basic template writing and .gitignore

Author: alexrozanski

lib/file/template.ts

@@ -0,0 +1,42 @@
+import cxxUmbrella from "../../templates/cxx/umbrella.h.mustache";
+import executableMainSwift from "../../templates/executable/main.swift.mustache";
+import gitignore from "../../templates/git/.gitignore.mustache";
+import libraryMainSwift from "../../templates/library/main.swift.mustache";
+import testCaseSwift from "../../templates/test/testCase.swift.mustache";
+
+import Mustache from "mustache";
+
+export type Template =
+  | { template: "gitignore"; props: {} } // Doesn't need to be run through Mustache but this makes this easier
+  | { template: "cxx/umbrella"; props: { targetName: string } }
+  | { template: "swift/executable/main"; props: { targetName: string } }
+  | { template: "swift/library/main"; props: { targetName: string } }
+  | { template: "swift/plugin/main"; props: { targetName: string } }
+  | { template: "swift/supporting/main"; props: { targetName: string } }
+  | { template: "swift/test/testCase"; props: { targetName: string } };
+
+// Use imports so we don't have to mess around with files on disk, and they all get bundled into the distribution.
+const getTemplateContents = (template: Template) => {
+  switch (template.template) {
+    case "gitignore":
+      return gitignore;
+    case "cxx/umbrella":
+      return cxxUmbrella;
+    case "swift/executable/main":
+      return executableMainSwift;
+    case "swift/library/main":
+      return libraryMainSwift;
+    case "swift/plugin/main":
+      return "";
+    case "swift/supporting/main":
+      return "";
+    case "swift/test/testCase":
+      return testCaseSwift;
+  }
+};
+
+export const evaluateTemplate = (template: Template) => {
+  const contents = getTemplateContents(template);
+  const { props } = template;
+  return Mustache.render(contents, props);
+};

lib/package/create.ts

@@ -4,16 +4,32 @@ import path from "path";
 import { packageFile } from ".";
 import { type CliOptions } from "../cli";
 import { type Config } from "../config";
+import { evaluateTemplate } from "../file/template";
 import { formatDirectoryTree, type Node } from "../format/directory";
 import { writeSwiftFile } from "../swift/file";
 import { canWrite, exists } from "../util/fs";
 import { makePackageDescription } from "./description";
 import { type Target } from "./target";
 
-const writeTarget = async (config: Config, target: Target) => {
-  fs.promises.mkdir(path.join(config.projectDir, "Sources", target.name), {
-    recursive: true,
-  });
+const writeTarget = async (config: Config, target: Target, cli: CliOptions) => {
+  const targetBase = path.join(config.projectDir, "Sources", target.name);
+
+  if (!cli.dryRun) {
+    fs.promises.mkdir(targetBase, {
+      recursive: true,
+    });
+  }
+
+  await Promise.all(
+    target.files.map(async (file) => {
+      const contents = evaluateTemplate(file.template);
+      const filePath = path.join(targetBase, file.path);
+      const { dir } = path.parse(filePath);
+
+      await fs.promises.mkdir(dir, { recursive: true });
+      return await fs.promises.writeFile(filePath, contents);
+    })
+  );
 };
 
 const relativePath = (pathInTarget: string, target: Target) => {
@@ -27,6 +43,7 @@ const packageFiles = (config: Config, targets: Target[]) => {
         target.files.map((file) => relativePath(file.path, target))
       ),
       "Package.swift",
+      ".gitignore",
     ],
     targetPaths: targets.map((target) => relativePath("/", target)),
   };
@@ -118,9 +135,15 @@ export const createPackage = async (props: {
       path.join(config.projectDir, "Package.swift"),
       writeSwiftFile(file)
     );
-    await Promise.all(targets.map((target) => writeTarget(config, target)));
+
+    await fs.promises.writeFile(
+      path.join(config.projectDir, ".gitignore"),
+      evaluateTemplate({ template: "gitignore", props: {} })
+    );
   }
 
