@mnci/cli 4.29.2 → 4.31.0

package/dist/cli.js

@@ -2563,6 +2563,19 @@ function csharpConsoleProgram(identity) {
 Console.WriteLine(GreetUseCase.Greet("world").Message);
 `;
 }
+function csharpExampleTest(identity) {
+  return `using ${identity};
+
+public class GreetUseCaseTests
+{
+    [Fact]
+    public void GreetsAName()
+    {
+        Assert.Equal("Hello, world!", GreetUseCase.Greet("world").Message);
+    }
+}
+`;
+}
 
 // src/project-scaffolding/post-generation.use-case.ts
 var import_node_fs5 = require("fs");
@@ -2970,6 +2983,21 @@ function writeCsharpExample(absoluteRoot, identity, kind) {
     writeFileEnsured((0, import_node_path6.join)(absoluteRoot, "Program.cs"), csharpConsoleProgram(identity));
   }
 }
+function addCsharpTestProject(workspaceRoot, projectRoot, identity) {
+  const name = (0, import_node_path6.basename)(projectRoot);
+  const testRoot = `tests/${name}`;
+  scaffoldDotnetProject(workspaceRoot, testRoot, `${identity}.Tests`, "xunit");
+  (0, import_node_fs6.rmSync)((0, import_node_path6.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
+  writeFileEnsured((0, import_node_path6.join)(workspaceRoot, testRoot, "GreetUseCaseTests.cs"), csharpExampleTest(identity));
+  writeFileEnsured(
+    (0, import_node_path6.join)(workspaceRoot, testRoot, "project.json"),
+    toJson({ name: `${name}-tests`, tags: ["type:csharp-test"] })
+  );
+  const reference = (0, import_node_path6.join)(workspaceRoot, projectRoot, `${identity}.csproj`);
+  if (runShell("dotnet", ["add", (0, import_node_path6.join)(workspaceRoot, testRoot), "reference", reference], workspaceRoot) !== 0) {
+    throw new Error(`dotnet add reference failed for ${testRoot}`);
+  }
+}
 function csharpAppPackageTarget(tag, projectRoot, name) {
   const outDir = `dist/apps/${name}`;
   const zip = `dist/drop/${tag}-${name}.zip`;
@@ -2994,6 +3022,7 @@ function addCsharpApp(workspaceRoot, name, template = "console") {
   const projectRoot = `apps/${name}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, pascalCase(name), template);
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), pascalCase(name), template);
+  addCsharpTestProject(workspaceRoot, projectRoot, pascalCase(name));
   addProjectJsonTargets((0, import_node_path6.join)(workspaceRoot, projectRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-app", projectRoot, name),
     start: csharpAppStartTarget(projectRoot)
@@ -3118,6 +3147,7 @@ async function addCsharpLib(workspaceRoot, name, options, kindProvided) {
   const identity = `${pascalScope(scope)}.${pascalCase(name)}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), identity, "classlib");
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   addInitialVersion((0, import_node_path6.join)(workspaceRoot, projectRoot, `${identity}.csproj`));
   writeCsharpVersionActions(workspaceRoot);
   addProjectJsonReleaseVersionActions((0, import_node_path6.join)(workspaceRoot, projectRoot, "project.json"));
@@ -3135,6 +3165,7 @@ function addCsharpInternalLib(workspaceRoot, name) {
   const identity = pascalCase(name);
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
   writeCsharpExample((0, import_node_path6.join)(workspaceRoot, projectRoot), identity, "classlib");
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   registerProjectCommands(workspaceRoot, name, { build: false });
   logger.step(
     `Reference it from a consumer with: dotnet add <consumer>.csproj reference ${projectRoot}/${identity}.csproj`
@@ -3214,6 +3245,7 @@ function addCsharpFunctionApp(workspaceRoot, name) {
   if (runShell("dotnet", ["restore", projectRoot], workspaceRoot) !== 0) {
     throw new Error(`dotnet restore failed for ${projectRoot}`);
   }
+  addCsharpTestProject(workspaceRoot, projectRoot, identity);
   addProjectJsonTargets((0, import_node_path6.join)(absoluteRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-function-app", projectRoot, name),
     start: csharpFunctionAppStartTarget(projectRoot)
@@ -3278,6 +3310,72 @@ function addFlutterInternalLib(workspaceRoot, name) {
 var import_node_fs10 = require("fs");
 var import_node_path11 = require("path");
 
+// src/project-scaffolding/go-example.algorithm.ts
+function greetingContract(packageName) {
+  return [
+    `package ${packageName}`,
+    "",
+    "// Greeting is what greeting someone returns.",
+    "type Greeting struct {",
+    "	Message string",
+    "}",
+    ""
+  ].join("\n");
+}
+function greetUseCase(packageName) {
+  return [
+    `package ${packageName}`,
+    "",
+    "// Greet greets someone by name: a worked example of a use case. Replace it with your own.",
+    "func Greet(name string) Greeting {",
+    '	return Greeting{Message: "Hello, " + name + "!"}',
+    "}",
+    ""
+  ].join("\n");
+}
+function greetUseCaseTest(packageName) {
+  return [
+    `package ${packageName}`,
+    "",
+    'import "testing"',
+    "",
+    "func TestGreet(t *testing.T) {",
+    '	if got := Greet("world").Message; got != "Hello, world!" {',
+    '		t.Fatalf("got %q", got)',
+    "	}",
+    "}",
+    ""
+  ].join("\n");
+}
+function goLibraryExampleFiles(packageName, fileStem) {
+  return {
+    "greeting_contract.go": greetingContract(packageName),
+    [`${fileStem}_use_case.go`]: greetUseCase(packageName),
+    [`${fileStem}_use_case_test.go`]: greetUseCaseTest(packageName)
+  };
+}
+function goAppExampleFiles(modulePath) {
+  return {
+    "main.go": [
+      "package main",
+      "",
+      "import (",
+      '	"fmt"',
+      "",
+      `	"${modulePath}/hello"`,
+      ")",
+      "",
+      "func main() {",
+      '	fmt.Println(hello.Greet("world").Message)',
+      "}",
+      ""
+    ].join("\n"),
+    "hello/greeting_contract.go": greetingContract("hello"),
+    "hello/greet_use_case.go": greetUseCase("hello"),
+    "hello/greet_use_case_test.go": greetUseCaseTest("hello")
+  };
+}
+
 // src/go-workspace/go-plugin.use-case.ts
 var import_node_fs7 = require("fs");
 var import_node_path8 = require("path");
@@ -3715,6 +3813,18 @@ function setGoModulePath(workspaceRoot, projectDir) {
   const rewritten = (0, import_node_fs10.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
   writeFileEnsured(goModPath, rewritten);
 }
+function writeGoAppExample(workspaceRoot, projectDir) {
+  const goModPath = (0, import_node_path11.join)(workspaceRoot, projectDir, "go.mod");
+  const modulePath = fileExists(goModPath) ? /^module\s+(\S+)/m.exec((0, import_node_fs10.readFileSync)(goModPath, "utf8"))?.[1] : void 0;
+  if (modulePath === void 0) {
+    return;
+  }
+  (0, import_node_fs10.rmSync)((0, import_node_path11.join)(workspaceRoot, projectDir, "main_test.go"), { force: true });
+  const example = goAppExampleFiles(modulePath);
+  for (const [relative, contents] of Object.entries(example)) {
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, projectDir, relative), contents);
+  }
+}
 function goTestTarget() {
   return { executor: "@nx-go/nx-go:test" };
 }
@@ -3834,7 +3944,7 @@ function goLibraryIdentifiers(projectName) {
   };
 }
 function reshapeGoLibraryScaffold(projectRoot, projectName) {
-  const { packageName, functionName, fileStem } = goLibraryIdentifiers(projectName);
+  const { packageName, fileStem } = goLibraryIdentifiers(projectName);
   (0, import_node_fs10.rmSync)((0, import_node_path11.join)(projectRoot, `${projectName}.go`), { force: true });
   (0, import_node_fs10.rmSync)((0, import_node_path11.join)(projectRoot, `${projectName}_test.go`), { force: true });
   const files = [
@@ -3852,29 +3962,10 @@ package ${packageName}
 package ${packageName}
 `
     ],
-    [
-      (0, import_node_path11.join)(packageName, `${fileStem}_use_case.go`),
-      `package ${packageName}
-
-// ${functionName} is the generator's sample behaviour, kept so the slice builds and tests.
-func ${functionName}(name string) string {
-	return "${functionName} " + name
-}
-`
-    ],
-    [
-      (0, import_node_path11.join)(packageName, `${fileStem}_use_case_test.go`),
-      `package ${packageName}
-
-import "testing"
-
-func Test${functionName}(t *testing.T) {
-	if got := ${functionName}("works"); got != "${functionName} works" {
-		t.Fatalf("got %q", got)
-	}
-}
-`
-    ]
+    // The starter slice: a contract, a use case and its test (see goLibraryExampleFiles).
+    ...Object.entries(goLibraryExampleFiles(packageName, fileStem)).map(
+      ([name, content]) => [(0, import_node_path11.join)(packageName, name), content]
+    )
   ];
   for (const [relativePath, content] of files) {
     const path = (0, import_node_path11.join)(projectRoot, relativePath);
@@ -3912,6 +4003,9 @@ function addGoApp(workspaceRoot, name, options = {}) {
     workspaceRoot
   );
   setGoModulePath(workspaceRoot, `apps/${name}`);
+  if (options.web === void 0) {
+    writeGoAppExample(workspaceRoot, `apps/${name}`);
+  }
   addProjectJsonTargets((0, import_node_path11.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
@@ -3951,6 +4045,7 @@ function addGoFunctionApp(workspaceRoot, name) {
     workspaceRoot
   );
   setGoModulePath(workspaceRoot, `apps/${name}`);
+  writeGoAppExample(workspaceRoot, `apps/${name}`);
   addProjectJsonTargets((0, import_node_path11.join)(workspaceRoot, "apps", name, "project.json"), {
     "build": goBuildTarget(name),
     "test": goTestTarget(),