+  await Promise.all(targets.map((target) => writeTarget(config, target, cli)));
+
   console.log(
     formatDirectoryTree(
       makeDirectoryStructure(config, packageFiles(config, targets))

lib/package/index.ts

@@ -24,6 +24,10 @@ const productValue = (
   }
 };
 
+/**
+ * General purpose AST for Package.swift. This should be easy to modify for different versions
+ * of Swift or if this format changes.
+ */
 export const packageFile = (description: PackageDescription): SwiftFile => {
   return {
     headerComment: `swift-tools-version: ${description.toolsVersion}`,

lib/package/target.ts

@@ -1,9 +1,11 @@
 import path from "path";
 import { Config, LanguageOptions } from "../config";
+import { type Template } from "../file/template";
+import { ProductType } from "../swift/types";
 
 export type TargetFile = {
   path: string; // Relative path of the file within the target's folder
-  template: string; // Relative path to the template in `templates`
+  template: Template;
 };
 type TargetRole = "main" | "supporting" | "test";
 export type TargetLanguage = "swift" | "cfamily";
@@ -41,19 +43,35 @@ const makeFiles = (
   language: TargetLanguage,
   config: Config,
   templates: {
-    swiftTemplate: string;
-    cxxTemplates: { header: string; implementation: string };
+    swiftTemplate: Template;
+    cxxTemplates: { header?: Template; implementation?: Template };
   }
 ) => {
   const { swiftTemplate, cxxTemplates } = templates;
   switch (language) {
     case "cfamily": {
       const { header, implementation } = cxxTemplates;
       const headerPath = cIncludePath(config.language) || "include";
-      return [
-        { path: path.join(headerPath, `${name}.h`), template: header },
-        { path: `${name}.m`, template: implementation },
-      ];
+      const headerFile =
+        header != null
+          ? { path: path.join(headerPath, `${name}.h`), template: header }
+          : null;
+      const implementationFile =
+        implementation != null
+          ? {
+              path: path.join(headerPath, `${name}.m`),
+              template: implementation,
+            }
+          : null;
+
+      var files: TargetFile[] = [];
+      if (headerFile != null) {
+        files.push(headerFile);
+      }
+      if (implementationFile != null) {
+        files.push(implementationFile);
+      }
+      return files;
     }
     case "swift":
       return [{ path: `${name}.swift`, template: swiftTemplate }];
@@ -62,6 +80,7 @@ const makeFiles = (
 
 const makeMainTarget = (
   mainName: string,
+  productType: ProductType,
   language: TargetLanguage,
   dependencies: Target[],
   config: Config
@@ -71,8 +90,11 @@ const makeMainTarget = (
   language,
   dependencies,
   files: makeFiles(mainName, language, config, {
-    swiftTemplate: "",
-    cxxTemplates: { header: "", implementation: "" },
+    swiftTemplate: {
+      template: `swift/${productType}/main`,
+      props: { targetName: mainName },
+    },
+    cxxTemplates: {},
   }),
 });
 
@@ -87,8 +109,11 @@ const makeSupportingTarget = (
   language,
   dependencies,
   files: makeFiles(name, language, config, {
-    swiftTemplate: "",
-    cxxTemplates: { header: "", implementation: "" },
+    swiftTemplate: {
+      template: "swift/supporting/main",
+      props: { targetName: name },
+    },
+    cxxTemplates: {},
   }),
 });
 
@@ -98,25 +123,29 @@ const makeTestTarget = (mainTarget: Target, config: Config): Target => ({
   language: mainTarget.language,
   dependencies: [mainTarget],
   files: makeFiles(`${mainTarget.name}Tests`, mainTarget.language, config, {
-    swiftTemplate: "",
-    cxxTemplates: { header: "", implementation: "" },
+    swiftTemplate: {
+      template: "swift/test/testCase",
+      props: { targetName: mainTarget.name },
+    },
+    cxxTemplates: {},
   }),
 });
 
 /* Public */
 
 export const makeTargets = (config: Config): Target[] => {
   const targets: Target[] = [];
+  const { productType, language } = config;
 
   const mainName = mainTargetName(config);
   let mainTarget: Target;
-  switch (config.language.type) {
+  switch (language.type) {
     case "cfamily":
-      mainTarget = makeMainTarget(mainName, "cfamily", [], config);
+      mainTarget = makeMainTarget(mainName, productType, "cfamily", [], config);
       targets.push(mainTarget);
       break;
     case "swift":
-      mainTarget = makeMainTarget(mainName, "swift", [], config);
+      mainTarget = makeMainTarget(mainName, productType, "swift", [], config);
       targets.push(mainTarget);
       break;
     case "mixed":
@@ -126,7 +155,13 @@ export const makeTargets = (config: Config): Target[] => {
         [],
         config
       );
-      mainTarget = makeMainTarget(mainName, "swift", [objCxx], config);
+      mainTarget = makeMainTarget(
+        mainName,
+        productType,
+        "swift",
+        [objCxx],
+        config
+      );
       targets.push(mainTarget);
       targets.push(objCxx);
       break;

package-lock.json

@@ -4,7 +4,7 @@
   "description": "An interactive and more fully-featured alternative to swift package init",
   "main": "index.js",
   "scripts": {
-    "dev": "esbuild index.ts --bundle --outdir=dist --platform=node --watch",
+    "dev": "esbuild index.ts --bundle --outdir=dist --platform=node --watch --loader:.mustache=text",
     "test": "jest",
     "unit": "NODE_OPTIONS='--experimental-vm-modules' jest \"test/unit\""
   },
@@ -26,6 +26,7 @@
   "devDependencies": {
     "@types/jest": "^29.5.1",
     "@types/lodash": "^4.14.194",
+    "@types/mustache": "^4.2.2",
     "@types/node": "^18.16.2",
     "@types/prompts": "2.0.1",
     "@types/tmp": "^0.2.3",

package.json

@@ -0,0 +1,7 @@
+//
+//  {{targetName}}.h
+//
+
+// This is your target's umbrella header. Import public-facing headers here.
+//
+// #import "MyHeader.h"

templates/cxx/umbrella.h.mustache

@@ -0,0 +1,7 @@
+@main
+public struct {{targetName}} {
+    public static func main() {
+        print("Hello from Swift 🤘")
+        exit(0)
+    }
+}

templates/executable/main.swift.mustache

@@ -0,0 +1,10 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc
+

templates/git/.gitignore.mustache

@@ -0,0 +1,3 @@
+public struct {{targetName}} {
+    public init() {}
+}

templates/library/main.swift.mustache

@@ -0,0 +1,28 @@
+#import <XCTest/XCTest.h>
+
+@interface {{targetName}}Tests : XCTestCase
+@end
+
+@implementation MyLibraryTests
+
+- (void)setUp {
+    [super setUp];
+
+    // Peform shared test setup here.
+}
+
+- (void)tearDown {
+    // Peform shared test teardown here.
+
+    [super tearDown];
+}
+
+- (void)testExample {
+    NSString *input = @"Hello, MyLibrary!";
+    NSString *expectedOutput = @"Processed: Hello, MyLibrary!";
+
+    NSString *actualOutput = [self.myLibrary processString:input];
+    XCTAssertEqualObjects(expectedOutput, actualOutput, @"MyLibrary should correctly process strings");
+}
+
+@end

templates/test/TestCase.m.mustache

@@ -0,0 +1,8 @@
+import XCTest
+@testable import {{targetName}}
+
+final class libraryTests: XCTestCase {
+    func testExample() throws {
+        XCTAssertEqual(library().text, "Hello, World!")
+    }
+}

templates/test/testCase.swift.mustache

@@ -2,3 +2,7 @@ declare module "*.yml" {
   const content: { [key: string]: any };
   export default content;
 }
+declare module "*.mustache" {
+  const content: string;
+  export default content;
+}