From 7aa4e5486d0b0fde623079dd553733a83c2802c0 Mon Sep 17 00:00:00 2001 From: Virgil Date: Thu, 26 Mar 2026 17:41:53 +0000 Subject: [PATCH] chore(ax): finish v0.8.0 polish pass Co-Authored-By: Virgil --- cmd/build/cmd_build.go | 1 + cmd/build/cmd_project.go | 110 +++--- cmd/build/cmd_pwa.go | 147 ++++---- cmd/build/cmd_release.go | 5 +- cmd/build/cmd_sdk.go | 38 +-- cmd/ci/ci.go | 19 +- cmd/ci/cmd.go | 1 + cmd/sdk/cmd.go | 8 +- go.mod | 1 + go.sum | 148 +-------- internal/ax/ax.go | 350 ++++++++++++++++++++ locales/embed.go | 2 + pkg/api/embed.go | 2 + pkg/api/provider.go | 24 +- pkg/api/provider_test.go | 28 +- pkg/build/archive.go | 30 +- pkg/build/archive_test.go | 83 ++--- pkg/build/build.go | 6 + pkg/build/builders/cpp.go | 42 ++- pkg/build/builders/cpp_test.go | 44 +-- pkg/build/builders/docker.go | 70 ++-- pkg/build/builders/docker_test.go | 22 +- pkg/build/builders/go.go | 38 +-- pkg/build/builders/go_test.go | 34 +- pkg/build/builders/linuxkit.go | 60 ++-- pkg/build/builders/linuxkit_test.go | 62 ++-- pkg/build/builders/taskfile.go | 93 +++--- pkg/build/builders/taskfile_test.go | 66 ++-- pkg/build/builders/wails.go | 55 ++- pkg/build/builders/wails_test.go | 74 ++--- pkg/build/checksum.go | 3 + pkg/build/checksum_test.go | 42 ++- pkg/build/config.go | 21 +- pkg/build/config_test.go | 44 +-- pkg/build/discovery.go | 24 +- pkg/build/discovery_test.go | 40 +-- pkg/build/signing/codesign.go | 34 +- pkg/build/signing/codesign_test.go | 12 +- pkg/build/signing/gpg.go | 15 +- pkg/build/signing/gpg_test.go | 8 +- pkg/build/signing/sign.go | 12 +- pkg/build/signing/signer.go | 65 +++- pkg/build/signing/signing_test.go | 34 +- pkg/build/signing/signtool.go | 5 + pkg/release/changelog.go | 19 +- pkg/release/changelog_test.go | 71 ++-- pkg/release/config.go | 40 ++- pkg/release/config_test.go | 60 ++-- pkg/release/publishers/aur.go | 117 +++---- pkg/release/publishers/aur_test.go | 32 +- pkg/release/publishers/chocolatey.go | 103 +++--- pkg/release/publishers/chocolatey_test.go | 67 ++-- pkg/release/publishers/docker.go | 97 +++--- pkg/release/publishers/docker_test.go | 194 ++++------- pkg/release/publishers/github.go | 105 +++--- pkg/release/publishers/github_test.go | 156 +++------ pkg/release/publishers/homebrew.go | 123 ++++--- pkg/release/publishers/homebrew_test.go | 69 ++-- pkg/release/publishers/integration_test.go | 295 +++++------------ pkg/release/publishers/linuxkit.go | 94 +++--- pkg/release/publishers/linuxkit_test.go | 303 +++++------------ pkg/release/publishers/npm.go | 87 +++-- pkg/release/publishers/npm_test.go | 59 +--- pkg/release/publishers/output.go | 38 +++ pkg/release/publishers/publisher.go | 6 + pkg/release/publishers/scoop.go | 101 +++--- pkg/release/publishers/scoop_test.go | 66 ++-- pkg/release/publishers/test_helpers_test.go | 32 ++ pkg/release/release.go | 34 +- pkg/release/release_test.go | 203 ++++++------ pkg/release/sdk.go | 2 + pkg/release/sdk_test.go | 26 +- pkg/release/test_helpers_test.go | 14 + pkg/release/version.go | 27 +- pkg/release/version_test.go | 75 ++--- pkg/sdk/breaking_test.go | 142 ++++---- pkg/sdk/detect.go | 10 +- pkg/sdk/detect_test.go | 28 +- pkg/sdk/diff.go | 3 + pkg/sdk/diff_test.go | 24 +- pkg/sdk/generation_test.go | 68 ++-- pkg/sdk/generators/docker_runtime.go | 10 +- pkg/sdk/generators/generator.go | 12 +- pkg/sdk/generators/go.go | 37 +-- pkg/sdk/generators/go_test.go | 12 +- pkg/sdk/generators/php.go | 20 +- pkg/sdk/generators/php_test.go | 12 +- pkg/sdk/generators/python.go | 29 +- pkg/sdk/generators/python_test.go | 12 +- pkg/sdk/generators/typescript.go | 38 +-- pkg/sdk/generators/typescript_test.go | 23 +- pkg/sdk/sdk.go | 14 +- pkg/sdk/sdk_test.go | 16 +- 93 files changed, 2526 insertions(+), 2721 deletions(-) create mode 100644 internal/ax/ax.go create mode 100644 pkg/release/publishers/output.go create mode 100644 pkg/release/publishers/test_helpers_test.go create mode 100644 pkg/release/test_helpers_test.go diff --git a/cmd/build/cmd_build.go b/cmd/build/cmd_build.go index 07974ed..2249b1e 100644 --- a/cmd/build/cmd_build.go +++ b/cmd/build/cmd_build.go @@ -140,6 +140,7 @@ func initBuildFlags() { } // AddBuildCommands registers the 'build' command and all subcommands. +// Usage example: call buildcmd.AddBuildCommands(...) from integrating code. func AddBuildCommands(root *cli.Command) { setBuildI18n() initBuildFlags() diff --git a/cmd/build/cmd_project.go b/cmd/build/cmd_project.go index 1e32a64..8eee9a7 100644 --- a/cmd/build/cmd_project.go +++ b/cmd/build/cmd_project.go @@ -7,19 +7,17 @@ package buildcmd import ( "context" - "encoding/json" - "fmt" - "os" - "path/filepath" "runtime" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/build/pkg/build/builders" "dappco.re/go/core/build/pkg/build/signing" "dappco.re/go/core/i18n" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" + "forge.lthn.ai/core/cli/pkg/cli" ) // runProjectBuild handles the main `core build` command with auto-detection. @@ -28,7 +26,7 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets fs := io.Local // Get current working directory as project root - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return coreerr.E("build.Run", "failed to get working directory", err) } @@ -78,14 +76,14 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets if outputDir == "" { outputDir = "dist" } - if !filepath.IsAbs(outputDir) { - outputDir = filepath.Join(projectDir, outputDir) + if !ax.IsAbs(outputDir) { + outputDir = ax.Join(projectDir, outputDir) } - outputDir = filepath.Clean(outputDir) + outputDir = ax.Clean(outputDir) // Ensure config path is absolute if provided - if configPath != "" && !filepath.IsAbs(configPath) { - configPath = filepath.Join(projectDir, configPath) + if configPath != "" && !ax.IsAbs(configPath) { + configPath = ax.Join(projectDir, configPath) } // Determine binary name @@ -94,17 +92,17 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets binaryName = buildCfg.Project.Name } if binaryName == "" { - binaryName = filepath.Base(projectDir) + binaryName = ax.Base(projectDir) } // Print build info (verbose mode only) if verbose && !ciMode { - fmt.Printf("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.build")), i18n.T("cmd.build.building_project")) - fmt.Printf(" %s %s\n", i18n.T("cmd.build.label.type"), buildTargetStyle.Render(string(projectType))) - fmt.Printf(" %s %s\n", i18n.T("cmd.build.label.output"), buildTargetStyle.Render(outputDir)) - fmt.Printf(" %s %s\n", i18n.T("cmd.build.label.binary"), buildTargetStyle.Render(binaryName)) - fmt.Printf(" %s %s\n", i18n.T("cmd.build.label.targets"), buildTargetStyle.Render(formatTargets(buildTargets))) - fmt.Println() + cli.Print("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.build")), i18n.T("cmd.build.building_project")) + cli.Print(" %s %s\n", i18n.T("cmd.build.label.type"), buildTargetStyle.Render(string(projectType))) + cli.Print(" %s %s\n", i18n.T("cmd.build.label.output"), buildTargetStyle.Render(outputDir)) + cli.Print(" %s %s\n", i18n.T("cmd.build.label.binary"), buildTargetStyle.Render(binaryName)) + cli.Print(" %s %s\n", i18n.T("cmd.build.label.targets"), buildTargetStyle.Render(formatTargets(buildTargets))) + cli.Blank() } // Get the appropriate builder @@ -131,30 +129,30 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets // Parse formats for LinuxKit if format != "" { - cfg.Formats = strings.Split(format, ",") + cfg.Formats = core.Split(format, ",") } // Execute build artifacts, err := builder.Build(ctx, cfg, buildTargets) if err != nil { if !ciMode { - fmt.Printf("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) + cli.Print("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) } return err } if verbose && !ciMode { - fmt.Printf("%s %s\n", buildSuccessStyle.Render(i18n.T("common.label.success")), i18n.T("cmd.build.built_artifacts", map[string]any{"Count": len(artifacts)})) - fmt.Println() + cli.Print("%s %s\n", buildSuccessStyle.Render(i18n.T("common.label.success")), i18n.T("cmd.build.built_artifacts", map[string]any{"Count": len(artifacts)})) + cli.Blank() for _, artifact := range artifacts { - relPath, err := filepath.Rel(projectDir, artifact.Path) + relPath, err := ax.Rel(projectDir, artifact.Path) if err != nil { relPath = artifact.Path } - fmt.Printf(" %s %s %s\n", + cli.Print(" %s %s %s\n", buildSuccessStyle.Render("*"), buildTargetStyle.Render(relPath), - buildDimStyle.Render(fmt.Sprintf("(%s/%s)", artifact.OS, artifact.Arch)), + buildDimStyle.Render(core.Sprintf("(%s/%s)", artifact.OS, artifact.Arch)), ) } } @@ -170,8 +168,8 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets if signCfg.Enabled && runtime.GOOS == "darwin" { if verbose && !ciMode { - fmt.Println() - fmt.Printf("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.sign")), i18n.T("cmd.build.signing_binaries")) + cli.Blank() + cli.Print("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.sign")), i18n.T("cmd.build.signing_binaries")) } // Convert build.Artifact to signing.Artifact @@ -182,7 +180,7 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets if err := signing.SignBinaries(ctx, fs, signCfg, signingArtifacts); err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.signing_failed"), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.signing_failed"), err) } return err } @@ -190,7 +188,7 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets if signCfg.MacOS.Notarize { if err := signing.NotarizeBinaries(ctx, fs, signCfg, signingArtifacts); err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.notarization_failed"), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.notarization_failed"), err) } return err } @@ -201,28 +199,28 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets var archivedArtifacts []build.Artifact if doArchive && len(artifacts) > 0 { if verbose && !ciMode { - fmt.Println() - fmt.Printf("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.archive")), i18n.T("cmd.build.creating_archives")) + cli.Blank() + cli.Print("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.archive")), i18n.T("cmd.build.creating_archives")) } archivedArtifacts, err = build.ArchiveAll(fs, artifacts) if err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.archive_failed"), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.archive_failed"), err) } return err } if verbose && !ciMode { for _, artifact := range archivedArtifacts { - relPath, err := filepath.Rel(projectDir, artifact.Path) + relPath, err := ax.Rel(projectDir, artifact.Path) if err != nil { relPath = artifact.Path } - fmt.Printf(" %s %s %s\n", + cli.Print(" %s %s %s\n", buildSuccessStyle.Render("*"), buildTargetStyle.Render(relPath), - buildDimStyle.Render(fmt.Sprintf("(%s/%s)", artifact.OS, artifact.Arch)), + buildDimStyle.Render(core.Sprintf("(%s/%s)", artifact.OS, artifact.Arch)), ) } } @@ -256,17 +254,17 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets } // JSON output for CI - output, err := json.MarshalIndent(outputArtifacts, "", " ") + output, err := ax.JSONMarshal(outputArtifacts) if err != nil { return coreerr.E("build.Run", "failed to marshal artifacts", err) } - fmt.Println(string(output)) + cli.Print("%s\n", output) } else if !verbose { // Minimal output: just success with artifact count - fmt.Printf("%s %s %s\n", + cli.Print("%s %s %s\n", buildSuccessStyle.Render(i18n.T("common.label.success")), i18n.T("cmd.build.built_artifacts", map[string]any{"Count": len(artifacts)}), - buildDimStyle.Render(fmt.Sprintf("(%s)", outputDir)), + buildDimStyle.Render(core.Sprintf("(%s)", outputDir)), ) } @@ -277,23 +275,23 @@ func runProjectBuild(ctx context.Context, buildType string, ciMode bool, targets func computeAndWriteChecksums(ctx context.Context, projectDir, outputDir string, artifacts []build.Artifact, signCfg signing.SignConfig, ciMode bool, verbose bool) ([]build.Artifact, error) { fs := io.Local if verbose && !ciMode { - fmt.Println() - fmt.Printf("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.checksum")), i18n.T("cmd.build.computing_checksums")) + cli.Blank() + cli.Print("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.label.checksum")), i18n.T("cmd.build.computing_checksums")) } checksummedArtifacts, err := build.ChecksumAll(fs, artifacts) if err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.checksum_failed"), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.checksum_failed"), err) } return nil, err } // Write CHECKSUMS.txt - checksumPath := filepath.Join(outputDir, "CHECKSUMS.txt") + checksumPath := ax.Join(outputDir, "CHECKSUMS.txt") if err := build.WriteChecksumFile(fs, checksummedArtifacts, checksumPath); err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("common.error.failed", map[string]any{"Action": "write CHECKSUMS.txt"}), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("common.error.failed", map[string]any{"Action": "write CHECKSUMS.txt"}), err) } return nil, err } @@ -302,7 +300,7 @@ func computeAndWriteChecksums(ctx context.Context, projectDir, outputDir string, if signCfg.Enabled { if err := signing.SignChecksums(ctx, fs, signCfg, checksumPath); err != nil { if !ciMode { - fmt.Printf("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.gpg_signing_failed"), err) + cli.Print("%s %s: %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), i18n.T("cmd.build.error.gpg_signing_failed"), err) } return nil, err } @@ -310,22 +308,22 @@ func computeAndWriteChecksums(ctx context.Context, projectDir, outputDir string, if verbose && !ciMode { for _, artifact := range checksummedArtifacts { - relPath, err := filepath.Rel(projectDir, artifact.Path) + relPath, err := ax.Rel(projectDir, artifact.Path) if err != nil { relPath = artifact.Path } - fmt.Printf(" %s %s\n", + cli.Print(" %s %s\n", buildSuccessStyle.Render("*"), buildTargetStyle.Render(relPath), ) - fmt.Printf(" %s\n", buildDimStyle.Render(artifact.Checksum)) + cli.Print(" %s\n", buildDimStyle.Render(artifact.Checksum)) } - relChecksumPath, err := filepath.Rel(projectDir, checksumPath) + relChecksumPath, err := ax.Rel(projectDir, checksumPath) if err != nil { relChecksumPath = checksumPath } - fmt.Printf(" %s %s\n", + cli.Print(" %s %s\n", buildSuccessStyle.Render("*"), buildTargetStyle.Render(relChecksumPath), ) @@ -336,23 +334,23 @@ func computeAndWriteChecksums(ctx context.Context, projectDir, outputDir string, // parseTargets parses a comma-separated list of OS/arch pairs. func parseTargets(targetsFlag string) ([]build.Target, error) { - parts := strings.Split(targetsFlag, ",") + parts := core.Split(targetsFlag, ",") var targets []build.Target for _, part := range parts { - part = strings.TrimSpace(part) + part = core.Trim(part) if part == "" { continue } - osArch := strings.Split(part, "/") + osArch := core.Split(part, "/") if len(osArch) != 2 { return nil, coreerr.E("build.parseTargets", "invalid target format (expected os/arch): "+part, nil) } targets = append(targets, build.Target{ - OS: strings.TrimSpace(osArch[0]), - Arch: strings.TrimSpace(osArch[1]), + OS: core.Trim(osArch[0]), + Arch: core.Trim(osArch[1]), }) } @@ -369,7 +367,7 @@ func formatTargets(targets []build.Target) string { for _, t := range targets { parts = append(parts, t.String()) } - return strings.Join(parts, ", ") + return core.Join(", ", parts...) } // getBuilder returns the appropriate builder for the project type. diff --git a/cmd/build/cmd_pwa.go b/cmd/build/cmd_pwa.go index fe1a8a1..7148a00 100644 --- a/cmd/build/cmd_pwa.go +++ b/cmd/build/cmd_pwa.go @@ -7,16 +7,13 @@ package buildcmd import ( - "encoding/json" - "fmt" + "context" "io" "net/http" "net/url" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/i18n" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -33,14 +30,14 @@ var ( // runPwaBuild downloads a PWA from URL and builds it. func runPwaBuild(pwaURL string) error { - fmt.Printf("%s %s\n", i18n.T("cmd.build.pwa.starting"), pwaURL) + core.Print(nil, "%s %s", i18n.T("cmd.build.pwa.starting"), pwaURL) - tempDir, err := os.MkdirTemp("", "core-pwa-build-*") + tempDir, err := ax.TempDir("core-pwa-build-*") if err != nil { return coreerr.E("pwa.runPwaBuild", i18n.T("common.error.failed", map[string]any{"Action": "create temporary directory"}), err) } // defer os.RemoveAll(tempDir) // Keep temp dir for debugging - fmt.Printf("%s %s\n", i18n.T("cmd.build.pwa.downloading_to"), tempDir) + core.Print(nil, "%s %s", i18n.T("cmd.build.pwa.downloading_to"), tempDir) if err := downloadPWA(pwaURL, tempDir); err != nil { return coreerr.E("pwa.runPwaBuild", i18n.T("common.error.failed", map[string]any{"Action": "download PWA"}), err) @@ -67,14 +64,14 @@ func downloadPWA(baseURL, destDir string) error { manifestURL, err := findManifestURL(string(body), baseURL) if err != nil { // If no manifest, it's not a PWA, but we can still try to package it as a simple site. - fmt.Printf("%s %s\n", i18n.T("common.label.warning"), i18n.T("cmd.build.pwa.no_manifest")) - if err := coreio.Local.Write(filepath.Join(destDir, "index.html"), string(body)); err != nil { + core.Print(nil, "%s %s", i18n.T("common.label.warning"), i18n.T("cmd.build.pwa.no_manifest")) + if err := coreio.Local.Write(ax.Join(destDir, "index.html"), string(body)); err != nil { return coreerr.E("pwa.downloadPWA", i18n.T("common.error.failed", map[string]any{"Action": "write index.html"}), err) } return nil } - fmt.Printf("%s %s\n", i18n.T("cmd.build.pwa.found_manifest"), manifestURL) + core.Print(nil, "%s %s", i18n.T("cmd.build.pwa.found_manifest"), manifestURL) // Fetch and parse the manifest manifest, err := fetchManifest(manifestURL) @@ -86,22 +83,22 @@ func downloadPWA(baseURL, destDir string) error { assets := collectAssets(manifest, manifestURL) for _, assetURL := range assets { if err := downloadAsset(assetURL, destDir); err != nil { - fmt.Printf("%s %s %s: %v\n", i18n.T("common.label.warning"), i18n.T("common.error.failed", map[string]any{"Action": "download asset"}), assetURL, err) + core.Print(nil, "%s %s %s: %v", i18n.T("common.label.warning"), i18n.T("common.error.failed", map[string]any{"Action": "download asset"}), assetURL, err) } } // Also save the root index.html - if err := coreio.Local.Write(filepath.Join(destDir, "index.html"), string(body)); err != nil { + if err := coreio.Local.Write(ax.Join(destDir, "index.html"), string(body)); err != nil { return coreerr.E("pwa.downloadPWA", i18n.T("common.error.failed", map[string]any{"Action": "write index.html"}), err) } - fmt.Println(i18n.T("cmd.build.pwa.download_complete")) + core.Println(i18n.T("cmd.build.pwa.download_complete")) return nil } // findManifestURL extracts the manifest URL from HTML content. func findManifestURL(htmlContent, baseURL string) (string, error) { - doc, err := html.Parse(strings.NewReader(htmlContent)) + doc, err := html.Parse(core.NewReader(htmlContent)) if err != nil { return "", err } @@ -155,8 +152,13 @@ func fetchManifest(manifestURL string) (map[string]any, error) { } defer func() { _ = resp.Body.Close() }() + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, err + } + var manifest map[string]any - if err := json.NewDecoder(resp.Body).Decode(&manifest); err != nil { + if err := ax.JSONUnmarshal(body, &manifest); err != nil { return nil, err } return manifest, nil @@ -203,12 +205,13 @@ func downloadAsset(assetURL, destDir string) error { return err } - path := filepath.Join(destDir, filepath.FromSlash(u.Path)) - if err := coreio.Local.EnsureDir(filepath.Dir(path)); err != nil { + assetPath := core.TrimPrefix(ax.FromSlash(u.Path), ax.DS()) + path := ax.Join(destDir, assetPath) + if err := coreio.Local.EnsureDir(ax.Dir(path)); err != nil { return err } - out, err := os.Create(path) + out, err := ax.Create(path) if err != nil { return err } @@ -220,16 +223,16 @@ func downloadAsset(assetURL, destDir string) error { // runBuild builds a desktop application from a local directory. func runBuild(fromPath string) error { - fmt.Printf("%s %s\n", i18n.T("cmd.build.from_path.starting"), fromPath) + core.Print(nil, "%s %s", i18n.T("cmd.build.from_path.starting"), fromPath) if !coreio.Local.IsDir(fromPath) { return coreerr.E("pwa.runBuild", i18n.T("cmd.build.from_path.error.must_be_directory"), nil) } buildDir := ".core/build/app" - htmlDir := filepath.Join(buildDir, "html") - appName := filepath.Base(fromPath) - if strings.HasPrefix(appName, "core-pwa-build-") { + htmlDir := ax.Join(buildDir, "html") + appName := ax.Base(fromPath) + if core.HasPrefix(appName, "core-pwa-build-") { appName = "pwa-app" } outputExe := appName @@ -239,7 +242,7 @@ func runBuild(fromPath string) error { } // 1. Generate the project from the embedded template - fmt.Println(i18n.T("cmd.build.from_path.generating_template")) + core.Println(i18n.T("cmd.build.from_path.generating_template")) templateFS, err := debme.FS(guiTemplate, "tmpl/gui") if err != nil { return coreerr.E("pwa.runBuild", i18n.T("common.error.failed", map[string]any{"Action": "anchor template filesystem"}), err) @@ -255,67 +258,75 @@ func runBuild(fromPath string) error { } // 2. Copy the user's web app files - fmt.Println(i18n.T("cmd.build.from_path.copying_files")) + core.Println(i18n.T("cmd.build.from_path.copying_files")) if err := copyDir(fromPath, htmlDir); err != nil { return coreerr.E("pwa.runBuild", i18n.T("common.error.failed", map[string]any{"Action": "copy application files"}), err) } // 3. Compile the application - fmt.Println(i18n.T("cmd.build.from_path.compiling")) + core.Println(i18n.T("cmd.build.from_path.compiling")) // Run go mod tidy - cmd := exec.Command("go", "mod", "tidy") - cmd.Dir = buildDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(context.Background(), buildDir, "go", "mod", "tidy"); err != nil { return coreerr.E("pwa.runBuild", i18n.T("cmd.build.from_path.error.go_mod_tidy"), err) } // Run go build - cmd = exec.Command("go", "build", "-o", outputExe) - cmd.Dir = buildDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(context.Background(), buildDir, "go", "build", "-o", outputExe); err != nil { return coreerr.E("pwa.runBuild", i18n.T("cmd.build.from_path.error.go_build"), err) } - fmt.Printf("\n%s %s/%s\n", i18n.T("cmd.build.from_path.success"), buildDir, outputExe) + core.Println() + core.Print(nil, "%s %s/%s", i18n.T("cmd.build.from_path.success"), buildDir, outputExe) return nil } // copyDir recursively copies a directory from src to dst. func copyDir(src, dst string) error { - return filepath.Walk(src, func(path string, info os.FileInfo, err error) error { - if err != nil { - return err - } - - relPath, err := filepath.Rel(src, path) - if err != nil { - return err - } - - dstPath := filepath.Join(dst, relPath) - - if info.IsDir() { - return coreio.Local.EnsureDir(dstPath) - } - - srcFile, err := os.Open(path) - if err != nil { - return err - } - defer func() { _ = srcFile.Close() }() - - dstFile, err := os.Create(dstPath) - if err != nil { - return err - } - defer func() { _ = dstFile.Close() }() - - _, err = io.Copy(dstFile, srcFile) + if err := coreio.Local.EnsureDir(dst); err != nil { return err - }) + } + + entries, err := coreio.Local.List(src) + if err != nil { + return err + } + + for _, entry := range entries { + srcPath := ax.Join(src, entry.Name()) + dstPath := ax.Join(dst, entry.Name()) + + if entry.IsDir() { + if err := copyDir(srcPath, dstPath); err != nil { + return err + } + continue + } + + srcFile, err := ax.Open(srcPath) + if err != nil { + return err + } + + dstFile, err := ax.Create(dstPath) + if err != nil { + _ = srcFile.Close() + return err + } + + if _, err := io.Copy(dstFile, srcFile); err != nil { + _ = srcFile.Close() + _ = dstFile.Close() + return err + } + if err := srcFile.Close(); err != nil { + _ = dstFile.Close() + return err + } + if err := dstFile.Close(); err != nil { + return err + } + } + + return nil } diff --git a/cmd/build/cmd_release.go b/cmd/build/cmd_release.go index bbec186..bef9738 100644 --- a/cmd/build/cmd_release.go +++ b/cmd/build/cmd_release.go @@ -4,8 +4,8 @@ package buildcmd import ( "context" - "os" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/release" "dappco.re/go/core/i18n" coreerr "dappco.re/go/core/log" @@ -40,6 +40,7 @@ func initReleaseFlags() { } // AddReleaseCommand adds the release subcommand to the build command. +// Usage example: call buildcmd.AddReleaseCommand(...) from integrating code. func AddReleaseCommand(buildCmd *cli.Command) { setReleaseI18n() initReleaseFlags() @@ -49,7 +50,7 @@ func AddReleaseCommand(buildCmd *cli.Command) { // runRelease executes the full release workflow: build + archive + checksum + publish. func runRelease(ctx context.Context, dryRun bool, version string, draft, prerelease bool) error { // Get current directory - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return coreerr.E("release", "get working directory", err) } diff --git a/cmd/build/cmd_sdk.go b/cmd/build/cmd_sdk.go index 9320c0a..cb9dda9 100644 --- a/cmd/build/cmd_sdk.go +++ b/cmd/build/cmd_sdk.go @@ -7,20 +7,20 @@ package buildcmd import ( "context" - "fmt" - "os" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/sdk" "dappco.re/go/core/i18n" coreerr "dappco.re/go/core/log" + "forge.lthn.ai/core/cli/pkg/cli" ) // runBuildSDK handles the `core build sdk` command. func runBuildSDK(specPath, lang, version string, dryRun bool) error { ctx := context.Background() - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return coreerr.E("build.SDK", "failed to get working directory", err) } @@ -36,48 +36,48 @@ func runBuildSDK(specPath, lang, version string, dryRun bool) error { s.SetVersion(version) } - fmt.Printf("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.sdk.label")), i18n.T("cmd.build.sdk.generating")) + cli.Print("%s %s\n", buildHeaderStyle.Render(i18n.T("cmd.build.sdk.label")), i18n.T("cmd.build.sdk.generating")) if dryRun { - fmt.Printf(" %s\n", buildDimStyle.Render(i18n.T("cmd.build.sdk.dry_run_mode"))) + cli.Print(" %s\n", buildDimStyle.Render(i18n.T("cmd.build.sdk.dry_run_mode"))) } - fmt.Println() + cli.Blank() // Detect spec detectedSpec, err := s.DetectSpec() if err != nil { - fmt.Printf("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) + cli.Print("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) return err } - fmt.Printf(" %s %s\n", i18n.T("common.label.spec"), buildTargetStyle.Render(detectedSpec)) + cli.Print(" %s %s\n", i18n.T("common.label.spec"), buildTargetStyle.Render(detectedSpec)) if dryRun { if lang != "" { - fmt.Printf(" %s %s\n", i18n.T("cmd.build.sdk.language_label"), buildTargetStyle.Render(lang)) + cli.Print(" %s %s\n", i18n.T("cmd.build.sdk.language_label"), buildTargetStyle.Render(lang)) } else { - fmt.Printf(" %s %s\n", i18n.T("cmd.build.sdk.languages_label"), buildTargetStyle.Render(strings.Join(config.Languages, ", "))) + cli.Print(" %s %s\n", i18n.T("cmd.build.sdk.languages_label"), buildTargetStyle.Render(core.Join(", ", config.Languages...))) } - fmt.Println() - fmt.Printf("%s %s\n", buildSuccessStyle.Render(i18n.T("cmd.build.label.ok")), i18n.T("cmd.build.sdk.would_generate")) + cli.Blank() + cli.Print("%s %s\n", buildSuccessStyle.Render(i18n.T("cmd.build.label.ok")), i18n.T("cmd.build.sdk.would_generate")) return nil } if lang != "" { // Generate single language if err := s.GenerateLanguage(ctx, lang); err != nil { - fmt.Printf("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) + cli.Print("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) return err } - fmt.Printf(" %s %s\n", i18n.T("cmd.build.sdk.generated_label"), buildTargetStyle.Render(lang)) + cli.Print(" %s %s\n", i18n.T("cmd.build.sdk.generated_label"), buildTargetStyle.Render(lang)) } else { // Generate all if err := s.Generate(ctx); err != nil { - fmt.Printf("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) + cli.Print("%s %v\n", buildErrorStyle.Render(i18n.T("common.label.error")), err) return err } - fmt.Printf(" %s %s\n", i18n.T("cmd.build.sdk.generated_label"), buildTargetStyle.Render(strings.Join(config.Languages, ", "))) + cli.Print(" %s %s\n", i18n.T("cmd.build.sdk.generated_label"), buildTargetStyle.Render(core.Join(", ", config.Languages...))) } - fmt.Println() - fmt.Printf("%s %s\n", buildSuccessStyle.Render(i18n.T("common.label.success")), i18n.T("cmd.build.sdk.complete")) + cli.Blank() + cli.Print("%s %s\n", buildSuccessStyle.Render(i18n.T("common.label.success")), i18n.T("cmd.build.sdk.complete")) return nil } diff --git a/cmd/ci/ci.go b/cmd/ci/ci.go index 5108200..77ecc23 100644 --- a/cmd/ci/ci.go +++ b/cmd/ci/ci.go @@ -2,10 +2,9 @@ package ci import ( "context" - "os" - "os/exec" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/release" "dappco.re/go/core/i18n" coreerr "dappco.re/go/core/log" @@ -96,7 +95,7 @@ func initCIFlags() { func runCIPublish(dryRun bool, version string, draft, prerelease bool) error { ctx := context.Background() - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return cli.WrapVerb(err, "get", "working directory") } @@ -155,7 +154,7 @@ func runCIPublish(dryRun bool, version string, draft, prerelease bool) error { // runCIReleaseInit scaffolds a release config. func runCIReleaseInit() error { - cwd, err := os.Getwd() + cwd, err := ax.Getwd() if err != nil { return cli.Err("%s: %w", i18n.T("i18n.fail.get", "working directory"), err) } @@ -184,7 +183,7 @@ func runCIReleaseInit() error { // runChangelog generates a changelog between two git refs. func runChangelog(fromRef, toRef string) error { - cwd, err := os.Getwd() + cwd, err := ax.Getwd() if err != nil { return cli.Err("%s: %w", i18n.T("i18n.fail.get", "working directory"), err) } @@ -217,7 +216,7 @@ func runChangelog(fromRef, toRef string) error { // runCIReleaseVersion shows the determined version. func runCIReleaseVersion() error { - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return cli.WrapVerb(err, "get", "working directory") } @@ -232,11 +231,9 @@ func runCIReleaseVersion() error { } func latestTag(dir string) (string, error) { - cmd := exec.Command("git", "describe", "--tags", "--abbrev=0") - cmd.Dir = dir - out, err := cmd.Output() + out, err := ax.RunDir(context.Background(), dir, "git", "describe", "--tags", "--abbrev=0") if err != nil { return "", err } - return strings.TrimSpace(string(out)), nil + return core.Trim(out), nil } diff --git a/cmd/ci/cmd.go b/cmd/ci/cmd.go index dce91e4..65e0c95 100644 --- a/cmd/ci/cmd.go +++ b/cmd/ci/cmd.go @@ -18,6 +18,7 @@ func init() { } // AddCICommands registers the 'ci' command and all subcommands. +// Usage example: call ci.AddCICommands(...) from integrating code. func AddCICommands(root *cli.Command) { setCII18n() initCIFlags() diff --git a/cmd/sdk/cmd.go b/cmd/sdk/cmd.go index acb9421..05c8c01 100644 --- a/cmd/sdk/cmd.go +++ b/cmd/sdk/cmd.go @@ -8,8 +8,7 @@ package sdkcmd import ( - "os" - + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/sdk" "dappco.re/go/core/i18n" coreerr "dappco.re/go/core/log" @@ -61,6 +60,7 @@ func setSDKI18n() { } // AddSDKCommands registers the 'sdk' command and all subcommands. +// Usage example: call sdkcmd.AddSDKCommands(...) from integrating code. func AddSDKCommands(root *cli.Command) { setSDKI18n() @@ -79,7 +79,7 @@ func AddSDKCommands(root *cli.Command) { } func runSDKDiff(basePath, specPath string) error { - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return coreerr.E("sdk.Diff", "failed to get working directory", err) } @@ -119,7 +119,7 @@ func runSDKDiff(basePath, specPath string) error { } func runSDKValidate(specPath string) error { - projectDir, err := os.Getwd() + projectDir, err := ax.Getwd() if err != nil { return coreerr.E("sdk.Validate", "failed to get working directory", err) } diff --git a/go.mod b/go.mod index cb891c3..545a2d6 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( dappco.re/go/core/i18n v0.2.0 dappco.re/go/core/io v0.2.0 dappco.re/go/core/log v0.1.0 + dappco.re/go/core/process v0.3.0 dappco.re/go/core/ws v0.3.0 forge.lthn.ai/core/cli v0.3.7 github.com/Snider/Borg v0.2.0 diff --git a/go.sum b/go.sum index 0da0cde..67559dd 100644 --- a/go.sum +++ b/go.sum @@ -1,12 +1,5 @@ -cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.16.4/go.mod h1:j10ncYwjX/g3cdX7GpEzsdM+d+ZNsXAbb6qXA7p1Y5M= -cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= -cloud.google.com/go/compute/metadata v0.8.0/go.mod h1:sYOGTp851OV9bOFJ9CH7elVvyzopvWQFNNghtDQ/Biw= -cloud.google.com/go/iam v1.5.2/go.mod h1:SE1vg0N81zQqLzQEwxL2WI6yhetBdbNQuTvIKCSkUHE= -cloud.google.com/go/monitoring v1.24.2/go.mod h1:x7yzPWcgDRnPEv3sI+jJGBkwl5qINf+6qY4eq0I9B4U= -cloud.google.com/go/storage v1.56.0/go.mod h1:Tpuj6t4NweCLzlNbw9Z9iwxEkrSem20AetIeH/shgVU= dappco.re/go/core v0.8.0-alpha.1 h1:gj7+Scv+L63Z7wMxbJYHhaRFkHJo2u4MMPuUSv/Dhtk= dappco.re/go/core v0.8.0-alpha.1/go.mod h1:f2/tBZ3+3IqDrg2F5F598llv0nmb/4gJVCFzM5geE4A= dappco.re/go/core/api v0.2.0 h1:5OcN9nawpp18Jp6dB1OwI2CBfs0Tacb0y0zqxFB6TJ0= @@ -17,38 +10,28 @@ dappco.re/go/core/io v0.2.0 h1:zuudgIiTsQQ5ipVt97saWdGLROovbEB/zdVyy9/l+I4= dappco.re/go/core/io v0.2.0/go.mod h1:1QnQV6X9LNgFKfm8SkOtR9LLaj3bDcsOIeJOOyjbL5E= dappco.re/go/core/log v0.1.0 h1:pa71Vq2TD2aoEUQWFKwNcaJ3GBY8HbaNGqtE688Unyc= dappco.re/go/core/log v0.1.0/go.mod h1:Nkqb8gsXhZAO8VLpx7B8i1iAmohhzqA20b9Zr8VUcJs= +dappco.re/go/core/process v0.3.0 h1:BPF9R79+8ZWe34qCIy/sZy+P4HwbaO95js2oPJL7IqM= +dappco.re/go/core/process v0.3.0/go.mod h1:qwx8kt6x+J9gn7fu8lavuess72Ye9jPBODqDZQ9K0as= dappco.re/go/core/ws v0.3.0 h1:ZxR8y5pfrWvnCHVN7qExXz7fdP5a063uNqyqE0Ab8pQ= dappco.re/go/core/ws v0.3.0/go.mod h1:aLyXrJnbCOGL0SW9rC1EHAAIS83w3djO374gHIz4Nic= -dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= -forge.lthn.ai/Snider/Borg v0.3.1/go.mod h1:Z7DJD0yHXsxSyM7Mjl6/g4gH1NBsIz44Bf5AFlV76Wg= forge.lthn.ai/core/cli v0.3.7 h1:1GrbaGg0wDGHr6+klSbbGyN/9sSbHvFbdySJznymhwg= forge.lthn.ai/core/cli v0.3.7/go.mod h1:DBUppJkA9P45ZFGgI2B8VXw1rAZxamHoI/KG7fRvTNs= forge.lthn.ai/core/go v0.3.2 h1:VB9pW6ggqBhe438cjfE2iSI5Lg+62MmRbaOFglZM+nQ= forge.lthn.ai/core/go v0.3.2/go.mod h1:f7/zb3Labn4ARfwTq5Bi2AFHY+uxyPHozO+hLb54eFo= -forge.lthn.ai/core/go-crypt v0.1.6/go.mod h1:4VZAGqxlbadhSB66sJkdj54/HSJ+bSxVgwWK5kMMYDo= forge.lthn.ai/core/go-i18n v0.1.7 h1:aHkAoc3W8fw3RPNvw/UszQbjyFWXHszzbZgty3SwyAA= forge.lthn.ai/core/go-i18n v0.1.7/go.mod h1:0VDjwtY99NSj2iqwrI09h5GUsJeM9s48MLkr+/Dn4G8= forge.lthn.ai/core/go-inference v0.1.7 h1:9Dy6v03jX5ZRH3n5iTzlYyGtucuBIgSe+S7GWvBzx9Q= forge.lthn.ai/core/go-inference v0.1.7/go.mod h1:jfWz+IJX55wAH98+ic6FEqqGB6/P31CHlg7VY7pxREw= -forge.lthn.ai/core/go-io v0.1.5/go.mod h1:FRtXSsi8W+U9vewCU+LBAqqbIj3wjXA4dBdSv3SAtWI= forge.lthn.ai/core/go-log v0.0.4 h1:KTuCEPgFmuM8KJfnyQ8vPOU1Jg654W74h8IJvfQMfv0= forge.lthn.ai/core/go-log v0.0.4/go.mod h1:r14MXKOD3LF/sI8XUJQhRk/SZHBE7jAFVuCfgkXoZPw= github.com/99designs/gqlgen v0.17.88 h1:neMQDgehMwT1vYIOx/w5ZYPUU/iMNAJzRO44I5Intoc= github.com/99designs/gqlgen v0.17.88/go.mod h1:qeqYFEgOeSKqWedOjogPizimp2iu4E23bdPvl4jTYic= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.27.0/go.mod h1:yAZHSGnqScoU556rBOVkwLze6WP5N+U11RHuWaGVxwY= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0/go.mod h1:ZPpqegjbE99EPKsu3iUWV22A04wzGPcAY/ziSIQEEgs= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0/go.mod h1:cSgYe11MCNYunTnRXrKiR/tHc0eoKjICUuWpNZoVCOo= github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc= github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/ProtonMail/go-crypto v1.4.0/go.mod h1:e1OaTyu5SYVrO9gKOEhTc+5UcXtTUa+P3uLudwcgPqo= github.com/PuerkitoBio/goquery v1.11.0 h1:jZ7pwMQXIITcUXNH83LLk+txlaEy6NVOfTuP43xxfqw= github.com/PuerkitoBio/goquery v1.11.0/go.mod h1:wQHgxUOU3JGuj3oD/QFfxUdlzW6xPHfqyHre6VMY4DQ= -github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/Snider/Borg v0.2.0 h1:iCyDhY4WTXi39+FexRwXbn2YpZ2U9FUXVXDZk9xRCXQ= github.com/Snider/Borg v0.2.0/go.mod h1:TqlKnfRo9okioHbgrZPfWjQsztBV0Nfskz4Om1/vdMY= -github.com/Snider/Enchantrix v0.0.2/go.mod h1:CtFcLAvnDT1KcuF1JBb/DJj0KplY8jHryO06KzQ1hsQ= github.com/TwiN/go-color v1.4.1 h1:mqG0P/KBgHKVqmtL5ye7K0/Gr4l6hTksPgTgMk3mUzc= github.com/TwiN/go-color v1.4.1/go.mod h1:WcPf/jtiW95WBIsEeY1Lc/b8aaWoiqQpu5cf8WFxu+s= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= @@ -59,31 +42,13 @@ github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwTo github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM= github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA= -github.com/antonlindstrom/pgstore v0.0.0-20220421113606-e3a6e3fed12a/go.mod h1:Sdr/tmSOLEnncCuXS5TwZRxuk7deH1WXVY8cve3eVBM= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE= -github.com/aws/aws-sdk-go-v2 v1.41.4/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o= -github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.7/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20/go.mod h1:oydPDJKcfMhgfcgBUZaG+toBbwy8yPWubJXBVERtI4o= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20/go.mod h1:YJ898MhD067hSHA6xYCx5ts/jEd8BSOLtQDL3iZsvbc= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.21/go.mod h1:UUxgWxofmOdAMuqEsSppbDtGKLfR04HGsD0HXzvhI1k= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI= -github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.12/go.mod h1:v2pNpJbRNl4vEUWEh5ytQok0zACAKfdmKS51Hotc3pQ= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20/go.mod h1:V4X406Y666khGa8ghKmphma/7C0DAtEQYhkq9z4vpbk= -github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.20/go.mod h1:4TLZCmVJDM3FOu5P5TJP0zOlu9zWgDWU7aUxWbr+rcw= -github.com/aws/aws-sdk-go-v2/service/s3 v1.97.1/go.mod h1:qXVal5H0ChqXP63t6jze5LmFalc7+ZE7wOdLtZ0LCP0= -github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= -github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA= -github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0= -github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/bmatcuk/doublestar/v4 v4.6.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= github.com/bmatcuk/doublestar/v4 v4.10.0 h1:zU9WiOla1YA122oLM6i4EXvGW62DvKZVxIe6TYWexEs= github.com/bmatcuk/doublestar/v4 v4.10.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= -github.com/boj/redistore v1.4.1/go.mod h1:c0Tvw6aMjslog4jHIAcNv6EtJM849YoOAhMY7JBbWpI= -github.com/bradfitz/gomemcache v0.0.0-20250403215159-8d39553ac7cf/go.mod h1:r5xuitiExdLAJ09PR7vBVENGvp4ZuTBeWTGtxuX3K+c= -github.com/bradleypeabody/gorilla-sessions-memcache v0.0.0-20240916143655-c0e34fd2f304/go.mod h1:dkChI7Tbtx7H1Tj7TqGSZMOeGpMP5gLHtjroHd4agiI= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= @@ -111,24 +76,17 @@ github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ= github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI= github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q= -github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U= github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk= github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI= -github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk= github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8= github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0= -github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA= github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk= github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM= -github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= -github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY= -github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= github.com/coreos/go-oidc/v3 v3.17.0 h1:hWBGaQfbi0iVviX4ibC7bk8OKT5qNr4klBaCHVNvehc= github.com/coreos/go-oidc/v3 v3.17.0/go.mod h1:wqPbKFrVnE90vty060SB40FCJ8fTHTxSwyXJqZH+sI8= github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= -github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= @@ -137,15 +95,8 @@ github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/r github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54/go.mod h1:if7Fbed8SFyPtHLHbg49SI7NAdJiC5WIA09pe59rfAA= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= -github.com/envoyproxy/go-control-plane/envoy v1.32.4/go.mod h1:Gzjc5k8JcJswLjAx1Zm+wSYE20UrLtt7JZMWiWQXQEw= -github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU= github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4= github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM= -github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM= github.com/gabriel-vasile/mimetype v1.4.13/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= github.com/gin-contrib/authz v1.0.6 h1:qAO4sSSzOPCwYRZI6YtubC+h2tZVwhwSJeyEZn2W+5k= @@ -176,10 +127,6 @@ github.com/gin-contrib/timeout v1.1.0 h1:WAmWseo5gfBUbMrMJu5hJxDclehfSJUmK2wGwCC github.com/gin-contrib/timeout v1.1.0/go.mod h1:NpRo4gd1Ad8ZQ4T6bQLVFDqiplCmPRs2nvfckxS2Fw4= github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8= github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc= -github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= -github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= -github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU= -github.com/go-git/go-git/v5 v5.16.3/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8= github.com/go-jose/go-jose/v4 v4.1.3 h1:CVLmWDhDVRa6Mi/IgCgaopNosCaHz7zrMeF9MlZRkrs= github.com/go-jose/go-jose/v4 v4.1.3/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -187,7 +134,6 @@ github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/go-openapi/jsonpointer v0.22.5 h1:8on/0Yp4uTb9f4XvTrM2+1CPrV05QPZXu+rvu2o9jcA= github.com/go-openapi/jsonpointer v0.22.5/go.mod h1:gyUR3sCvGSWchA2sUBJGluYMbe1zazrYWIkWPjjMUY0= github.com/go-openapi/jsonreference v0.21.5 h1:6uCGVXU/aNF13AQNggxfysJ+5ZcU4nEAe+pJyVWRdiE= @@ -195,7 +141,6 @@ github.com/go-openapi/jsonreference v0.21.5/go.mod h1:u25Bw85sX4E2jzFodh1FOKMTZL github.com/go-openapi/spec v0.22.4 h1:4pxGjipMKu0FzFiu/DPwN3CTBRlVM2yLf/YTWorYfDQ= github.com/go-openapi/spec v0.22.4/go.mod h1:WQ6Ai0VPWMZgMT4XySjlRIE6GP1bGQOtEThn3gcWLtQ= github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= -github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= github.com/go-openapi/swag/conv v0.25.5 h1:wAXBYEXJjoKwE5+vc9YHhpQOFj2JYBMF2DUi+tGu97g= github.com/go-openapi/swag/conv v0.25.5/go.mod h1:CuJ1eWvh1c4ORKx7unQnFGyvBbNlRKbnRyAvDvzWA4k= github.com/go-openapi/swag/jsonname v0.25.5 h1:8p150i44rv/Drip4vWI3kGi9+4W9TdI3US3uUYSFhSo= @@ -232,29 +177,17 @@ github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU= github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM= github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= -github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/gomodule/redigo v1.9.2/go.mod h1:KsU3hiK/Ay8U42qpaJk+kuNa3C+spxapWpM+ywhcgtw= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/go-github/v39 v39.2.0/go.mod h1:C1s8C5aCC9L+JXIYpJM5GYytdX52vC1bLvHEF1IhBrE= -github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= -github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA= -github.com/googleapis/gax-go/v2 v2.15.0/go.mod h1:zVVkkxAQHa1RQpg9z2AUCMnKhi0Qld9rcmyfL1OZhoc= github.com/gorilla/context v1.1.2 h1:WRkNAv2uoa03QNIc1A6u4O7DAGMUVoopZhkiXWA2V1o= github.com/gorilla/context v1.1.2/go.mod h1:KDPwT9i/MeWHiLl90fuTgrt4/wPcv75vFAZLaOOcbxM= -github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kXD8ePA= github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo= github.com/gorilla/sessions v1.4.0 h1:kpIYOp/oi6MG/p5PgxApU8srsSw9tuFbt46Lt7auzqQ= @@ -263,43 +196,27 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= -github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/jordanlewis/gcassert v0.0.0-20250430164644-389ef753e22e/go.mod h1:ZybsQk6DWyN5t7An1MuPm1gtSZ1xDaTXS9ZjIOxvQrk= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= -github.com/kidstuff/mongostore v0.0.0-20181113001930-e650cd85ee4b/go.mod h1:g2nVr8KZVXJSS97Jo8pJ0jgq29P6H7dG0oplUA86MQw= -github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g= -github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= -github.com/laziness-coders/mongostore v0.0.14/go.mod h1:Rh+yJax2Vxc2QY62clIM/kRnLk+TxivgSLHOXENXPtk= github.com/leaanthony/debme v1.2.1 h1:9Tgwf+kjcrbMQ4WnPcEIUcQuIZYqdWftzZkBr+i/oOc= github.com/leaanthony/debme v1.2.1/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA= -github.com/leaanthony/go-ansi-parser v1.6.1/go.mod h1:+vva/2y4alzVmmIEpk9QDhA7vLC5zKDTRwfZGOp3IWU= github.com/leaanthony/gosod v1.0.4 h1:YLAbVyd591MRffDgxUOU1NwLhT9T1/YiwjKZpkNFeaI= github.com/leaanthony/gosod v1.0.4/go.mod h1:GKuIL0zzPj3O1SdWQOdgURSuhkF+Urizzxh26t9f1cw= github.com/leaanthony/slicer v1.5.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY= github.com/leaanthony/slicer v1.6.0 h1:1RFP5uiPJvT93TAHi+ipd3NACobkW53yUiBqZheE/Js= github.com/leaanthony/slicer v1.6.0/go.mod h1:o/Iz29g7LN0GqH3aMjWAe90381nyZlDNquK+mtH2Fj8= -github.com/leaanthony/u v1.1.1/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI= github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= -github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/logrusorgru/aurora/v4 v4.0.0/go.mod h1:lP0iIa2nrnT/qoFXcOZSrZQpJ1o6n2CUf/hyHi2Q4ZQ= github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag= github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/mailru/easyjson v0.9.2 h1:dX8U45hQsZpxd80nLvDGihsQ/OxlvTkVUXH2r/8cb2M= @@ -307,18 +224,12 @@ github.com/mailru/easyjson v0.9.2/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUt github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= -github.com/matryer/moq v0.6.0/go.mod h1:iEVhY/XBwFG/nbRyEf0oV+SqnTHZJ5wectzx7yT+y98= -github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w= github.com/mattn/go-runewidth v0.0.21/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= -github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= -github.com/memcachier/mc v2.0.1+incompatible/go.mod h1:7bkvFE61leUBvXz+yxsOnGBQSZpBSPIMUQSmmSHvuXc= -github.com/memcachier/mc/v3 v3.0.3/go.mod h1:GzjocBahcXPxt2cmqzknrgqCOmMxiSzhVKPOe90Tpug= -github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -326,14 +237,12 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw= github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8= -github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= -github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/oasdiff/kin-openapi v0.136.1 h1:x1G9doDyPcagCNXDcMK5dt5yAmIgsSCiK7F5gPUiQdM= github.com/oasdiff/kin-openapi v0.136.1/go.mod h1:BMeaLn+GmFJKtHJ31JrgXFt91eZi/q+Og4tr7sq0BzI= github.com/oasdiff/oasdiff v1.12.3 h1:eUzJ/AiyyCY1KwUZPv7fosgDyETacIZbFesJrRz+QdY= @@ -346,44 +255,29 @@ github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s= github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw= -github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A= -github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/quasoft/memstore v0.0.0-20191010062613-2bce066d2b0b/go.mod h1:wTPjTepVu7uJBYgZ0SdWHQlIas582j6cn2jgk4DDdlg= github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw= github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs= github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sagikazarmark/locafero v0.12.0/go.mod h1:sZh36u/YSZ918v0Io+U9ogLYQJ9tLLBmM4eneO6WwsI= -github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o= -github.com/schollz/progressbar/v3 v3.18.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec= github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw= github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= -github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY= github.com/sosodev/duration v1.4.0 h1:35ed0KiVFriGHHzZZJaZLgmTEEICIyt8Sx0RQfj9IjE= github.com/sosodev/duration v1.4.0/go.mod h1:RQIBBX0+fMLc/D9+Jb/fwvVmo0eZvDDEERAikUR6SDg= -github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= -github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU= github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4= github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= -github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= @@ -395,7 +289,6 @@ github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXl github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE= github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg= github.com/swaggo/gin-swagger v1.6.1 h1:Ri06G4gc9N4t4k8hekMigJ9zKTFSlqj/9paAQCQs7cY= @@ -413,53 +306,33 @@ github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= -github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY= github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4= github.com/ulikunitz/xz v0.5.15 h1:9DNdB5s+SgV3bQ2ApL10xRc35ck0DuIX/isZvIk+ubY= github.com/ulikunitz/xz v0.5.15/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= -github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI= -github.com/urfave/cli/v3 v3.7.0/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= github.com/vektah/gqlparser/v2 v2.5.32 h1:k9QPJd4sEDTL+qB4ncPLflqTJ3MmjB9SrVzJrawpFSc= github.com/vektah/gqlparser/v2 v2.5.32/go.mod h1:c1I28gSOVNzlfc4WuDlqU7voQnsqI6OG2amkBAFmgts= github.com/wI2L/jsondiff v0.7.0 h1:1lH1G37GhBPqCfp/lrs91rf/2j3DktX6qYAKZkLuCQQ= github.com/wI2L/jsondiff v0.7.0/go.mod h1:KAEIojdQq66oJiHhDyQez2x+sRit0vIzC9KeK0yizxM= -github.com/wader/gormstore/v2 v2.0.3/go.mod h1:sr3N3a8F1+PBc3fHoKaphFqDXLRJ9Oe6Yow0HxKFbbg= -github.com/wailsapp/go-webview2 v1.0.22/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc= -github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o= -github.com/wailsapp/wails/v2 v2.11.0/go.mod h1:jrf0ZaM6+GBc1wRmXsM8cIvzlg0karYin3erahI4+0k= github.com/woodsbury/decimal128 v1.4.0 h1:xJATj7lLu4f2oObouMt2tgGiElE5gO6mSWUjQsBgUlc= github.com/woodsbury/decimal128 v1.4.0/go.mod h1:BP46FUrVjVhdTbKT+XuQh2xfQaGki9LMIRJSFuh6THU= -github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= -github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= -github.com/xdg-go/scram v1.2.0/go.mod h1:3dlrS0iBaWKYVt2ZfA4cj48umJZ+cAEbR6/SjLA88I8= -github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM= github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU= github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E= github.com/yargevad/filepathx v1.0.0 h1:SYcT+N3tYGi+NvazubCNlvgIPbzAk7i7y2dwg3I5FYc= github.com/yargevad/filepathx v1.0.0/go.mod h1:BprfX/gpYNJHJfc35GjRRpVcwWXS89gGulUIU5tK3tA= -github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= -github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= -go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ= go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/detectors/gcp v1.36.0/go.mod h1:IbBN8uAIIx734PTonTPxAxnjc2pQTxWNkwfstZ+6H2k= go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin v0.67.0 h1:E7DmskpIO7ZR6QI6zKSEKIDNUYoKw9oHXP23gzbCdU0= go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin v0.67.0/go.mod h1:WB2cS9y+AwqqKhoo9gw6/ZxlSjFBUQGZ8BQOaD3FVXM= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.61.0/go.mod h1:snMWehoOh2wsEwnvvwtDyFCxVeDAODenXHtn5vzrKjo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0/go.mod h1:UHB22Z8QsdRDrnAtX4PntOl36ajSxcdUMt1sF7Y6E7Q= go.opentelemetry.io/contrib/propagators/b3 v1.42.0 h1:B2Pew5ufEtgkjLF+tSkXjgYZXQr9m7aCm1wLKB0URbU= go.opentelemetry.io/contrib/propagators/b3 v1.42.0/go.mod h1:iPgUcSEF5DORW6+yNbdw/YevUy+QqJ508ncjhrRSCjc= go.opentelemetry.io/otel v1.42.0 h1:lSQGzTgVR3+sgJDAU/7/ZMjN9Z+vUip7leaqBKy4sho= @@ -516,7 +389,6 @@ golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/telemetry v0.0.0-20260311193753-579e4da9a98c/go.mod h1:TpUTTEp9frx7rTdLpC9gFG9kdI7zVLFTFFlqaH2Cncw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= @@ -528,7 +400,6 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= -golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -536,26 +407,11 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s= golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/api v0.247.0/go.mod h1:r1qZOPmxXffXg6xS5uhx16Fa/UFY8QU/K4bfKrnvovM= -google.golang.org/genproto v0.0.0-20250603155806-513f23925822/go.mod h1:HubltRL7rMh0LfnQPkMH4NPDFEWp0jw3vixw7jEM53s= -google.golang.org/genproto/googleapis/api v0.0.0-20250721164621-a45f3dfb1074/go.mod h1:vYFwMYFbmA8vl6Z/krj/h7+U/AqpHknwJX4Uqgfyc7I= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250818200422-3122310a409c/go.mod h1:gw1tLEfykwDz2ET4a12jcXt4couGAm7IwsVaTy0Sflo= -google.golang.org/grpc v1.74.2/go.mod h1:CtQ+BGjaAIXHs/5YS3i473GqwBBa1zGQNevxdeBEXrM= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/sqlite v1.5.7/go.mod h1:U+J8craQU6Fzkcvu8oLeAQmi50TkwPEhHDEjQZXDah4= -gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= -modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo= -modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= -modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= -modernc.org/sqlite v1.47.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig= -rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= -sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/internal/ax/ax.go b/internal/ax/ax.go new file mode 100644 index 0000000..a837236 --- /dev/null +++ b/internal/ax/ax.go @@ -0,0 +1,350 @@ +package ax + +import ( + "context" + "io" + "io/fs" + "syscall" + + "dappco.re/go/core" + coreio "dappco.re/go/core/io" + coreerr "dappco.re/go/core/log" + process "dappco.re/go/core/process" + processexec "dappco.re/go/core/process/exec" +) + +// DS returns the current platform directory separator. +// +// Usage example: read ax.DS() when building Core-aware filesystem paths. +func DS() string { + return core.Env("DS") +} + +// Clean normalises a filesystem path using Core path primitives. +// +// Usage example: clean := ax.Clean("./dist/../dist/output") +func Clean(path string) string { + return core.CleanPath(path, DS()) +} + +// Join combines path segments without relying on path/filepath. +// +// Usage example: path := ax.Join(projectDir, ".core", "build.yaml") +func Join(parts ...string) string { + return Clean(core.Join(DS(), parts...)) +} + +// Abs resolves a path against the current working directory. +// +// Usage example: abs, err := ax.Abs("./testdata") +func Abs(path string) (string, error) { + if core.PathIsAbs(path) { + return Clean(path), nil + } + + cwd, err := Getwd() + if err != nil { + return "", err + } + + return Join(cwd, path), nil +} + +// Rel returns target relative to base when target is inside base. +// +// Usage example: rel, err := ax.Rel(projectDir, artifactPath) +func Rel(base, target string) (string, error) { + base = Clean(base) + target = Clean(target) + + if base == target { + return ".", nil + } + + prefix := base + if !core.HasSuffix(prefix, DS()) { + prefix = core.Concat(prefix, DS()) + } + + if core.HasPrefix(target, prefix) { + return core.TrimPrefix(target, prefix), nil + } + + return "", coreerr.E("ax.Rel", "path is outside base: "+target, nil) +} + +// Base returns the last path element. +// +// Usage example: name := ax.Base("/tmp/dist/app.tar.gz") +func Base(path string) string { + return core.PathBase(path) +} + +// Dir returns the parent directory for a path. +// +// Usage example: dir := ax.Dir("/tmp/dist/app.tar.gz") +func Dir(path string) string { + return core.PathDir(path) +} + +// Ext returns the filename extension including the dot. +// +// Usage example: ext := ax.Ext("app.tar.gz") +func Ext(path string) string { + return core.PathExt(path) +} + +// IsAbs reports whether a path is absolute. +// +// Usage example: if ax.IsAbs(outputDir) { ... } +func IsAbs(path string) bool { + return core.PathIsAbs(path) +} + +// FromSlash rewrites slash-separated paths for the current platform. +// +// Usage example: path := ax.FromSlash("ui/dist/index.html") +func FromSlash(path string) string { + if DS() == "/" { + return path + } + return core.Replace(path, "/", DS()) +} + +// Getwd returns the current working directory from Core environment metadata. +// +// Usage example: cwd, err := ax.Getwd() +func Getwd() (string, error) { + cwd := core.Env("DIR_CWD") + if cwd == "" { + return "", coreerr.E("ax.Getwd", "current working directory is unavailable", nil) + } + return cwd, nil +} + +// TempDir creates a temporary directory via Core's filesystem primitive. +// +// Usage example: dir, err := ax.TempDir("core-build-*") +func TempDir(prefix string) (string, error) { + dir := (&core.Fs{}).NewUnrestricted().TempDir(prefix) + if dir == "" { + return "", coreerr.E("ax.TempDir", "failed to create temporary directory", nil) + } + return dir, nil +} + +// ReadFile reads a file into bytes via io.Local. +// +// Usage example: data, err := ax.ReadFile("go.mod") +func ReadFile(path string) ([]byte, error) { + content, err := coreio.Local.Read(path) + if err != nil { + return nil, err + } + return []byte(content), nil +} + +// WriteFile writes bytes via io.Local with an explicit mode. +// +// Usage example: err := ax.WriteFile("README.md", []byte("hi"), 0o644) +func WriteFile(path string, data []byte, mode fs.FileMode) error { + return coreio.Local.WriteMode(path, string(data), mode) +} + +// WriteString writes text via io.Local with an explicit mode. +// +// Usage example: err := ax.WriteString("README.md", "hi", 0o644) +func WriteString(path, data string, mode fs.FileMode) error { + return coreio.Local.WriteMode(path, data, mode) +} + +// MkdirAll ensures a directory exists. +// +// Usage example: err := ax.MkdirAll("dist/linux_arm64", 0o755) +func MkdirAll(path string, _ fs.FileMode) error { + return coreio.Local.EnsureDir(path) +} + +// Mkdir ensures a directory exists. +// +// Usage example: err := ax.Mkdir(".core", 0o755) +func Mkdir(path string, _ fs.FileMode) error { + return coreio.Local.EnsureDir(path) +} + +// RemoveAll removes a file or directory tree. +// +// Usage example: err := ax.RemoveAll("dist") +func RemoveAll(path string) error { + return coreio.Local.DeleteAll(path) +} + +// Stat returns file metadata from io.Local. +// +// Usage example: info, err := ax.Stat("go.mod") +func Stat(path string) (fs.FileInfo, error) { + return coreio.Local.Stat(path) +} + +// ReadDir lists directory entries via io.Local. +// +// Usage example: entries, err := ax.ReadDir("dist") +func ReadDir(path string) ([]fs.DirEntry, error) { + return coreio.Local.List(path) +} + +// Open opens a file for reading via io.Local. +// +// Usage example: file, err := ax.Open("README.md") +func Open(path string) (fs.File, error) { + return coreio.Local.Open(path) +} + +// Create opens a file for writing via io.Local. +// +// Usage example: file, err := ax.Create("dist/output.txt") +func Create(path string) (io.WriteCloser, error) { + return coreio.Local.Create(path) +} + +// Exists reports whether a path exists. +// +// Usage example: if ax.Exists("dist") { ... } +func Exists(path string) bool { + return coreio.Local.Exists(path) +} + +// IsFile reports whether a path is a regular file. +// +// Usage example: if ax.IsFile("go.mod") { ... } +func IsFile(path string) bool { + return coreio.Local.IsFile(path) +} + +// IsDir reports whether a path is a directory. +// +// Usage example: if ax.IsDir(".core") { ... } +func IsDir(path string) bool { + return coreio.Local.IsDir(path) +} + +// Chmod updates file permissions without importing os. +// +// Usage example: err := ax.Chmod("dist/app", 0o755) +func Chmod(path string, mode fs.FileMode) error { + return syscall.Chmod(path, uint32(mode)) +} + +// Getuid returns the current process UID. +// +// Usage example: uid := ax.Getuid() +func Getuid() int { + return syscall.Getuid() +} + +// Getgid returns the current process GID. +// +// Usage example: gid := ax.Getgid() +func Getgid() int { + return syscall.Getgid() +} + +// Geteuid returns the effective UID. +// +// Usage example: if ax.Geteuid() == 0 { ... } +func Geteuid() int { + return syscall.Geteuid() +} + +// JSONMarshal returns a JSON string using Core's JSON wrapper. +// +// Usage example: data, err := ax.JSONMarshal(cfg) +func JSONMarshal(value any) (string, error) { + result := core.JSONMarshal(value) + if !result.OK { + return "", result.Value.(error) + } + return string(result.Value.([]byte)), nil +} + +// JSONUnmarshal decodes JSON into target using Core's JSON wrapper. +// +// Usage example: err := ax.JSONUnmarshal(data, &cfg) +func JSONUnmarshal(data []byte, target any) error { + result := core.JSONUnmarshal(data, target) + if !result.OK { + return result.Value.(error) + } + return nil +} + +// LookPath resolves a program on PATH via the Core process package. +// +// Usage example: path, err := ax.LookPath("git") +func LookPath(name string) (string, error) { + program := process.Program{Name: name} + if err := program.Find(); err != nil { + return "", err + } + return program.Path, nil +} + +// Run executes a command and returns trimmed combined output. +// +// Usage example: output, err := ax.Run(ctx, "git", "status", "--short") +func Run(ctx context.Context, command string, args ...string) (string, error) { + program := process.Program{Name: command} + return program.Run(ctx, args...) +} + +// RunDir executes a command in the provided directory and returns combined output. +// +// Usage example: output, err := ax.RunDir(ctx, repoDir, "git", "log", "--oneline") +func RunDir(ctx context.Context, dir, command string, args ...string) (string, error) { + program := process.Program{Name: command} + return program.RunDir(ctx, dir, args...) +} + +// Exec executes a command without capturing output. +// +// Usage example: err := ax.Exec(ctx, "go", "test", "./...") +func Exec(ctx context.Context, command string, args ...string) error { + return processexec.Command(ctx, command, args...).Run() +} + +// ExecDir executes a command in a specific directory without capturing output. +// +// Usage example: err := ax.ExecDir(ctx, repoDir, "go", "test", "./...") +func ExecDir(ctx context.Context, dir, command string, args ...string) error { + return processexec.Command(ctx, command, args...).WithDir(dir).Run() +} + +// ExecWithEnv executes a command with additional environment variables. +// +// Usage example: err := ax.ExecWithEnv(ctx, repoDir, []string{"GOOS=linux"}, "go", "build") +func ExecWithEnv(ctx context.Context, dir string, env []string, command string, args ...string) error { + return processexec.Command(ctx, command, args...).WithDir(dir).WithEnv(env).Run() +} + +// ExecWithWriters executes a command and streams output to the provided writers. +// +// Usage example: err := ax.ExecWithWriters(ctx, repoDir, nil, w, w, "docker", "build", ".") +func ExecWithWriters(ctx context.Context, dir string, env []string, stdout, stderr io.Writer, command string, args ...string) error { + cmd := processexec.Command(ctx, command, args...).WithDir(dir).WithEnv(env) + if stdout != nil { + cmd = cmd.WithStdout(stdout) + } + if stderr != nil { + cmd = cmd.WithStderr(stderr) + } + return cmd.Run() +} + +// CombinedOutput executes a command and returns combined output. +// +// Usage example: output, err := ax.CombinedOutput(ctx, repoDir, nil, "go", "test", "./...") +func CombinedOutput(ctx context.Context, dir string, env []string, command string, args ...string) (string, error) { + cmd := processexec.Command(ctx, command, args...).WithDir(dir).WithEnv(env) + output, err := cmd.CombinedOutput() + return core.Trim(string(output)), err +} diff --git a/locales/embed.go b/locales/embed.go index 1fa659a..98b854b 100644 --- a/locales/embed.go +++ b/locales/embed.go @@ -7,6 +7,8 @@ import ( "dappco.re/go/core/i18n" ) +// Usage example: use locales.FS from package consumers as needed. +// //go:embed *.json var FS embed.FS diff --git a/pkg/api/embed.go b/pkg/api/embed.go index 2270c3c..2624f38 100644 --- a/pkg/api/embed.go +++ b/pkg/api/embed.go @@ -7,5 +7,7 @@ import "embed" // Assets holds the built UI bundle (core-build.js and related files). // The directory is populated by running `npm run build` in the ui/ directory. // +// Usage example: use api.Assets from package consumers as needed. +// //go:embed all:ui/dist var Assets embed.FS diff --git a/pkg/api/provider.go b/pkg/api/provider.go index 645c923..3a75428 100644 --- a/pkg/api/provider.go +++ b/pkg/api/provider.go @@ -6,12 +6,12 @@ package api import ( + "io/fs" "net/http" - "os" - "path/filepath" "dappco.re/go/core/api" "dappco.re/go/core/api/pkg/provider" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/build/pkg/build/builders" "dappco.re/go/core/build/pkg/release" @@ -24,6 +24,7 @@ import ( // BuildProvider wraps go-build's build, release, and SDK operations as a // service provider. It implements Provider, Streamable, Describable, and // Renderable. +// Usage example: declare a value of type api.BuildProvider in integrating code. type BuildProvider struct { hub *ws.Hub projectDir string @@ -41,6 +42,7 @@ var ( // NewProvider creates a BuildProvider for the given project directory. // If projectDir is empty, the current working directory is used. // The WS hub is used to emit real-time build events; pass nil if not available. +// Usage example: call api.NewProvider(...) from integrating code. func NewProvider(projectDir string, hub *ws.Hub) *BuildProvider { if projectDir == "" { projectDir = "." @@ -53,12 +55,15 @@ func NewProvider(projectDir string, hub *ws.Hub) *BuildProvider { } // Name implements api.RouteGroup. +// Usage example: call value.Name(...) from integrating code. func (p *BuildProvider) Name() string { return "build" } // BasePath implements api.RouteGroup. +// Usage example: call value.BasePath(...) from integrating code. func (p *BuildProvider) BasePath() string { return "/api/v1/build" } // Element implements provider.Renderable. +// Usage example: call value.Element(...) from integrating code. func (p *BuildProvider) Element() provider.ElementSpec { return provider.ElementSpec{ Tag: "core-build-panel", @@ -67,6 +72,7 @@ func (p *BuildProvider) Element() provider.ElementSpec { } // Channels implements provider.Streamable. +// Usage example: call value.Channels(...) from integrating code. func (p *BuildProvider) Channels() []string { return []string{ "build.started", @@ -79,6 +85,7 @@ func (p *BuildProvider) Channels() []string { } // RegisterRoutes implements api.RouteGroup. +// Usage example: call value.RegisterRoutes(...) from integrating code. func (p *BuildProvider) RegisterRoutes(rg *gin.RouterGroup) { // Build rg.GET("/config", p.getConfig) @@ -97,6 +104,7 @@ func (p *BuildProvider) RegisterRoutes(rg *gin.RouterGroup) { } // Describe implements api.DescribableGroup. +// Usage example: call value.Describe(...) from integrating code. func (p *BuildProvider) Describe() []api.RouteDescription { return []api.RouteDescription{ { @@ -180,7 +188,7 @@ func (p *BuildProvider) Describe() []api.RouteDescription { // resolveDir returns the absolute project directory. func (p *BuildProvider) resolveDir() (string, error) { - return filepath.Abs(p.projectDir) + return ax.Abs(p.projectDir) } // -- Build Handlers ----------------------------------------------------------- @@ -278,10 +286,10 @@ func (p *BuildProvider) triggerBuild(c *gin.Context) { binaryName = cfg.Project.Name } if binaryName == "" { - binaryName = filepath.Base(dir) + binaryName = ax.Base(dir) } - outputDir := filepath.Join(dir, "dist") + outputDir := ax.Join(dir, "dist") buildConfig := &build.Config{ FS: p.medium, @@ -348,7 +356,7 @@ func (p *BuildProvider) listArtifacts(c *gin.Context) { return } - distDir := filepath.Join(dir, "dist") + distDir := ax.Join(dir, "dist") if !p.medium.IsDir(distDir) { c.JSON(http.StatusOK, api.OK(map[string]any{ "artifacts": []artifactInfo{}, @@ -374,7 +382,7 @@ func (p *BuildProvider) listArtifacts(c *gin.Context) { } artifacts = append(artifacts, artifactInfo{ Name: entry.Name(), - Path: filepath.Join(distDir, entry.Name()), + Path: ax.Join(distDir, entry.Name()), Size: info.Size(), }) } @@ -566,7 +574,7 @@ func getBuilder(projectType build.ProjectType) (build.Builder, error) { case build.ProjectTypeGo: return builders.NewGoBuilder(), nil default: - return nil, os.ErrNotExist + return nil, fs.ErrNotExist } } diff --git a/pkg/api/provider_test.go b/pkg/api/provider_test.go index aca88c4..e5c6110 100644 --- a/pkg/api/provider_test.go +++ b/pkg/api/provider_test.go @@ -3,7 +3,7 @@ package api import ( - "os" + "io/fs" "testing" "dappco.re/go/core/build/pkg/build" @@ -11,14 +11,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestBuildProvider_Good_Identity(t *testing.T) { +func TestProvider_BuildProviderIdentity_Good(t *testing.T) { p := NewProvider(".", nil) assert.Equal(t, "build", p.Name()) assert.Equal(t, "/api/v1/build", p.BasePath()) } -func TestBuildProvider_Good_Element(t *testing.T) { +func TestProvider_BuildProviderElement_Good(t *testing.T) { p := NewProvider(".", nil) el := p.Element() @@ -26,7 +26,7 @@ func TestBuildProvider_Good_Element(t *testing.T) { assert.Equal(t, "/assets/core-build.js", el.Source) } -func TestBuildProvider_Good_Channels(t *testing.T) { +func TestProvider_BuildProviderChannels_Good(t *testing.T) { p := NewProvider(".", nil) channels := p.Channels() @@ -39,7 +39,7 @@ func TestBuildProvider_Good_Channels(t *testing.T) { assert.Len(t, channels, 6) } -func TestBuildProvider_Good_Describe(t *testing.T) { +func TestProvider_BuildProviderDescribe_Good(t *testing.T) { p := NewProvider(".", nil) routes := p.Describe() @@ -63,23 +63,23 @@ func TestBuildProvider_Good_Describe(t *testing.T) { assert.Equal(t, "POST", paths["/sdk/generate"]) } -func TestBuildProvider_Good_DefaultProjectDir(t *testing.T) { +func TestProvider_BuildProviderDefaultProjectDir_Good(t *testing.T) { p := NewProvider("", nil) assert.Equal(t, ".", p.projectDir) } -func TestBuildProvider_Good_CustomProjectDir(t *testing.T) { +func TestProvider_BuildProviderCustomProjectDir_Good(t *testing.T) { p := NewProvider("/tmp/myproject", nil) assert.Equal(t, "/tmp/myproject", p.projectDir) } -func TestBuildProvider_Good_NilHub(t *testing.T) { +func TestProvider_BuildProviderNilHub_Good(t *testing.T) { p := NewProvider(".", nil) // emitEvent should not panic with nil hub p.emitEvent("build.started", map[string]any{"test": true}) } -func TestGetBuilder_Good_SupportedTypes(t *testing.T) { +func TestProvider_GetBuilderSupportedTypes_Good(t *testing.T) { b, err := getBuilder(build.ProjectTypeGo) require.NoError(t, err) assert.Equal(t, "go", b.Name()) @@ -89,19 +89,19 @@ func TestGetBuilder_Good_SupportedTypes(t *testing.T) { assert.Equal(t, "wails", b.Name()) } -func TestGetBuilder_Bad_UnsupportedType(t *testing.T) { +func TestProvider_GetBuilderUnsupportedType_Bad(t *testing.T) { _, err := getBuilder(build.ProjectType("unknown")) - assert.ErrorIs(t, err, os.ErrNotExist) + assert.ErrorIs(t, err, fs.ErrNotExist) } -func TestBuildProvider_Good_ResolveDir(t *testing.T) { +func TestProvider_BuildProviderResolveDir_Good(t *testing.T) { p := NewProvider("/tmp", nil) dir, err := p.resolveDir() require.NoError(t, err) assert.Equal(t, "/tmp", dir) } -func TestBuildProvider_Good_ResolveDirRelative(t *testing.T) { +func TestProvider_BuildProviderResolveDirRelative_Good(t *testing.T) { p := NewProvider(".", nil) dir, err := p.resolveDir() require.NoError(t, err) @@ -109,7 +109,7 @@ func TestBuildProvider_Good_ResolveDirRelative(t *testing.T) { assert.True(t, len(dir) > 1 && dir[0] == '/') } -func TestBuildProvider_Good_MediumSet(t *testing.T) { +func TestProvider_BuildProviderMediumSet_Good(t *testing.T) { p := NewProvider(".", nil) assert.NotNil(t, p.medium, "medium should be set to io.Local") } diff --git a/pkg/build/archive.go b/pkg/build/archive.go index 58af1c4..e2dbb0e 100644 --- a/pkg/build/archive.go +++ b/pkg/build/archive.go @@ -6,17 +6,17 @@ import ( "archive/zip" "bytes" "compress/gzip" - "fmt" "io" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" io_interface "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" "github.com/Snider/Borg/pkg/compress" ) // ArchiveFormat specifies the compression format for archives. +// Usage example: declare a value of type build.ArchiveFormat in integrating code. type ArchiveFormat string const ( @@ -32,6 +32,7 @@ const ( // Uses tar.gz for linux/darwin and zip for windows. // The archive is created alongside the binary (e.g., dist/myapp_linux_amd64.tar.gz). // Returns a new Artifact with Path pointing to the archive. +// Usage example: call build.Archive(...) from integrating code. func Archive(fs io_interface.Medium, artifact Artifact) (Artifact, error) { return ArchiveWithFormat(fs, artifact, ArchiveFormatGzip) } @@ -39,6 +40,7 @@ func Archive(fs io_interface.Medium, artifact Artifact) (Artifact, error) { // ArchiveXZ creates an archive for a single artifact using xz compression. // Uses tar.xz for linux/darwin and zip for windows. // Returns a new Artifact with Path pointing to the archive. +// Usage example: call build.ArchiveXZ(...) from integrating code. func ArchiveXZ(fs io_interface.Medium, artifact Artifact) (Artifact, error) { return ArchiveWithFormat(fs, artifact, ArchiveFormatXZ) } @@ -47,6 +49,7 @@ func ArchiveXZ(fs io_interface.Medium, artifact Artifact) (Artifact, error) { // Uses tar.gz or tar.xz for linux/darwin and zip for windows. // The archive is created alongside the binary (e.g., dist/myapp_linux_amd64.tar.xz). // Returns a new Artifact with Path pointing to the archive. +// Usage example: call build.ArchiveWithFormat(...) from integrating code. func ArchiveWithFormat(fs io_interface.Medium, artifact Artifact, format ArchiveFormat) (Artifact, error) { if artifact.Path == "" { return Artifact{}, coreerr.E("build.Archive", "artifact path is empty", nil) @@ -94,18 +97,21 @@ func ArchiveWithFormat(fs io_interface.Medium, artifact Artifact, format Archive // ArchiveAll archives all artifacts using gzip compression. // Returns a slice of new artifacts pointing to the archives. +// Usage example: call build.ArchiveAll(...) from integrating code. func ArchiveAll(fs io_interface.Medium, artifacts []Artifact) ([]Artifact, error) { return ArchiveAllWithFormat(fs, artifacts, ArchiveFormatGzip) } // ArchiveAllXZ archives all artifacts using xz compression. // Returns a slice of new artifacts pointing to the archives. +// Usage example: call build.ArchiveAllXZ(...) from integrating code. func ArchiveAllXZ(fs io_interface.Medium, artifacts []Artifact) ([]Artifact, error) { return ArchiveAllWithFormat(fs, artifacts, ArchiveFormatXZ) } // ArchiveAllWithFormat archives all artifacts with the specified format. // Returns a slice of new artifacts pointing to the archives. +// Usage example: call build.ArchiveAllWithFormat(...) from integrating code. func ArchiveAllWithFormat(fs io_interface.Medium, artifacts []Artifact, format ArchiveFormat) ([]Artifact, error) { if len(artifacts) == 0 { return nil, nil @@ -127,18 +133,18 @@ func ArchiveAllWithFormat(fs io_interface.Medium, artifacts []Artifact, format A // Format: dist/myapp_linux_amd64.tar.gz (binary name taken from artifact path). func archiveFilename(artifact Artifact, ext string) string { // Get the directory containing the binary (e.g., dist/linux_amd64) - dir := filepath.Dir(artifact.Path) + dir := ax.Dir(artifact.Path) // Go up one level to the output directory (e.g., dist) - outputDir := filepath.Dir(dir) + outputDir := ax.Dir(dir) // Get the binary name without extension - binaryName := filepath.Base(artifact.Path) - binaryName = strings.TrimSuffix(binaryName, ".exe") + binaryName := ax.Base(artifact.Path) + binaryName = core.TrimSuffix(binaryName, ".exe") // Construct archive name: myapp_linux_amd64.tar.gz - archiveName := fmt.Sprintf("%s_%s_%s%s", binaryName, artifact.OS, artifact.Arch, ext) + archiveName := core.Sprintf("%s_%s_%s%s", binaryName, artifact.OS, artifact.Arch, ext) - return filepath.Join(outputDir, archiveName) + return ax.Join(outputDir, archiveName) } // createTarXzArchive creates a tar.xz archive containing a single file. @@ -165,7 +171,7 @@ func createTarXzArchive(fs io_interface.Medium, src, dst string) error { if err != nil { return coreerr.E("build.createTarXzArchive", "failed to create tar header", err) } - header.Name = filepath.Base(src) + header.Name = ax.Base(src) if err := tarWriter.WriteHeader(header); err != nil { return coreerr.E("build.createTarXzArchive", "failed to write tar header", err) @@ -234,7 +240,7 @@ func createTarGzArchive(fs io_interface.Medium, src, dst string) error { return coreerr.E("build.createTarGzArchive", "failed to create tar header", err) } // Use just the filename, not the full path - header.Name = filepath.Base(src) + header.Name = ax.Base(src) // Write header if err := tarWriter.WriteHeader(header); err != nil { @@ -280,7 +286,7 @@ func createZipArchive(fs io_interface.Medium, src, dst string) error { return coreerr.E("build.createZipArchive", "failed to create zip header", err) } // Use just the filename, not the full path - header.Name = filepath.Base(src) + header.Name = ax.Base(src) header.Method = zip.Deflate // Create file in archive diff --git a/pkg/build/archive_test.go b/pkg/build/archive_test.go index b0e475d..1805947 100644 --- a/pkg/build/archive_test.go +++ b/pkg/build/archive_test.go @@ -6,10 +6,11 @@ import ( "bytes" "compress/gzip" "io" - "os" - "path/filepath" + stdfs "io/fs" "testing" + "dappco.re/go/core/build/internal/ax" + io_interface "dappco.re/go/core/io" "github.com/Snider/Borg/pkg/compress" "github.com/stretchr/testify/assert" @@ -24,20 +25,20 @@ func setupArchiveTestFile(t *testing.T, name, os_, arch string) (binaryPath stri outputDir = t.TempDir() // Create platform directory: dist/os_arch - platformDir := filepath.Join(outputDir, os_+"_"+arch) - err := os.MkdirAll(platformDir, 0755) + platformDir := ax.Join(outputDir, os_+"_"+arch) + err := ax.MkdirAll(platformDir, 0755) require.NoError(t, err) // Create test binary - binaryPath = filepath.Join(platformDir, name) + binaryPath = ax.Join(platformDir, name) content := []byte("#!/bin/bash\necho 'Hello, World!'\n") - err = os.WriteFile(binaryPath, content, 0755) + err = ax.WriteFile(binaryPath, content, 0755) require.NoError(t, err) return binaryPath, outputDir } -func TestArchive_Good(t *testing.T) { +func TestArchive_Archive_Good(t *testing.T) { fs := io_interface.Local t.Run("creates tar.gz for linux", func(t *testing.T) { binaryPath, outputDir := setupArchiveTestFile(t, "myapp", "linux", "amd64") @@ -52,7 +53,7 @@ func TestArchive_Good(t *testing.T) { require.NoError(t, err) // Verify archive was created - expectedPath := filepath.Join(outputDir, "myapp_linux_amd64.tar.gz") + expectedPath := ax.Join(outputDir, "myapp_linux_amd64.tar.gz") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -76,7 +77,7 @@ func TestArchive_Good(t *testing.T) { result, err := Archive(fs, artifact) require.NoError(t, err) - expectedPath := filepath.Join(outputDir, "myapp_darwin_arm64.tar.gz") + expectedPath := ax.Join(outputDir, "myapp_darwin_arm64.tar.gz") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -96,7 +97,7 @@ func TestArchive_Good(t *testing.T) { require.NoError(t, err) // Windows archives should strip .exe from archive name - expectedPath := filepath.Join(outputDir, "myapp_windows_amd64.zip") + expectedPath := ax.Join(outputDir, "myapp_windows_amd64.zip") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -130,7 +131,7 @@ func TestArchive_Good(t *testing.T) { result, err := ArchiveXZ(fs, artifact) require.NoError(t, err) - expectedPath := filepath.Join(outputDir, "myapp_linux_amd64.tar.xz") + expectedPath := ax.Join(outputDir, "myapp_linux_amd64.tar.xz") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -149,7 +150,7 @@ func TestArchive_Good(t *testing.T) { result, err := ArchiveWithFormat(fs, artifact, ArchiveFormatXZ) require.NoError(t, err) - expectedPath := filepath.Join(outputDir, "myapp_darwin_arm64.tar.xz") + expectedPath := ax.Join(outputDir, "myapp_darwin_arm64.tar.xz") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -169,7 +170,7 @@ func TestArchive_Good(t *testing.T) { require.NoError(t, err) // Windows should still get .zip regardless of format - expectedPath := filepath.Join(outputDir, "myapp_windows_amd64.zip") + expectedPath := ax.Join(outputDir, "myapp_windows_amd64.zip") assert.Equal(t, expectedPath, result.Path) assert.FileExists(t, result.Path) @@ -177,7 +178,7 @@ func TestArchive_Good(t *testing.T) { }) } -func TestArchive_Bad(t *testing.T) { +func TestArchive_Archive_Bad(t *testing.T) { fs := io_interface.Local t.Run("returns error for empty path", func(t *testing.T) { artifact := Artifact{ @@ -221,7 +222,7 @@ func TestArchive_Bad(t *testing.T) { }) } -func TestArchiveAll_Good(t *testing.T) { +func TestArchive_ArchiveAll_Good(t *testing.T) { fs := io_interface.Local t.Run("archives multiple artifacts", func(t *testing.T) { outputDir := t.TempDir() @@ -239,8 +240,8 @@ func TestArchiveAll_Good(t *testing.T) { } for _, target := range targets { - platformDir := filepath.Join(outputDir, target.os_+"_"+target.arch) - err := os.MkdirAll(platformDir, 0755) + platformDir := ax.Join(outputDir, target.os_+"_"+target.arch) + err := ax.MkdirAll(platformDir, 0755) require.NoError(t, err) name := "myapp" @@ -248,8 +249,8 @@ func TestArchiveAll_Good(t *testing.T) { name = "myapp.exe" } - binaryPath := filepath.Join(platformDir, name) - err = os.WriteFile(binaryPath, []byte("binary content"), 0755) + binaryPath := ax.Join(platformDir, name) + err = ax.WriteFile(binaryPath, []byte("binary content"), 0755) require.NoError(t, err) artifacts = append(artifacts, Artifact{ @@ -284,7 +285,7 @@ func TestArchiveAll_Good(t *testing.T) { }) } -func TestArchiveAll_Bad(t *testing.T) { +func TestArchive_ArchiveAll_Bad(t *testing.T) { fs := io_interface.Local t.Run("returns partial results on error", func(t *testing.T) { binaryPath, _ := setupArchiveTestFile(t, "myapp", "linux", "amd64") @@ -302,7 +303,7 @@ func TestArchiveAll_Bad(t *testing.T) { }) } -func TestArchiveFilename_Good(t *testing.T) { +func TestArchive_ArchiveFilename_Good(t *testing.T) { t.Run("generates correct tar.gz filename", func(t *testing.T) { artifact := Artifact{ Path: "/output/linux_amd64/myapp", @@ -344,7 +345,7 @@ func TestArchive_RoundTrip_Good(t *testing.T) { binaryPath, _ := setupArchiveTestFile(t, "roundtrip-app", "linux", "amd64") // Read original content - originalContent, err := os.ReadFile(binaryPath) + originalContent, err := ax.ReadFile(binaryPath) require.NoError(t, err) artifact := Artifact{ @@ -366,7 +367,7 @@ func TestArchive_RoundTrip_Good(t *testing.T) { t.Run("tar.xz round trip preserves content", func(t *testing.T) { binaryPath, _ := setupArchiveTestFile(t, "roundtrip-xz", "linux", "arm64") - originalContent, err := os.ReadFile(binaryPath) + originalContent, err := ax.ReadFile(binaryPath) require.NoError(t, err) artifact := Artifact{ @@ -386,7 +387,7 @@ func TestArchive_RoundTrip_Good(t *testing.T) { t.Run("zip round trip preserves content", func(t *testing.T) { binaryPath, _ := setupArchiveTestFile(t, "roundtrip.exe", "windows", "amd64") - originalContent, err := os.ReadFile(binaryPath) + originalContent, err := ax.ReadFile(binaryPath) require.NoError(t, err) artifact := Artifact{ @@ -418,21 +419,21 @@ func TestArchive_RoundTrip_Good(t *testing.T) { // Extract and verify permissions are preserved mode := extractTarGzFileMode(t, archiveArtifact.Path, "perms-app") // The original file was written with 0755 - assert.Equal(t, os.FileMode(0755), mode&os.ModePerm) + assert.Equal(t, stdfs.FileMode(0o755), mode&stdfs.ModePerm) }) t.Run("round trip with large binary content", func(t *testing.T) { outputDir := t.TempDir() - platformDir := filepath.Join(outputDir, "linux_amd64") - require.NoError(t, os.MkdirAll(platformDir, 0755)) + platformDir := ax.Join(outputDir, "linux_amd64") + require.NoError(t, ax.MkdirAll(platformDir, 0755)) // Create a larger file (64KB) largeContent := make([]byte, 64*1024) for i := range largeContent { largeContent[i] = byte(i % 256) } - binaryPath := filepath.Join(platformDir, "large-app") - require.NoError(t, os.WriteFile(binaryPath, largeContent, 0755)) + binaryPath := ax.Join(platformDir, "large-app") + require.NoError(t, ax.WriteFile(binaryPath, largeContent, 0755)) artifact := Artifact{ Path: binaryPath, @@ -449,16 +450,16 @@ func TestArchive_RoundTrip_Good(t *testing.T) { t.Run("archive is smaller than original for tar.gz", func(t *testing.T) { outputDir := t.TempDir() - platformDir := filepath.Join(outputDir, "linux_amd64") - require.NoError(t, os.MkdirAll(platformDir, 0755)) + platformDir := ax.Join(outputDir, "linux_amd64") + require.NoError(t, ax.MkdirAll(platformDir, 0755)) // Create a compressible file (repeated pattern) compressibleContent := make([]byte, 4096) for i := range compressibleContent { compressibleContent[i] = 'A' } - binaryPath := filepath.Join(platformDir, "compressible-app") - require.NoError(t, os.WriteFile(binaryPath, compressibleContent, 0755)) + binaryPath := ax.Join(platformDir, "compressible-app") + require.NoError(t, ax.WriteFile(binaryPath, compressibleContent, 0755)) artifact := Artifact{ Path: binaryPath, @@ -469,9 +470,9 @@ func TestArchive_RoundTrip_Good(t *testing.T) { archiveArtifact, err := Archive(fs, artifact) require.NoError(t, err) - originalInfo, err := os.Stat(binaryPath) + originalInfo, err := ax.Stat(binaryPath) require.NoError(t, err) - archiveInfo, err := os.Stat(archiveArtifact.Path) + archiveInfo, err := ax.Stat(archiveArtifact.Path) require.NoError(t, err) // Compressed archive should be smaller than original @@ -483,7 +484,7 @@ func TestArchive_RoundTrip_Good(t *testing.T) { func extractTarGzFile(t *testing.T, archivePath, fileName string) []byte { t.Helper() - file, err := os.Open(archivePath) + file, err := ax.Open(archivePath) require.NoError(t, err) defer func() { _ = file.Close() }() @@ -509,10 +510,10 @@ func extractTarGzFile(t *testing.T, archivePath, fileName string) []byte { } // extractTarGzFileMode extracts the file mode of a named file from a tar.gz archive. -func extractTarGzFileMode(t *testing.T, archivePath, fileName string) os.FileMode { +func extractTarGzFileMode(t *testing.T, archivePath, fileName string) stdfs.FileMode { t.Helper() - file, err := os.Open(archivePath) + file, err := ax.Open(archivePath) require.NoError(t, err) defer func() { _ = file.Close() }() @@ -539,7 +540,7 @@ func extractTarGzFileMode(t *testing.T, archivePath, fileName string) os.FileMod func extractTarXzFile(t *testing.T, archivePath, fileName string) []byte { t.Helper() - xzData, err := os.ReadFile(archivePath) + xzData, err := ax.ReadFile(archivePath) require.NoError(t, err) tarData, err := compress.Decompress(xzData) @@ -590,7 +591,7 @@ func extractZipFile(t *testing.T, archivePath, fileName string) []byte { func verifyTarGzContent(t *testing.T, archivePath, expectedName string) { t.Helper() - file, err := os.Open(archivePath) + file, err := ax.Open(archivePath) require.NoError(t, err) defer func() { _ = file.Close() }() @@ -626,7 +627,7 @@ func verifyTarXzContent(t *testing.T, archivePath, expectedName string) { t.Helper() // Read the xz-compressed file - xzData, err := os.ReadFile(archivePath) + xzData, err := ax.ReadFile(archivePath) require.NoError(t, err) // Decompress with Borg diff --git a/pkg/build/build.go b/pkg/build/build.go index 783db1f..4d3e84e 100644 --- a/pkg/build/build.go +++ b/pkg/build/build.go @@ -10,6 +10,7 @@ import ( ) // ProjectType represents a detected project type. +// Usage example: declare a value of type build.ProjectType in integrating code. type ProjectType string // Project type constants for build detection. @@ -33,17 +34,20 @@ const ( ) // Target represents a build target platform. +// Usage example: declare a value of type build.Target in integrating code. type Target struct { OS string Arch string } // String returns the target in GOOS/GOARCH format. +// Usage example: call value.String(...) from integrating code. func (t Target) String() string { return t.OS + "/" + t.Arch } // Artifact represents a build output file. +// Usage example: declare a value of type build.Artifact in integrating code. type Artifact struct { Path string OS string @@ -52,6 +56,7 @@ type Artifact struct { } // Config holds build configuration. +// Usage example: declare a value of type build.Config in integrating code. type Config struct { // FS is the medium used for file operations. FS io.Medium @@ -82,6 +87,7 @@ type Config struct { } // Builder defines the interface for project-specific build implementations. +// Usage example: declare a value of type build.Builder in integrating code. type Builder interface { // Name returns the builder's identifier. Name() string diff --git a/pkg/build/builders/cpp.go b/pkg/build/builders/cpp.go index f2ff572..6718f94 100644 --- a/pkg/build/builders/cpp.go +++ b/pkg/build/builders/cpp.go @@ -3,13 +3,10 @@ package builders import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" "runtime" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -17,19 +14,23 @@ import ( // CPPBuilder implements the Builder interface for C++ projects using CMake + Conan. // It wraps the Makefile-based build system from the .core/build submodule. +// Usage example: declare a value of type builders.CPPBuilder in integrating code. type CPPBuilder struct{} // NewCPPBuilder creates a new CPPBuilder instance. +// Usage example: call builders.NewCPPBuilder(...) from integrating code. func NewCPPBuilder() *CPPBuilder { return &CPPBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *CPPBuilder) Name() string { return "cpp" } // Detect checks if this builder can handle the project in the given directory. +// Usage example: call value.Detect(...) from integrating code. func (b *CPPBuilder) Detect(fs io.Medium, dir string) (bool, error) { return build.IsCPPProject(fs, dir), nil } @@ -37,6 +38,7 @@ func (b *CPPBuilder) Detect(fs io.Medium, dir string) (bool, error) { // Build compiles the C++ project using Make targets. // The build flow is: make configure → make build → make package. // Cross-compilation is handled via Conan profiles specified in .core/build.yaml. +// Usage example: call value.Build(...) from integrating code. func (b *CPPBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { if cfg == nil { return nil, coreerr.E("CPPBuilder.Build", "config is nil", nil) @@ -83,7 +85,7 @@ func (b *CPPBuilder) buildTarget(ctx context.Context, cfg *build.Config, target // buildHost runs the standard make configure → make build → make package flow. func (b *CPPBuilder) buildHost(ctx context.Context, cfg *build.Config, target build.Target) ([]build.Artifact, error) { - fmt.Printf("Building C++ project for %s/%s (host)\n", target.OS, target.Arch) + core.Print(nil, "Building C++ project for %s/%s (host)", target.OS, target.Arch) // Step 1: Configure (runs conan install + cmake configure) if err := b.runMake(ctx, cfg.ProjectDir, "configure"); err != nil { @@ -113,7 +115,7 @@ func (b *CPPBuilder) buildCross(ctx context.Context, cfg *build.Config, target b return nil, coreerr.E("CPPBuilder.buildCross", "no Conan profile mapped for target "+target.OS+"/"+target.Arch, nil) } - fmt.Printf("Building C++ project for %s/%s (cross: %s)\n", target.OS, target.Arch, profile) + core.Print(nil, "Building C++ project for %s/%s (cross: %s)", target.OS, target.Arch, profile) // The Makefile exposes each profile as a top-level target if err := b.runMake(ctx, cfg.ProjectDir, profile); err != nil { @@ -125,13 +127,7 @@ func (b *CPPBuilder) buildCross(ctx context.Context, cfg *build.Config, target b // runMake executes a make target in the project directory. func (b *CPPBuilder) runMake(ctx context.Context, projectDir string, target string) error { - cmd := exec.CommandContext(ctx, "make", target) - cmd.Dir = projectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - cmd.Env = os.Environ() - - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(ctx, projectDir, "make", target); err != nil { return coreerr.E("CPPBuilder.runMake", "make "+target+" failed", err) } return nil @@ -139,7 +135,7 @@ func (b *CPPBuilder) runMake(ctx context.Context, projectDir string, target stri // findArtifacts searches for built packages in build/packages/. func (b *CPPBuilder) findArtifacts(fs io.Medium, projectDir string, target build.Target) ([]build.Artifact, error) { - packagesDir := filepath.Join(projectDir, "build", "packages") + packagesDir := ax.Join(projectDir, "build", "packages") if !fs.IsDir(packagesDir) { // Fall back to searching build/release/src/ for raw binaries @@ -159,12 +155,12 @@ func (b *CPPBuilder) findArtifacts(fs io.Medium, projectDir string, target build name := entry.Name() // Skip checksum files and hidden files - if strings.HasSuffix(name, ".sha256") || strings.HasPrefix(name, ".") { + if core.HasSuffix(name, ".sha256") || core.HasPrefix(name, ".") { continue } artifacts = append(artifacts, build.Artifact{ - Path: filepath.Join(packagesDir, name), + Path: ax.Join(packagesDir, name), OS: target.OS, Arch: target.Arch, }) @@ -175,7 +171,7 @@ func (b *CPPBuilder) findArtifacts(fs io.Medium, projectDir string, target build // findBinaries searches for compiled binaries in build/release/src/. func (b *CPPBuilder) findBinaries(fs io.Medium, projectDir string, target build.Target) ([]build.Artifact, error) { - binDir := filepath.Join(projectDir, "build", "release", "src") + binDir := ax.Join(projectDir, "build", "release", "src") if !fs.IsDir(binDir) { return nil, coreerr.E("CPPBuilder.findBinaries", "no build output found in "+binDir, nil) @@ -194,16 +190,16 @@ func (b *CPPBuilder) findBinaries(fs io.Medium, projectDir string, target build. name := entry.Name() // Skip non-executable files (libraries, cmake files, etc.) - if strings.HasSuffix(name, ".a") || strings.HasSuffix(name, ".o") || - strings.HasSuffix(name, ".cmake") || strings.HasPrefix(name, ".") { + if core.HasSuffix(name, ".a") || core.HasSuffix(name, ".o") || + core.HasSuffix(name, ".cmake") || core.HasPrefix(name, ".") { continue } - fullPath := filepath.Join(binDir, name) + fullPath := ax.Join(binDir, name) // On Unix, check if file is executable if target.OS != "windows" { - info, err := os.Stat(fullPath) + info, err := fs.Stat(fullPath) if err != nil { continue } @@ -244,7 +240,7 @@ func (b *CPPBuilder) targetToProfile(target build.Target) string { // validateMake checks if make is available. func (b *CPPBuilder) validateMake() error { - if _, err := exec.LookPath("make"); err != nil { + if _, err := ax.LookPath("make"); err != nil { return coreerr.E("CPPBuilder.validateMake", "make not found. Install build-essential (Linux) or Xcode Command Line Tools (macOS)", nil) } return nil diff --git a/pkg/build/builders/cpp_test.go b/pkg/build/builders/cpp_test.go index e90bc3f..9314b81 100644 --- a/pkg/build/builders/cpp_test.go +++ b/pkg/build/builders/cpp_test.go @@ -1,27 +1,27 @@ package builders import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestCPPBuilder_Name_Good(t *testing.T) { +func TestCPP_CPPBuilderName_Good(t *testing.T) { builder := NewCPPBuilder() assert.Equal(t, "cpp", builder.Name()) } -func TestCPPBuilder_Detect_Good(t *testing.T) { +func TestCPP_CPPBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects C++ project with CMakeLists.txt", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "CMakeLists.txt"), []byte("cmake_minimum_required(VERSION 3.16)"), 0644) + err := ax.WriteFile(ax.Join(dir, "CMakeLists.txt"), []byte("cmake_minimum_required(VERSION 3.16)"), 0644) require.NoError(t, err) builder := NewCPPBuilder() @@ -32,7 +32,7 @@ func TestCPPBuilder_Detect_Good(t *testing.T) { t.Run("returns false for non-C++ project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test"), 0644) require.NoError(t, err) builder := NewCPPBuilder() @@ -51,7 +51,7 @@ func TestCPPBuilder_Detect_Good(t *testing.T) { }) } -func TestCPPBuilder_Build_Bad(t *testing.T) { +func TestCPP_CPPBuilderBuild_Bad(t *testing.T) { t.Run("returns error for nil config", func(t *testing.T) { builder := NewCPPBuilder() artifacts, err := builder.Build(nil, nil, []build.Target{{OS: "linux", Arch: "amd64"}}) @@ -61,7 +61,7 @@ func TestCPPBuilder_Build_Bad(t *testing.T) { }) } -func TestCPPBuilder_TargetToProfile_Good(t *testing.T) { +func TestCPP_CPPBuilderTargetToProfile_Good(t *testing.T) { builder := NewCPPBuilder() tests := []struct { @@ -84,7 +84,7 @@ func TestCPPBuilder_TargetToProfile_Good(t *testing.T) { } } -func TestCPPBuilder_TargetToProfile_Bad(t *testing.T) { +func TestCPP_CPPBuilderTargetToProfile_Bad(t *testing.T) { builder := NewCPPBuilder() t.Run("returns empty for unknown target", func(t *testing.T) { @@ -93,18 +93,18 @@ func TestCPPBuilder_TargetToProfile_Bad(t *testing.T) { }) } -func TestCPPBuilder_FindArtifacts_Good(t *testing.T) { +func TestCPP_CPPBuilderFindArtifacts_Good(t *testing.T) { fs := io.Local t.Run("finds packages in build/packages", func(t *testing.T) { dir := t.TempDir() - packagesDir := filepath.Join(dir, "build", "packages") - require.NoError(t, os.MkdirAll(packagesDir, 0755)) + packagesDir := ax.Join(dir, "build", "packages") + require.NoError(t, ax.MkdirAll(packagesDir, 0755)) // Create mock package files - require.NoError(t, os.WriteFile(filepath.Join(packagesDir, "test-1.0-linux-x86_64.tar.xz"), []byte("pkg"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(packagesDir, "test-1.0-linux-x86_64.tar.xz.sha256"), []byte("checksum"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(packagesDir, "test-1.0-linux-x86_64.rpm"), []byte("rpm"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(packagesDir, "test-1.0-linux-x86_64.tar.xz"), []byte("pkg"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(packagesDir, "test-1.0-linux-x86_64.tar.xz.sha256"), []byte("checksum"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(packagesDir, "test-1.0-linux-x86_64.rpm"), []byte("rpm"), 0644)) builder := NewCPPBuilder() target := build.Target{OS: "linux", Arch: "amd64"} @@ -116,21 +116,21 @@ func TestCPPBuilder_FindArtifacts_Good(t *testing.T) { for _, a := range artifacts { assert.Equal(t, "linux", a.OS) assert.Equal(t, "amd64", a.Arch) - assert.False(t, filepath.Ext(a.Path) == ".sha256") + assert.False(t, ax.Ext(a.Path) == ".sha256") } }) t.Run("falls back to binaries in build/release/src", func(t *testing.T) { dir := t.TempDir() - binDir := filepath.Join(dir, "build", "release", "src") - require.NoError(t, os.MkdirAll(binDir, 0755)) + binDir := ax.Join(dir, "build", "release", "src") + require.NoError(t, ax.MkdirAll(binDir, 0755)) // Create mock binary (executable) - binPath := filepath.Join(binDir, "test-daemon") - require.NoError(t, os.WriteFile(binPath, []byte("binary"), 0755)) + binPath := ax.Join(binDir, "test-daemon") + require.NoError(t, ax.WriteFile(binPath, []byte("binary"), 0755)) // Create a library (should be skipped) - require.NoError(t, os.WriteFile(filepath.Join(binDir, "libcrypto.a"), []byte("lib"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(binDir, "libcrypto.a"), []byte("lib"), 0644)) builder := NewCPPBuilder() target := build.Target{OS: "linux", Arch: "amd64"} @@ -143,7 +143,7 @@ func TestCPPBuilder_FindArtifacts_Good(t *testing.T) { }) } -func TestCPPBuilder_Interface_Good(t *testing.T) { +func TestCPP_CPPBuilderInterface_Good(t *testing.T) { var _ build.Builder = (*CPPBuilder)(nil) var _ build.Builder = NewCPPBuilder() } diff --git a/pkg/build/builders/docker.go b/pkg/build/builders/docker.go index 7025bce..6cff56b 100644 --- a/pkg/build/builders/docker.go +++ b/pkg/build/builders/docker.go @@ -3,33 +3,34 @@ package builders import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // DockerBuilder builds Docker images. +// Usage example: declare a value of type builders.DockerBuilder in integrating code. type DockerBuilder struct{} // NewDockerBuilder creates a new Docker builder. +// Usage example: call builders.NewDockerBuilder(...) from integrating code. func NewDockerBuilder() *DockerBuilder { return &DockerBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *DockerBuilder) Name() string { return "docker" } // Detect checks if a Dockerfile exists in the directory. +// Usage example: call value.Detect(...) from integrating code. func (b *DockerBuilder) Detect(fs io.Medium, dir string) (bool, error) { - dockerfilePath := filepath.Join(dir, "Dockerfile") + dockerfilePath := ax.Join(dir, "Dockerfile") if fs.IsFile(dockerfilePath) { return true, nil } @@ -37,6 +38,7 @@ func (b *DockerBuilder) Detect(fs io.Medium, dir string) (bool, error) { } // Build builds Docker images for the specified targets. +// Usage example: call value.Build(...) from integrating code. func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { // Validate docker CLI is available if err := b.validateDockerCli(); err != nil { @@ -51,7 +53,7 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] // Determine Dockerfile path dockerfile := cfg.Dockerfile if dockerfile == "" { - dockerfile = filepath.Join(cfg.ProjectDir, "Dockerfile") + dockerfile = ax.Join(cfg.ProjectDir, "Dockerfile") } // Validate Dockerfile exists @@ -65,13 +67,13 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] imageName = cfg.Name } if imageName == "" { - imageName = filepath.Base(cfg.ProjectDir) + imageName = ax.Base(cfg.ProjectDir) } // Build platform string from targets var platforms []string for _, t := range targets { - platforms = append(platforms, fmt.Sprintf("%s/%s", t.OS, t.Arch)) + platforms = append(platforms, core.Sprintf("%s/%s", t.OS, t.Arch)) } // If no targets specified, use current platform @@ -98,13 +100,13 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] var imageRefs []string for _, tag := range tags { // Expand version template - expandedTag := strings.ReplaceAll(tag, "{{.Version}}", cfg.Version) - expandedTag = strings.ReplaceAll(expandedTag, "{{Version}}", cfg.Version) + expandedTag := core.Replace(tag, "{{.Version}}", cfg.Version) + expandedTag = core.Replace(expandedTag, "{{Version}}", cfg.Version) if registry != "" { - imageRefs = append(imageRefs, fmt.Sprintf("%s/%s:%s", registry, imageName, expandedTag)) + imageRefs = append(imageRefs, core.Sprintf("%s/%s:%s", registry, imageName, expandedTag)) } else { - imageRefs = append(imageRefs, fmt.Sprintf("%s:%s", imageName, expandedTag)) + imageRefs = append(imageRefs, core.Sprintf("%s:%s", imageName, expandedTag)) } } @@ -112,7 +114,7 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] args := []string{"buildx", "build"} // Multi-platform support - args = append(args, "--platform", strings.Join(platforms, ",")) + args = append(args, "--platform", core.Join(",", platforms...)) // Add all tags for _, ref := range imageRefs { @@ -124,14 +126,14 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] // Build arguments for k, v := range cfg.BuildArgs { - expandedValue := strings.ReplaceAll(v, "{{.Version}}", cfg.Version) - expandedValue = strings.ReplaceAll(expandedValue, "{{Version}}", cfg.Version) - args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, expandedValue)) + expandedValue := core.Replace(v, "{{.Version}}", cfg.Version) + expandedValue = core.Replace(expandedValue, "{{Version}}", cfg.Version) + args = append(args, "--build-arg", core.Sprintf("%s=%s", k, expandedValue)) } // Always add VERSION build arg if version is set if cfg.Version != "" { - args = append(args, "--build-arg", fmt.Sprintf("VERSION=%s", cfg.Version)) + args = append(args, "--build-arg", core.Sprintf("VERSION=%s", cfg.Version)) } // Output to local docker images or push @@ -143,8 +145,8 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] args = append(args, "--load") } else { // Multi-platform builds can't use --load, output to tarball - outputPath := filepath.Join(cfg.OutputDir, fmt.Sprintf("%s.tar", imageName)) - args = append(args, "--output", fmt.Sprintf("type=oci,dest=%s", outputPath)) + outputPath := ax.Join(cfg.OutputDir, core.Sprintf("%s.tar", imageName)) + args = append(args, "--output", core.Sprintf("type=oci,dest=%s", outputPath)) } } @@ -156,17 +158,11 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] return nil, coreerr.E("DockerBuilder.Build", "failed to create output directory", err) } - // Execute build - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Dir = cfg.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr + core.Print(nil, "Building Docker image: %s", imageName) + core.Print(nil, " Platforms: %s", core.Join(", ", platforms...)) + core.Print(nil, " Tags: %s", core.Join(", ", imageRefs...)) - fmt.Printf("Building Docker image: %s\n", imageName) - fmt.Printf(" Platforms: %s\n", strings.Join(platforms, ", ")) - fmt.Printf(" Tags: %s\n", strings.Join(imageRefs, ", ")) - - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(ctx, cfg.ProjectDir, "docker", args...); err != nil { return nil, coreerr.E("DockerBuilder.Build", "buildx build failed", err) } @@ -185,8 +181,7 @@ func (b *DockerBuilder) Build(ctx context.Context, cfg *build.Config, targets [] // validateDockerCli checks if the docker CLI is available. func (b *DockerBuilder) validateDockerCli() error { - cmd := exec.Command("docker", "--version") - if err := cmd.Run(); err != nil { + if _, err := ax.LookPath("docker"); err != nil { return coreerr.E("DockerBuilder.validateDockerCli", "docker CLI not found. Install it from https://docs.docker.com/get-docker/", err) } return nil @@ -195,19 +190,14 @@ func (b *DockerBuilder) validateDockerCli() error { // ensureBuildx ensures docker buildx is available and has a builder. func (b *DockerBuilder) ensureBuildx(ctx context.Context) error { // Check if buildx is available - cmd := exec.CommandContext(ctx, "docker", "buildx", "version") - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", "buildx", "version"); err != nil { return coreerr.E("DockerBuilder.ensureBuildx", "buildx is not available. Install it from https://docs.docker.com/buildx/working-with-buildx/", err) } // Check if we have a builder, create one if not - cmd = exec.CommandContext(ctx, "docker", "buildx", "inspect", "--bootstrap") - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", "buildx", "inspect", "--bootstrap"); err != nil { // Try to create a builder - cmd = exec.CommandContext(ctx, "docker", "buildx", "create", "--use", "--bootstrap") - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", "buildx", "create", "--use", "--bootstrap"); err != nil { return coreerr.E("DockerBuilder.ensureBuildx", "failed to create buildx builder", err) } } diff --git a/pkg/build/builders/docker_test.go b/pkg/build/builders/docker_test.go index 9982d32..81f8b15 100644 --- a/pkg/build/builders/docker_test.go +++ b/pkg/build/builders/docker_test.go @@ -1,27 +1,27 @@ package builders import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestDockerBuilder_Name_Good(t *testing.T) { +func TestDocker_DockerBuilderName_Good(t *testing.T) { builder := NewDockerBuilder() assert.Equal(t, "docker", builder.Name()) } -func TestDockerBuilder_Detect_Good(t *testing.T) { +func TestDocker_DockerBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects Dockerfile", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "Dockerfile"), []byte("FROM alpine\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "Dockerfile"), []byte("FROM alpine\n"), 0644) require.NoError(t, err) builder := NewDockerBuilder() @@ -42,7 +42,7 @@ func TestDockerBuilder_Detect_Good(t *testing.T) { t.Run("returns false for non-Docker project", func(t *testing.T) { dir := t.TempDir() // Create a Go project instead - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test"), 0644) require.NoError(t, err) builder := NewDockerBuilder() @@ -53,7 +53,7 @@ func TestDockerBuilder_Detect_Good(t *testing.T) { t.Run("does not match docker-compose.yml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "docker-compose.yml"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "docker-compose.yml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewDockerBuilder() @@ -64,9 +64,9 @@ func TestDockerBuilder_Detect_Good(t *testing.T) { t.Run("does not match Dockerfile in subdirectory", func(t *testing.T) { dir := t.TempDir() - subDir := filepath.Join(dir, "subdir") - require.NoError(t, os.MkdirAll(subDir, 0755)) - err := os.WriteFile(filepath.Join(subDir, "Dockerfile"), []byte("FROM alpine\n"), 0644) + subDir := ax.Join(dir, "subdir") + require.NoError(t, ax.MkdirAll(subDir, 0755)) + err := ax.WriteFile(ax.Join(subDir, "Dockerfile"), []byte("FROM alpine\n"), 0644) require.NoError(t, err) builder := NewDockerBuilder() @@ -76,7 +76,7 @@ func TestDockerBuilder_Detect_Good(t *testing.T) { }) } -func TestDockerBuilder_Interface_Good(t *testing.T) { +func TestDocker_DockerBuilderInterface_Good(t *testing.T) { // Verify DockerBuilder implements Builder interface var _ build.Builder = (*DockerBuilder)(nil) var _ build.Builder = NewDockerBuilder() diff --git a/pkg/build/builders/go.go b/pkg/build/builders/go.go index 186c984..1a496da 100644 --- a/pkg/build/builders/go.go +++ b/pkg/build/builders/go.go @@ -3,32 +3,33 @@ package builders import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // GoBuilder implements the Builder interface for Go projects. +// Usage example: declare a value of type builders.GoBuilder in integrating code. type GoBuilder struct{} // NewGoBuilder creates a new GoBuilder instance. +// Usage example: call builders.NewGoBuilder(...) from integrating code. func NewGoBuilder() *GoBuilder { return &GoBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *GoBuilder) Name() string { return "go" } // Detect checks if this builder can handle the project in the given directory. // Uses IsGoProject from the build package which checks for go.mod or wails.json. +// Usage example: call value.Detect(...) from integrating code. func (b *GoBuilder) Detect(fs io.Medium, dir string) (bool, error) { return build.IsGoProject(fs, dir), nil } @@ -36,6 +37,7 @@ func (b *GoBuilder) Detect(fs io.Medium, dir string) (bool, error) { // Build compiles the Go project for the specified targets. // It sets GOOS, GOARCH, and CGO_ENABLED environment variables, // applies ldflags and trimpath, and runs go build. +// Usage example: call value.Build(...) from integrating code. func (b *GoBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { if cfg == nil { return nil, coreerr.E("GoBuilder.Build", "config is nil", nil) @@ -68,21 +70,21 @@ func (b *GoBuilder) buildTarget(ctx context.Context, cfg *build.Config, target b // Determine output binary name binaryName := cfg.Name if binaryName == "" { - binaryName = filepath.Base(cfg.ProjectDir) + binaryName = ax.Base(cfg.ProjectDir) } // Add .exe extension for Windows - if target.OS == "windows" && !strings.HasSuffix(binaryName, ".exe") { + if target.OS == "windows" && !core.HasSuffix(binaryName, ".exe") { binaryName += ".exe" } // Create platform-specific output path: output/os_arch/binary - platformDir := filepath.Join(cfg.OutputDir, fmt.Sprintf("%s_%s", target.OS, target.Arch)) + platformDir := ax.Join(cfg.OutputDir, core.Sprintf("%s_%s", target.OS, target.Arch)) if err := cfg.FS.EnsureDir(platformDir); err != nil { return build.Artifact{}, coreerr.E("GoBuilder.buildTarget", "failed to create platform directory", err) } - outputPath := filepath.Join(platformDir, binaryName) + outputPath := ax.Join(platformDir, binaryName) // Build the go build arguments args := []string{"build"} @@ -92,7 +94,7 @@ func (b *GoBuilder) buildTarget(ctx context.Context, cfg *build.Config, target b // Add ldflags if specified if len(cfg.LDFlags) > 0 { - ldflags := strings.Join(cfg.LDFlags, " ") + ldflags := core.Join(" ", cfg.LDFlags...) args = append(args, "-ldflags", ldflags) } @@ -102,25 +104,21 @@ func (b *GoBuilder) buildTarget(ctx context.Context, cfg *build.Config, target b // Add the project directory as the build target (current directory) args = append(args, ".") - // Create the command - cmd := exec.CommandContext(ctx, "go", args...) - cmd.Dir = cfg.ProjectDir - // Set up environment - env := os.Environ() - env = append(env, fmt.Sprintf("GOOS=%s", target.OS)) - env = append(env, fmt.Sprintf("GOARCH=%s", target.Arch)) + env := []string{ + core.Sprintf("GOOS=%s", target.OS), + core.Sprintf("GOARCH=%s", target.Arch), + } if cfg.CGO { env = append(env, "CGO_ENABLED=1") } else { env = append(env, "CGO_ENABLED=0") } - cmd.Env = env // Capture output for error messages - output, err := cmd.CombinedOutput() + output, err := ax.CombinedOutput(ctx, cfg.ProjectDir, env, "go", args...) if err != nil { - return build.Artifact{}, coreerr.E("GoBuilder.buildTarget", "go build failed: "+string(output), err) + return build.Artifact{}, coreerr.E("GoBuilder.buildTarget", "go build failed: "+output, err) } return build.Artifact{ diff --git a/pkg/build/builders/go_test.go b/pkg/build/builders/go_test.go index 7eeb8cd..b0b3167 100644 --- a/pkg/build/builders/go_test.go +++ b/pkg/build/builders/go_test.go @@ -2,11 +2,11 @@ package builders import ( "context" - "os" - "path/filepath" "runtime" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" @@ -23,7 +23,7 @@ func setupGoTestProject(t *testing.T) string { go 1.21 ` - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte(goMod), 0644) require.NoError(t, err) // Create a minimal main.go @@ -33,22 +33,22 @@ func main() { println("hello") } ` - err = os.WriteFile(filepath.Join(dir, "main.go"), []byte(mainGo), 0644) + err = ax.WriteFile(ax.Join(dir, "main.go"), []byte(mainGo), 0644) require.NoError(t, err) return dir } -func TestGoBuilder_Name_Good(t *testing.T) { +func TestGo_GoBuilderName_Good(t *testing.T) { builder := NewGoBuilder() assert.Equal(t, "go", builder.Name()) } -func TestGoBuilder_Detect_Good(t *testing.T) { +func TestGo_GoBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects Go project with go.mod", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test"), 0644) require.NoError(t, err) builder := NewGoBuilder() @@ -59,7 +59,7 @@ func TestGoBuilder_Detect_Good(t *testing.T) { t.Run("detects Wails project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "wails.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "wails.json"), []byte("{}"), 0644) require.NoError(t, err) builder := NewGoBuilder() @@ -71,7 +71,7 @@ func TestGoBuilder_Detect_Good(t *testing.T) { t.Run("returns false for non-Go project", func(t *testing.T) { dir := t.TempDir() // Create a Node.js project instead - err := os.WriteFile(filepath.Join(dir, "package.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "package.json"), []byte("{}"), 0644) require.NoError(t, err) builder := NewGoBuilder() @@ -90,7 +90,7 @@ func TestGoBuilder_Detect_Good(t *testing.T) { }) } -func TestGoBuilder_Build_Good(t *testing.T) { +func TestGo_GoBuilderBuild_Good(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } @@ -178,7 +178,7 @@ func TestGoBuilder_Build_Good(t *testing.T) { require.Len(t, artifacts, 1) // Verify .exe extension - assert.True(t, filepath.Ext(artifacts[0].Path) == ".exe") + assert.True(t, ax.Ext(artifacts[0].Path) == ".exe") assert.FileExists(t, artifacts[0].Path) }) @@ -202,7 +202,7 @@ func TestGoBuilder_Build_Good(t *testing.T) { require.Len(t, artifacts, 1) // Binary should use the project directory base name - baseName := filepath.Base(projectDir) + baseName := ax.Base(projectDir) if runtime.GOOS == "windows" { baseName += ".exe" } @@ -233,7 +233,7 @@ func TestGoBuilder_Build_Good(t *testing.T) { t.Run("creates output directory if missing", func(t *testing.T) { projectDir := setupGoTestProject(t) - outputDir := filepath.Join(t.TempDir(), "nested", "output") + outputDir := ax.Join(t.TempDir(), "nested", "output") builder := NewGoBuilder() cfg := &build.Config{ @@ -254,7 +254,7 @@ func TestGoBuilder_Build_Good(t *testing.T) { }) } -func TestGoBuilder_Build_Bad(t *testing.T) { +func TestGo_GoBuilderBuild_Bad(t *testing.T) { t.Run("returns error for nil config", func(t *testing.T) { builder := NewGoBuilder() @@ -310,11 +310,11 @@ func TestGoBuilder_Build_Bad(t *testing.T) { dir := t.TempDir() // Create go.mod - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test\n\ngo 1.21"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test\n\ngo 1.21"), 0644) require.NoError(t, err) // Create invalid Go code - err = os.WriteFile(filepath.Join(dir, "main.go"), []byte("this is not valid go code"), 0644) + err = ax.WriteFile(ax.Join(dir, "main.go"), []byte("this is not valid go code"), 0644) require.NoError(t, err) builder := NewGoBuilder() @@ -391,7 +391,7 @@ func TestGoBuilder_Build_Bad(t *testing.T) { }) } -func TestGoBuilder_Interface_Good(t *testing.T) { +func TestGo_GoBuilderInterface_Good(t *testing.T) { // Verify GoBuilder implements Builder interface var _ build.Builder = (*GoBuilder)(nil) var _ build.Builder = NewGoBuilder() diff --git a/pkg/build/builders/linuxkit.go b/pkg/build/builders/linuxkit.go index 3cb5907..812b0db 100644 --- a/pkg/build/builders/linuxkit.go +++ b/pkg/build/builders/linuxkit.go @@ -3,43 +3,44 @@ package builders import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // LinuxKitBuilder builds LinuxKit images. +// Usage example: declare a value of type builders.LinuxKitBuilder in integrating code. type LinuxKitBuilder struct{} // NewLinuxKitBuilder creates a new LinuxKit builder. +// Usage example: call builders.NewLinuxKitBuilder(...) from integrating code. func NewLinuxKitBuilder() *LinuxKitBuilder { return &LinuxKitBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *LinuxKitBuilder) Name() string { return "linuxkit" } // Detect checks if a linuxkit.yml or .yml config exists in the directory. +// Usage example: call value.Detect(...) from integrating code. func (b *LinuxKitBuilder) Detect(fs io.Medium, dir string) (bool, error) { // Check for linuxkit.yml - if fs.IsFile(filepath.Join(dir, "linuxkit.yml")) { + if fs.IsFile(ax.Join(dir, "linuxkit.yml")) { return true, nil } // Check for .core/linuxkit/ - lkDir := filepath.Join(dir, ".core", "linuxkit") + lkDir := ax.Join(dir, ".core", "linuxkit") if fs.IsDir(lkDir) { entries, err := fs.List(lkDir) if err == nil { for _, entry := range entries { - if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".yml") { + if !entry.IsDir() && core.HasSuffix(entry.Name(), ".yml") { return true, nil } } @@ -49,6 +50,7 @@ func (b *LinuxKitBuilder) Detect(fs io.Medium, dir string) (bool, error) { } // Build builds LinuxKit images for the specified targets. +// Usage example: call value.Build(...) from integrating code. func (b *LinuxKitBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { // Validate linuxkit CLI is available if err := b.validateLinuxKitCli(); err != nil { @@ -59,17 +61,17 @@ func (b *LinuxKitBuilder) Build(ctx context.Context, cfg *build.Config, targets configPath := cfg.LinuxKitConfig if configPath == "" { // Auto-detect - if cfg.FS.IsFile(filepath.Join(cfg.ProjectDir, "linuxkit.yml")) { - configPath = filepath.Join(cfg.ProjectDir, "linuxkit.yml") + if cfg.FS.IsFile(ax.Join(cfg.ProjectDir, "linuxkit.yml")) { + configPath = ax.Join(cfg.ProjectDir, "linuxkit.yml") } else { // Look in .core/linuxkit/ - lkDir := filepath.Join(cfg.ProjectDir, ".core", "linuxkit") + lkDir := ax.Join(cfg.ProjectDir, ".core", "linuxkit") if cfg.FS.IsDir(lkDir) { entries, err := cfg.FS.List(lkDir) if err == nil { for _, entry := range entries { - if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".yml") { - configPath = filepath.Join(lkDir, entry.Name()) + if !entry.IsDir() && core.HasSuffix(entry.Name(), ".yml") { + configPath = ax.Join(lkDir, entry.Name()) break } } @@ -96,7 +98,7 @@ func (b *LinuxKitBuilder) Build(ctx context.Context, cfg *build.Config, targets // Create output directory outputDir := cfg.OutputDir if outputDir == "" { - outputDir = filepath.Join(cfg.ProjectDir, "dist") + outputDir = ax.Join(cfg.ProjectDir, "dist") } if err := cfg.FS.EnsureDir(outputDir); err != nil { return nil, coreerr.E("LinuxKitBuilder.Build", "failed to create output directory", err) @@ -105,7 +107,7 @@ func (b *LinuxKitBuilder) Build(ctx context.Context, cfg *build.Config, targets // Determine base name from config file or project name baseName := cfg.Name if baseName == "" { - baseName = strings.TrimSuffix(filepath.Base(configPath), ".yml") + baseName = core.TrimSuffix(ax.Base(configPath), ".yml") } // If no targets, default to linux/amd64 @@ -119,23 +121,17 @@ func (b *LinuxKitBuilder) Build(ctx context.Context, cfg *build.Config, targets for _, target := range targets { // LinuxKit only supports Linux if target.OS != "linux" { - fmt.Printf("Skipping %s/%s (LinuxKit only supports Linux)\n", target.OS, target.Arch) + core.Print(nil, "Skipping %s/%s (LinuxKit only supports Linux)", target.OS, target.Arch) continue } for _, format := range formats { - outputName := fmt.Sprintf("%s-%s", baseName, target.Arch) + outputName := core.Sprintf("%s-%s", baseName, target.Arch) args := b.buildLinuxKitArgs(configPath, format, outputName, outputDir, target.Arch) - cmd := exec.CommandContext(ctx, "linuxkit", args...) - cmd.Dir = cfg.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - fmt.Printf("Building LinuxKit image: %s (%s, %s)\n", outputName, format, target.Arch) - - if err := cmd.Run(); err != nil { + core.Print(nil, "Building LinuxKit image: %s (%s, %s)", outputName, format, target.Arch) + if err := ax.ExecDir(ctx, cfg.ProjectDir, "linuxkit", args...); err != nil { return nil, coreerr.E("LinuxKitBuilder.Build", "build failed for "+target.Arch+"/"+format, err) } @@ -189,7 +185,7 @@ func (b *LinuxKitBuilder) buildLinuxKitArgs(configPath, format, outputName, outp // getArtifactPath returns the expected path of the built artifact. func (b *LinuxKitBuilder) getArtifactPath(outputDir, outputName, format string) string { ext := b.getFormatExtension(format) - return filepath.Join(outputDir, outputName+ext) + return ax.Join(outputDir, outputName+ext) } // findArtifact searches for the built artifact with various naming conventions. @@ -202,7 +198,7 @@ func (b *LinuxKitBuilder) findArtifact(fs io.Medium, outputDir, outputName, form } for _, ext := range extensions { - path := filepath.Join(outputDir, outputName+ext) + path := ax.Join(outputDir, outputName+ext) if fs.Exists(path) { return path } @@ -212,10 +208,10 @@ func (b *LinuxKitBuilder) findArtifact(fs io.Medium, outputDir, outputName, form entries, err := fs.List(outputDir) if err == nil { for _, entry := range entries { - if strings.HasPrefix(entry.Name(), outputName) { - match := filepath.Join(outputDir, entry.Name()) + if core.HasPrefix(entry.Name(), outputName) { + match := ax.Join(outputDir, entry.Name()) // Return first match that looks like an image - ext := filepath.Ext(match) + ext := ax.Ext(match) if ext == ".iso" || ext == ".qcow2" || ext == ".raw" || ext == ".vmdk" || ext == ".vhd" { return match } @@ -244,14 +240,14 @@ func (b *LinuxKitBuilder) getFormatExtension(format string) string { case "aws": return ".raw" default: - return "." + strings.TrimSuffix(format, "-bios") + return "." + core.TrimSuffix(format, "-bios") } } // validateLinuxKitCli checks if the linuxkit CLI is available. func (b *LinuxKitBuilder) validateLinuxKitCli() error { // Check PATH first - if _, err := exec.LookPath("linuxkit"); err == nil { + if _, err := ax.LookPath("linuxkit"); err == nil { return nil } diff --git a/pkg/build/builders/linuxkit_test.go b/pkg/build/builders/linuxkit_test.go index 1315d91..0d63b99 100644 --- a/pkg/build/builders/linuxkit_test.go +++ b/pkg/build/builders/linuxkit_test.go @@ -1,27 +1,27 @@ package builders import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestLinuxKitBuilder_Name_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderName_Good(t *testing.T) { builder := NewLinuxKitBuilder() assert.Equal(t, "linuxkit", builder.Name()) } -func TestLinuxKitBuilder_Detect_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects linuxkit.yml in root", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "linuxkit.yml"), []byte("kernel:\n image: test\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "linuxkit.yml"), []byte("kernel:\n image: test\n"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -32,9 +32,9 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("detects .core/linuxkit/*.yml", func(t *testing.T) { dir := t.TempDir() - lkDir := filepath.Join(dir, ".core", "linuxkit") - require.NoError(t, os.MkdirAll(lkDir, 0755)) - err := os.WriteFile(filepath.Join(lkDir, "server.yml"), []byte("kernel:\n image: test\n"), 0644) + lkDir := ax.Join(dir, ".core", "linuxkit") + require.NoError(t, ax.MkdirAll(lkDir, 0755)) + err := ax.WriteFile(ax.Join(lkDir, "server.yml"), []byte("kernel:\n image: test\n"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -45,11 +45,11 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("detects .core/linuxkit with multiple yml files", func(t *testing.T) { dir := t.TempDir() - lkDir := filepath.Join(dir, ".core", "linuxkit") - require.NoError(t, os.MkdirAll(lkDir, 0755)) - err := os.WriteFile(filepath.Join(lkDir, "server.yml"), []byte("kernel:\n"), 0644) + lkDir := ax.Join(dir, ".core", "linuxkit") + require.NoError(t, ax.MkdirAll(lkDir, 0755)) + err := ax.WriteFile(ax.Join(lkDir, "server.yml"), []byte("kernel:\n"), 0644) require.NoError(t, err) - err = os.WriteFile(filepath.Join(lkDir, "desktop.yml"), []byte("kernel:\n"), 0644) + err = ax.WriteFile(ax.Join(lkDir, "desktop.yml"), []byte("kernel:\n"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -69,7 +69,7 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("returns false for non-LinuxKit project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -80,8 +80,8 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("returns false for empty .core/linuxkit directory", func(t *testing.T) { dir := t.TempDir() - lkDir := filepath.Join(dir, ".core", "linuxkit") - require.NoError(t, os.MkdirAll(lkDir, 0755)) + lkDir := ax.Join(dir, ".core", "linuxkit") + require.NoError(t, ax.MkdirAll(lkDir, 0755)) builder := NewLinuxKitBuilder() detected, err := builder.Detect(fs, dir) @@ -91,9 +91,9 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("returns false when .core/linuxkit has only non-yml files", func(t *testing.T) { dir := t.TempDir() - lkDir := filepath.Join(dir, ".core", "linuxkit") - require.NoError(t, os.MkdirAll(lkDir, 0755)) - err := os.WriteFile(filepath.Join(lkDir, "README.md"), []byte("# LinuxKit\n"), 0644) + lkDir := ax.Join(dir, ".core", "linuxkit") + require.NoError(t, ax.MkdirAll(lkDir, 0755)) + err := ax.WriteFile(ax.Join(lkDir, "README.md"), []byte("# LinuxKit\n"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -104,11 +104,11 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { t.Run("ignores subdirectories in .core/linuxkit", func(t *testing.T) { dir := t.TempDir() - lkDir := filepath.Join(dir, ".core", "linuxkit") - subDir := filepath.Join(lkDir, "subdir") - require.NoError(t, os.MkdirAll(subDir, 0755)) + lkDir := ax.Join(dir, ".core", "linuxkit") + subDir := ax.Join(lkDir, "subdir") + require.NoError(t, ax.MkdirAll(subDir, 0755)) // Put yml in subdir only, not in lkDir itself - err := os.WriteFile(filepath.Join(subDir, "server.yml"), []byte("kernel:\n"), 0644) + err := ax.WriteFile(ax.Join(subDir, "server.yml"), []byte("kernel:\n"), 0644) require.NoError(t, err) builder := NewLinuxKitBuilder() @@ -118,7 +118,7 @@ func TestLinuxKitBuilder_Detect_Good(t *testing.T) { }) } -func TestLinuxKitBuilder_GetFormatExtension_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderGetFormatExtension_Good(t *testing.T) { builder := NewLinuxKitBuilder() tests := []struct { @@ -149,7 +149,7 @@ func TestLinuxKitBuilder_GetFormatExtension_Good(t *testing.T) { } } -func TestLinuxKitBuilder_GetArtifactPath_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderGetArtifactPath_Good(t *testing.T) { builder := NewLinuxKitBuilder() t.Run("constructs correct path", func(t *testing.T) { @@ -163,7 +163,7 @@ func TestLinuxKitBuilder_GetArtifactPath_Good(t *testing.T) { }) } -func TestLinuxKitBuilder_BuildLinuxKitArgs_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderBuildLinuxKitArgs_Good(t *testing.T) { builder := NewLinuxKitBuilder() t.Run("builds args for amd64 without --arch", func(t *testing.T) { @@ -186,14 +186,14 @@ func TestLinuxKitBuilder_BuildLinuxKitArgs_Good(t *testing.T) { }) } -func TestLinuxKitBuilder_FindArtifact_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderFindArtifact_Good(t *testing.T) { fs := io.Local builder := NewLinuxKitBuilder() t.Run("finds artifact with exact extension", func(t *testing.T) { dir := t.TempDir() - artifactPath := filepath.Join(dir, "server-amd64.iso") - require.NoError(t, os.WriteFile(artifactPath, []byte("fake iso"), 0644)) + artifactPath := ax.Join(dir, "server-amd64.iso") + require.NoError(t, ax.WriteFile(artifactPath, []byte("fake iso"), 0644)) found := builder.findArtifact(fs, dir, "server-amd64", "iso") assert.Equal(t, artifactPath, found) @@ -209,15 +209,15 @@ func TestLinuxKitBuilder_FindArtifact_Good(t *testing.T) { t.Run("finds artifact with alternate naming", func(t *testing.T) { dir := t.TempDir() // Create file matching the name prefix + known image extension - artifactPath := filepath.Join(dir, "server-amd64.qcow2") - require.NoError(t, os.WriteFile(artifactPath, []byte("fake qcow2"), 0644)) + artifactPath := ax.Join(dir, "server-amd64.qcow2") + require.NoError(t, ax.WriteFile(artifactPath, []byte("fake qcow2"), 0644)) found := builder.findArtifact(fs, dir, "server-amd64", "qcow2") assert.Equal(t, artifactPath, found) }) } -func TestLinuxKitBuilder_Interface_Good(t *testing.T) { +func TestLinuxKit_LinuxKitBuilderInterface_Good(t *testing.T) { // Verify LinuxKitBuilder implements Builder interface var _ build.Builder = (*LinuxKitBuilder)(nil) var _ build.Builder = NewLinuxKitBuilder() diff --git a/pkg/build/builders/taskfile.go b/pkg/build/builders/taskfile.go index 0a36906..cf8deda 100644 --- a/pkg/build/builders/taskfile.go +++ b/pkg/build/builders/taskfile.go @@ -3,12 +3,10 @@ package builders import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "path" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -16,19 +14,23 @@ import ( // TaskfileBuilder builds projects using Taskfile (https://taskfile.dev/). // This is a generic builder that can handle any project type that has a Taskfile. +// Usage example: declare a value of type builders.TaskfileBuilder in integrating code. type TaskfileBuilder struct{} // NewTaskfileBuilder creates a new Taskfile builder. +// Usage example: call builders.NewTaskfileBuilder(...) from integrating code. func NewTaskfileBuilder() *TaskfileBuilder { return &TaskfileBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *TaskfileBuilder) Name() string { return "taskfile" } // Detect checks if a Taskfile exists in the directory. +// Usage example: call value.Detect(...) from integrating code. func (b *TaskfileBuilder) Detect(fs io.Medium, dir string) (bool, error) { // Check for Taskfile.yml, Taskfile.yaml, or Taskfile taskfiles := []string{ @@ -40,7 +42,7 @@ func (b *TaskfileBuilder) Detect(fs io.Medium, dir string) (bool, error) { } for _, tf := range taskfiles { - if fs.IsFile(filepath.Join(dir, tf)) { + if fs.IsFile(ax.Join(dir, tf)) { return true, nil } } @@ -48,6 +50,7 @@ func (b *TaskfileBuilder) Detect(fs io.Medium, dir string) (bool, error) { } // Build runs the Taskfile build task for each target platform. +// Usage example: call value.Build(...) from integrating code. func (b *TaskfileBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { // Validate task CLI is available if err := b.validateTaskCli(); err != nil { @@ -57,7 +60,7 @@ func (b *TaskfileBuilder) Build(ctx context.Context, cfg *build.Config, targets // Create output directory outputDir := cfg.OutputDir if outputDir == "" { - outputDir = filepath.Join(cfg.ProjectDir, "dist") + outputDir = ax.Join(cfg.ProjectDir, "dist") } if err := cfg.FS.EnsureDir(outputDir); err != nil { return nil, coreerr.E("TaskfileBuilder.Build", "failed to create output directory", err) @@ -94,54 +97,42 @@ func (b *TaskfileBuilder) Build(ctx context.Context, cfg *build.Config, targets func (b *TaskfileBuilder) runTask(ctx context.Context, cfg *build.Config, goos, goarch string) error { // Build task command args := []string{"build"} + env := []string{} // Pass variables if targets are specified if goos != "" { - args = append(args, fmt.Sprintf("GOOS=%s", goos)) + value := core.Sprintf("GOOS=%s", goos) + args = append(args, value) + env = append(env, value) } if goarch != "" { - args = append(args, fmt.Sprintf("GOARCH=%s", goarch)) + value := core.Sprintf("GOARCH=%s", goarch) + args = append(args, value) + env = append(env, value) } if cfg.OutputDir != "" { - args = append(args, fmt.Sprintf("OUTPUT_DIR=%s", cfg.OutputDir)) + value := core.Sprintf("OUTPUT_DIR=%s", cfg.OutputDir) + args = append(args, value) + env = append(env, value) } if cfg.Name != "" { - args = append(args, fmt.Sprintf("NAME=%s", cfg.Name)) + value := core.Sprintf("NAME=%s", cfg.Name) + args = append(args, value) + env = append(env, value) } if cfg.Version != "" { - args = append(args, fmt.Sprintf("VERSION=%s", cfg.Version)) - } - - cmd := exec.CommandContext(ctx, "task", args...) - cmd.Dir = cfg.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - // Set environment variables - cmd.Env = os.Environ() - if goos != "" { - cmd.Env = append(cmd.Env, fmt.Sprintf("GOOS=%s", goos)) - } - if goarch != "" { - cmd.Env = append(cmd.Env, fmt.Sprintf("GOARCH=%s", goarch)) - } - if cfg.OutputDir != "" { - cmd.Env = append(cmd.Env, fmt.Sprintf("OUTPUT_DIR=%s", cfg.OutputDir)) - } - if cfg.Name != "" { - cmd.Env = append(cmd.Env, fmt.Sprintf("NAME=%s", cfg.Name)) - } - if cfg.Version != "" { - cmd.Env = append(cmd.Env, fmt.Sprintf("VERSION=%s", cfg.Version)) + value := core.Sprintf("VERSION=%s", cfg.Version) + args = append(args, value) + env = append(env, value) } if goos != "" && goarch != "" { - fmt.Printf("Running task build for %s/%s\n", goos, goarch) + core.Print(nil, "Running task build for %s/%s", goos, goarch) } else { - fmt.Println("Running task build") + core.Print(nil, "Running task build") } - if err := cmd.Run(); err != nil { + if err := ax.ExecWithEnv(ctx, cfg.ProjectDir, env, "task", args...); err != nil { return coreerr.E("TaskfileBuilder.runTask", "task build failed", err) } @@ -164,12 +155,12 @@ func (b *TaskfileBuilder) findArtifacts(fs io.Medium, outputDir string) []build. // Skip common non-artifact files name := entry.Name() - if strings.HasPrefix(name, ".") || name == "CHECKSUMS.txt" { + if core.HasPrefix(name, ".") || name == "CHECKSUMS.txt" { continue } artifacts = append(artifacts, build.Artifact{ - Path: filepath.Join(outputDir, name), + Path: ax.Join(outputDir, name), OS: "", Arch: "", }) @@ -183,15 +174,15 @@ func (b *TaskfileBuilder) findArtifactsForTarget(fs io.Medium, outputDir string, var artifacts []build.Artifact // 1. Look for platform-specific subdirectory: output/os_arch/ - platformSubdir := filepath.Join(outputDir, fmt.Sprintf("%s_%s", target.OS, target.Arch)) + platformSubdir := ax.Join(outputDir, core.Sprintf("%s_%s", target.OS, target.Arch)) if fs.IsDir(platformSubdir) { entries, _ := fs.List(platformSubdir) for _, entry := range entries { if entry.IsDir() { // Handle .app bundles on macOS - if target.OS == "darwin" && strings.HasSuffix(entry.Name(), ".app") { + if target.OS == "darwin" && core.HasSuffix(entry.Name(), ".app") { artifacts = append(artifacts, build.Artifact{ - Path: filepath.Join(platformSubdir, entry.Name()), + Path: ax.Join(platformSubdir, entry.Name()), OS: target.OS, Arch: target.Arch, }) @@ -199,11 +190,11 @@ func (b *TaskfileBuilder) findArtifactsForTarget(fs io.Medium, outputDir string, continue } // Skip hidden files - if strings.HasPrefix(entry.Name(), ".") { + if core.HasPrefix(entry.Name(), ".") { continue } artifacts = append(artifacts, build.Artifact{ - Path: filepath.Join(platformSubdir, entry.Name()), + Path: ax.Join(platformSubdir, entry.Name()), OS: target.OS, Arch: target.Arch, }) @@ -215,9 +206,9 @@ func (b *TaskfileBuilder) findArtifactsForTarget(fs io.Medium, outputDir string, // 2. Look for files matching the target pattern in the root output dir patterns := []string{ - fmt.Sprintf("*-%s-%s*", target.OS, target.Arch), - fmt.Sprintf("*_%s_%s*", target.OS, target.Arch), - fmt.Sprintf("*-%s*", target.Arch), + core.Sprintf("*-%s-%s*", target.OS, target.Arch), + core.Sprintf("*_%s_%s*", target.OS, target.Arch), + core.Sprintf("*-%s*", target.Arch), } for _, pattern := range patterns { @@ -226,7 +217,7 @@ func (b *TaskfileBuilder) findArtifactsForTarget(fs io.Medium, outputDir string, match := entry.Name() // Simple glob matching if b.matchPattern(match, pattern) { - fullPath := filepath.Join(outputDir, match) + fullPath := ax.Join(outputDir, match) if fs.IsDir(fullPath) { continue } @@ -249,14 +240,14 @@ func (b *TaskfileBuilder) findArtifactsForTarget(fs io.Medium, outputDir string, // matchPattern implements glob matching for Taskfile artifacts. func (b *TaskfileBuilder) matchPattern(name, pattern string) bool { - matched, _ := filepath.Match(pattern, name) + matched, _ := path.Match(pattern, name) return matched } // validateTaskCli checks if the task CLI is available. func (b *TaskfileBuilder) validateTaskCli() error { // Check PATH first - if _, err := exec.LookPath("task"); err == nil { + if _, err := ax.LookPath("task"); err == nil { return nil } diff --git a/pkg/build/builders/taskfile_test.go b/pkg/build/builders/taskfile_test.go index 96810f1..02edaaa 100644 --- a/pkg/build/builders/taskfile_test.go +++ b/pkg/build/builders/taskfile_test.go @@ -1,27 +1,27 @@ package builders import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestTaskfileBuilder_Name_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderName_Good(t *testing.T) { builder := NewTaskfileBuilder() assert.Equal(t, "taskfile", builder.Name()) } -func TestTaskfileBuilder_Detect_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects Taskfile.yml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "Taskfile.yml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -32,7 +32,7 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("detects Taskfile.yaml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "Taskfile.yaml"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "Taskfile.yaml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -43,7 +43,7 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("detects Taskfile (no extension)", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "Taskfile"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "Taskfile"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -54,7 +54,7 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("detects lowercase taskfile.yml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "taskfile.yml"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "taskfile.yml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -65,7 +65,7 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("detects lowercase taskfile.yaml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "taskfile.yaml"), []byte("version: '3'\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "taskfile.yaml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -85,7 +85,7 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("returns false for non-Taskfile project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "Makefile"), []byte("all:\n\techo hello\n"), 0644) + err := ax.WriteFile(ax.Join(dir, "Makefile"), []byte("all:\n\techo hello\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -96,9 +96,9 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { t.Run("does not match Taskfile in subdirectory", func(t *testing.T) { dir := t.TempDir() - subDir := filepath.Join(dir, "subdir") - require.NoError(t, os.MkdirAll(subDir, 0755)) - err := os.WriteFile(filepath.Join(subDir, "Taskfile.yml"), []byte("version: '3'\n"), 0644) + subDir := ax.Join(dir, "subdir") + require.NoError(t, ax.MkdirAll(subDir, 0755)) + err := ax.WriteFile(ax.Join(subDir, "Taskfile.yml"), []byte("version: '3'\n"), 0644) require.NoError(t, err) builder := NewTaskfileBuilder() @@ -108,14 +108,14 @@ func TestTaskfileBuilder_Detect_Good(t *testing.T) { }) } -func TestTaskfileBuilder_FindArtifacts_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderFindArtifacts_Good(t *testing.T) { fs := io.Local builder := NewTaskfileBuilder() t.Run("finds files in output directory", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp"), []byte("binary"), 0755)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp.tar.gz"), []byte("archive"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp"), []byte("binary"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp.tar.gz"), []byte("archive"), 0644)) artifacts := builder.findArtifacts(fs, dir) assert.Len(t, artifacts, 2) @@ -123,8 +123,8 @@ func TestTaskfileBuilder_FindArtifacts_Good(t *testing.T) { t.Run("skips hidden files", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp"), []byte("binary"), 0755)) - require.NoError(t, os.WriteFile(filepath.Join(dir, ".hidden"), []byte("hidden"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp"), []byte("binary"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, ".hidden"), []byte("hidden"), 0644)) artifacts := builder.findArtifacts(fs, dir) assert.Len(t, artifacts, 1) @@ -133,8 +133,8 @@ func TestTaskfileBuilder_FindArtifacts_Good(t *testing.T) { t.Run("skips CHECKSUMS.txt", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp"), []byte("binary"), 0755)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "CHECKSUMS.txt"), []byte("sha256"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp"), []byte("binary"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "CHECKSUMS.txt"), []byte("sha256"), 0644)) artifacts := builder.findArtifacts(fs, dir) assert.Len(t, artifacts, 1) @@ -143,8 +143,8 @@ func TestTaskfileBuilder_FindArtifacts_Good(t *testing.T) { t.Run("skips directories", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp"), []byte("binary"), 0755)) - require.NoError(t, os.MkdirAll(filepath.Join(dir, "subdir"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp"), []byte("binary"), 0755)) + require.NoError(t, ax.MkdirAll(ax.Join(dir, "subdir"), 0755)) artifacts := builder.findArtifacts(fs, dir) assert.Len(t, artifacts, 1) @@ -163,15 +163,15 @@ func TestTaskfileBuilder_FindArtifacts_Good(t *testing.T) { }) } -func TestTaskfileBuilder_FindArtifactsForTarget_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderFindArtifactsForTarget_Good(t *testing.T) { fs := io.Local builder := NewTaskfileBuilder() t.Run("finds artifacts in platform subdirectory", func(t *testing.T) { dir := t.TempDir() - platformDir := filepath.Join(dir, "linux_amd64") - require.NoError(t, os.MkdirAll(platformDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(platformDir, "myapp"), []byte("binary"), 0755)) + platformDir := ax.Join(dir, "linux_amd64") + require.NoError(t, ax.MkdirAll(platformDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(platformDir, "myapp"), []byte("binary"), 0755)) target := build.Target{OS: "linux", Arch: "amd64"} artifacts := builder.findArtifactsForTarget(fs, dir, target) @@ -182,7 +182,7 @@ func TestTaskfileBuilder_FindArtifactsForTarget_Good(t *testing.T) { t.Run("finds artifacts by name pattern in root", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp-linux-amd64"), []byte("binary"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp-linux-amd64"), []byte("binary"), 0755)) target := build.Target{OS: "linux", Arch: "amd64"} artifacts := builder.findArtifactsForTarget(fs, dir, target) @@ -191,7 +191,7 @@ func TestTaskfileBuilder_FindArtifactsForTarget_Good(t *testing.T) { t.Run("returns empty when no matching artifacts", func(t *testing.T) { dir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(dir, "myapp"), []byte("binary"), 0755)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "myapp"), []byte("binary"), 0755)) target := build.Target{OS: "linux", Arch: "arm64"} artifacts := builder.findArtifactsForTarget(fs, dir, target) @@ -200,9 +200,9 @@ func TestTaskfileBuilder_FindArtifactsForTarget_Good(t *testing.T) { t.Run("handles .app bundles on darwin", func(t *testing.T) { dir := t.TempDir() - platformDir := filepath.Join(dir, "darwin_arm64") - appDir := filepath.Join(platformDir, "MyApp.app") - require.NoError(t, os.MkdirAll(appDir, 0755)) + platformDir := ax.Join(dir, "darwin_arm64") + appDir := ax.Join(platformDir, "MyApp.app") + require.NoError(t, ax.MkdirAll(appDir, 0755)) target := build.Target{OS: "darwin", Arch: "arm64"} artifacts := builder.findArtifactsForTarget(fs, dir, target) @@ -211,7 +211,7 @@ func TestTaskfileBuilder_FindArtifactsForTarget_Good(t *testing.T) { }) } -func TestTaskfileBuilder_MatchPattern_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderMatchPattern_Good(t *testing.T) { builder := NewTaskfileBuilder() t.Run("matches simple glob", func(t *testing.T) { @@ -227,7 +227,7 @@ func TestTaskfileBuilder_MatchPattern_Good(t *testing.T) { }) } -func TestTaskfileBuilder_Interface_Good(t *testing.T) { +func TestTaskfile_TaskfileBuilderInterface_Good(t *testing.T) { // Verify TaskfileBuilder implements Builder interface var _ build.Builder = (*TaskfileBuilder)(nil) var _ build.Builder = NewTaskfileBuilder() diff --git a/pkg/build/builders/wails.go b/pkg/build/builders/wails.go index 7d135dc..18b376a 100644 --- a/pkg/build/builders/wails.go +++ b/pkg/build/builders/wails.go @@ -3,31 +3,33 @@ package builders import ( "context" - "fmt" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // WailsBuilder implements the Builder interface for Wails v3 projects. +// Usage example: declare a value of type builders.WailsBuilder in integrating code. type WailsBuilder struct{} // NewWailsBuilder creates a new WailsBuilder instance. +// Usage example: call builders.NewWailsBuilder(...) from integrating code. func NewWailsBuilder() *WailsBuilder { return &WailsBuilder{} } // Name returns the builder's identifier. +// Usage example: call value.Name(...) from integrating code. func (b *WailsBuilder) Name() string { return "wails" } // Detect checks if this builder can handle the project in the given directory. // Uses IsWailsProject from the build package which checks for wails.json. +// Usage example: call value.Detect(...) from integrating code. func (b *WailsBuilder) Detect(fs io.Medium, dir string) (bool, error) { return build.IsWailsProject(fs, dir), nil } @@ -36,6 +38,7 @@ func (b *WailsBuilder) Detect(fs io.Medium, dir string) (bool, error) { // It detects the Wails version and chooses the appropriate build strategy: // - Wails v3: Delegates to Taskfile (error if missing) // - Wails v2: Uses 'wails build' command +// Usage example: call value.Build(...) from integrating code. func (b *WailsBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) { if cfg == nil { return nil, coreerr.E("WailsBuilder.Build", "config is nil", nil) @@ -83,12 +86,12 @@ func (b *WailsBuilder) Build(ctx context.Context, cfg *build.Config, targets []b // isWailsV3 checks if the project uses Wails v3 by inspecting go.mod. func (b *WailsBuilder) isWailsV3(fs io.Medium, dir string) bool { - goModPath := filepath.Join(dir, "go.mod") + goModPath := ax.Join(dir, "go.mod") content, err := fs.Read(goModPath) if err != nil { return false } - return strings.Contains(content, "github.com/wailsapp/wails/v3") + return core.Contains(content, "github.com/wailsapp/wails/v3") } // buildV2Target compiles for a single target platform using wails (v2). @@ -96,35 +99,31 @@ func (b *WailsBuilder) buildV2Target(ctx context.Context, cfg *build.Config, tar // Determine output binary name binaryName := cfg.Name if binaryName == "" { - binaryName = filepath.Base(cfg.ProjectDir) + binaryName = ax.Base(cfg.ProjectDir) } // Build the wails build arguments args := []string{"build"} // Platform - args = append(args, "-platform", fmt.Sprintf("%s/%s", target.OS, target.Arch)) + args = append(args, "-platform", core.Sprintf("%s/%s", target.OS, target.Arch)) // Output (Wails v2 uses -o for the binary name, relative to build/bin usually, but we want to control it) // Actually, Wails v2 is opinionated about output dir (build/bin). // We might need to copy artifacts after build if we want them in cfg.OutputDir. // For now, let's try to let Wails do its thing and find the artifact. - // Create the command - cmd := exec.CommandContext(ctx, "wails", args...) - cmd.Dir = cfg.ProjectDir - // Capture output for error messages - output, err := cmd.CombinedOutput() + output, err := ax.CombinedOutput(ctx, cfg.ProjectDir, nil, "wails", args...) if err != nil { - return build.Artifact{}, coreerr.E("WailsBuilder.buildV2Target", "wails build failed: "+string(output), err) + return build.Artifact{}, coreerr.E("WailsBuilder.buildV2Target", "wails build failed: "+output, err) } // Wails v2 typically outputs to build/bin // We need to move/copy it to our desired output dir // Construct the source path where Wails v2 puts the binary - wailsOutputDir := filepath.Join(cfg.ProjectDir, "build", "bin") + wailsOutputDir := ax.Join(cfg.ProjectDir, "build", "bin") // Find the artifact in Wails output dir sourcePath, err := b.findArtifact(cfg.FS, wailsOutputDir, binaryName, target) @@ -134,12 +133,12 @@ func (b *WailsBuilder) buildV2Target(ctx context.Context, cfg *build.Config, tar // Move/Copy to our output dir // Create platform specific dir in our output - platformDir := filepath.Join(cfg.OutputDir, fmt.Sprintf("%s_%s", target.OS, target.Arch)) + platformDir := ax.Join(cfg.OutputDir, core.Sprintf("%s_%s", target.OS, target.Arch)) if err := cfg.FS.EnsureDir(platformDir); err != nil { return build.Artifact{}, coreerr.E("WailsBuilder.buildV2Target", "failed to create output dir", err) } - destPath := filepath.Join(platformDir, filepath.Base(sourcePath)) + destPath := ax.Join(platformDir, ax.Base(sourcePath)) // Simple copy using the medium content, err := cfg.FS.Read(sourcePath) @@ -165,21 +164,21 @@ func (b *WailsBuilder) findArtifact(fs io.Medium, platformDir, binaryName string case "windows": // Look for NSIS installer first, then plain exe candidates = []string{ - filepath.Join(platformDir, binaryName+"-installer.exe"), - filepath.Join(platformDir, binaryName+".exe"), - filepath.Join(platformDir, binaryName+"-amd64-installer.exe"), + ax.Join(platformDir, binaryName+"-installer.exe"), + ax.Join(platformDir, binaryName+".exe"), + ax.Join(platformDir, binaryName+"-amd64-installer.exe"), } case "darwin": // Look for .dmg, then .app bundle, then plain binary candidates = []string{ - filepath.Join(platformDir, binaryName+".dmg"), - filepath.Join(platformDir, binaryName+".app"), - filepath.Join(platformDir, binaryName), + ax.Join(platformDir, binaryName+".dmg"), + ax.Join(platformDir, binaryName+".app"), + ax.Join(platformDir, binaryName), } default: // Linux and others: look for plain binary candidates = []string{ - filepath.Join(platformDir, binaryName), + ax.Join(platformDir, binaryName), } } @@ -199,11 +198,11 @@ func (b *WailsBuilder) findArtifact(fs io.Medium, platformDir, binaryName string for _, entry := range entries { name := entry.Name() // Skip common non-artifact files - if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".json") { + if core.HasSuffix(name, ".go") || core.HasSuffix(name, ".json") { continue } - path := filepath.Join(platformDir, name) + path := ax.Join(platformDir, name) info, err := entry.Info() if err != nil { continue @@ -211,7 +210,7 @@ func (b *WailsBuilder) findArtifact(fs io.Medium, platformDir, binaryName string // On Unix, check if it's executable; on Windows, check for .exe if target.OS == "windows" { - if strings.HasSuffix(name, ".exe") { + if core.HasSuffix(name, ".exe") { return path, nil } } else if info.Mode()&0111 != 0 || entry.IsDir() { @@ -238,7 +237,7 @@ func detectPackageManager(fs io.Medium, dir string) string { } for _, lf := range lockFiles { - if fs.IsFile(filepath.Join(dir, lf.file)) { + if fs.IsFile(ax.Join(dir, lf.file)) { return lf.manager } } diff --git a/pkg/build/builders/wails_test.go b/pkg/build/builders/wails_test.go index 09243bd..b1b87e5 100644 --- a/pkg/build/builders/wails_test.go +++ b/pkg/build/builders/wails_test.go @@ -2,12 +2,10 @@ package builders import ( "context" - "os" - "os/exec" - "path/filepath" "runtime" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" @@ -24,7 +22,7 @@ func setupWailsTestProject(t *testing.T) string { "name": "testapp", "outputfilename": "testapp" }` - err := os.WriteFile(filepath.Join(dir, "wails.json"), []byte(wailsJSON), 0644) + err := ax.WriteFile(ax.Join(dir, "wails.json"), []byte(wailsJSON), 0o644) require.NoError(t, err) // Create a minimal go.mod @@ -34,7 +32,7 @@ go 1.21 require github.com/wailsapp/wails/v3 v3.0.0 ` - err = os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644) + err = ax.WriteFile(ax.Join(dir, "go.mod"), []byte(goMod), 0o644) require.NoError(t, err) // Create a minimal main.go @@ -44,7 +42,7 @@ func main() { println("hello wails") } ` - err = os.WriteFile(filepath.Join(dir, "main.go"), []byte(mainGo), 0644) + err = ax.WriteFile(ax.Join(dir, "main.go"), []byte(mainGo), 0o644) require.NoError(t, err) // Create a minimal Taskfile.yml @@ -55,7 +53,7 @@ tasks: - mkdir -p {{.OUTPUT_DIR}}/{{.GOOS}}_{{.GOARCH}} - touch {{.OUTPUT_DIR}}/{{.GOOS}}_{{.GOARCH}}/testapp ` - err = os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(taskfile), 0644) + err = ax.WriteFile(ax.Join(dir, "Taskfile.yml"), []byte(taskfile), 0o644) require.NoError(t, err) return dir @@ -67,7 +65,7 @@ func setupWailsV2TestProject(t *testing.T) string { dir := t.TempDir() // wails.json - err := os.WriteFile(filepath.Join(dir, "wails.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "wails.json"), []byte("{}"), 0o644) require.NoError(t, err) // go.mod with v2 @@ -75,19 +73,19 @@ func setupWailsV2TestProject(t *testing.T) string { go 1.21 require github.com/wailsapp/wails/v2 v2.8.0 ` - err = os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644) + err = ax.WriteFile(ax.Join(dir, "go.mod"), []byte(goMod), 0o644) require.NoError(t, err) return dir } -func TestWailsBuilder_Build_Taskfile_Good(t *testing.T) { +func TestWails_WailsBuilderBuildTaskfile_Good(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } // Check if task is available - if _, err := exec.LookPath("task"); err != nil { + if _, err := ax.LookPath("task"); err != nil { t.Skip("task not installed, skipping test") } @@ -104,7 +102,7 @@ tasks: - mkdir -p {{.OUTPUT_DIR}}/{{.GOOS}}_{{.GOARCH}} - touch {{.OUTPUT_DIR}}/{{.GOOS}}_{{.GOARCH}}/testapp ` - err := os.WriteFile(filepath.Join(projectDir, "Taskfile.yml"), []byte(taskfile), 0644) + err := ax.WriteFile(ax.Join(projectDir, "Taskfile.yml"), []byte(taskfile), 0o644) require.NoError(t, err) builder := NewWailsBuilder() @@ -124,17 +122,17 @@ tasks: }) } -func TestWailsBuilder_Name_Good(t *testing.T) { +func TestWails_WailsBuilderName_Good(t *testing.T) { builder := NewWailsBuilder() assert.Equal(t, "wails", builder.Name()) } -func TestWailsBuilder_Build_V2_Good(t *testing.T) { +func TestWails_WailsBuilderBuildV2_Good(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } - if _, err := exec.LookPath("wails"); err != nil { + if _, err := ax.LookPath("wails"); err != nil { t.Skip("wails not installed, skipping integration test") } @@ -162,11 +160,11 @@ func TestWailsBuilder_Build_V2_Good(t *testing.T) { }) } -func TestWailsBuilder_Detect_Good(t *testing.T) { +func TestWails_WailsBuilderDetect_Good(t *testing.T) { fs := io.Local t.Run("detects Wails project with wails.json", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "wails.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "wails.json"), []byte("{}"), 0o644) require.NoError(t, err) builder := NewWailsBuilder() @@ -177,7 +175,7 @@ func TestWailsBuilder_Detect_Good(t *testing.T) { t.Run("returns false for Go-only project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module test"), 0644) + err := ax.WriteFile(ax.Join(dir, "go.mod"), []byte("module test"), 0o644) require.NoError(t, err) builder := NewWailsBuilder() @@ -188,7 +186,7 @@ func TestWailsBuilder_Detect_Good(t *testing.T) { t.Run("returns false for Node.js project", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "package.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "package.json"), []byte("{}"), 0o644) require.NoError(t, err) builder := NewWailsBuilder() @@ -207,11 +205,11 @@ func TestWailsBuilder_Detect_Good(t *testing.T) { }) } -func TestDetectPackageManager_Good(t *testing.T) { +func TestWails_DetectPackageManager_Good(t *testing.T) { fs := io.Local t.Run("detects bun from bun.lockb", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "bun.lockb"), []byte(""), 0644) + err := ax.WriteFile(ax.Join(dir, "bun.lockb"), []byte(""), 0o644) require.NoError(t, err) result := detectPackageManager(fs, dir) @@ -220,7 +218,7 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("detects pnpm from pnpm-lock.yaml", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "pnpm-lock.yaml"), []byte(""), 0644) + err := ax.WriteFile(ax.Join(dir, "pnpm-lock.yaml"), []byte(""), 0o644) require.NoError(t, err) result := detectPackageManager(fs, dir) @@ -229,7 +227,7 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("detects yarn from yarn.lock", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "yarn.lock"), []byte(""), 0644) + err := ax.WriteFile(ax.Join(dir, "yarn.lock"), []byte(""), 0o644) require.NoError(t, err) result := detectPackageManager(fs, dir) @@ -238,7 +236,7 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("detects npm from package-lock.json", func(t *testing.T) { dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "package-lock.json"), []byte(""), 0644) + err := ax.WriteFile(ax.Join(dir, "package-lock.json"), []byte(""), 0o644) require.NoError(t, err) result := detectPackageManager(fs, dir) @@ -255,9 +253,9 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("prefers bun over other lock files", func(t *testing.T) { dir := t.TempDir() // Create multiple lock files - require.NoError(t, os.WriteFile(filepath.Join(dir, "bun.lockb"), []byte(""), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "yarn.lock"), []byte(""), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "package-lock.json"), []byte(""), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "bun.lockb"), []byte(""), 0o644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "yarn.lock"), []byte(""), 0o644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "package-lock.json"), []byte(""), 0o644)) result := detectPackageManager(fs, dir) assert.Equal(t, "bun", result) @@ -266,9 +264,9 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("prefers pnpm over yarn and npm", func(t *testing.T) { dir := t.TempDir() // Create multiple lock files (no bun) - require.NoError(t, os.WriteFile(filepath.Join(dir, "pnpm-lock.yaml"), []byte(""), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "yarn.lock"), []byte(""), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "package-lock.json"), []byte(""), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "pnpm-lock.yaml"), []byte(""), 0o644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "yarn.lock"), []byte(""), 0o644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "package-lock.json"), []byte(""), 0o644)) result := detectPackageManager(fs, dir) assert.Equal(t, "pnpm", result) @@ -277,15 +275,15 @@ func TestDetectPackageManager_Good(t *testing.T) { t.Run("prefers yarn over npm", func(t *testing.T) { dir := t.TempDir() // Create multiple lock files (no bun or pnpm) - require.NoError(t, os.WriteFile(filepath.Join(dir, "yarn.lock"), []byte(""), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(dir, "package-lock.json"), []byte(""), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "yarn.lock"), []byte(""), 0o644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "package-lock.json"), []byte(""), 0o644)) result := detectPackageManager(fs, dir) assert.Equal(t, "yarn", result) }) } -func TestWailsBuilder_Build_Bad(t *testing.T) { +func TestWails_WailsBuilderBuild_Bad(t *testing.T) { t.Run("returns error for nil config", func(t *testing.T) { builder := NewWailsBuilder() @@ -313,13 +311,13 @@ func TestWailsBuilder_Build_Bad(t *testing.T) { }) } -func TestWailsBuilder_Build_Good(t *testing.T) { +func TestWails_WailsBuilderBuild_Good(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } // Check if wails3 is available in PATH - if _, err := exec.LookPath("wails3"); err != nil { + if _, err := ax.LookPath("wails3"); err != nil { t.Skip("wails3 not installed, skipping integration test") } @@ -349,13 +347,13 @@ func TestWailsBuilder_Build_Good(t *testing.T) { }) } -func TestWailsBuilder_Interface_Good(t *testing.T) { +func TestWails_WailsBuilderInterface_Good(t *testing.T) { // Verify WailsBuilder implements Builder interface var _ build.Builder = (*WailsBuilder)(nil) var _ build.Builder = NewWailsBuilder() } -func TestWailsBuilder_Ugly(t *testing.T) { +func TestWails_WailsBuilder_Ugly(t *testing.T) { t.Run("handles nonexistent frontend directory gracefully", func(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") @@ -363,7 +361,7 @@ func TestWailsBuilder_Ugly(t *testing.T) { // Create a Wails project without a frontend directory dir := t.TempDir() - err := os.WriteFile(filepath.Join(dir, "wails.json"), []byte("{}"), 0644) + err := ax.WriteFile(ax.Join(dir, "wails.json"), []byte("{}"), 0o644) require.NoError(t, err) builder := NewWailsBuilder() diff --git a/pkg/build/checksum.go b/pkg/build/checksum.go index e9ea569..c48f8fd 100644 --- a/pkg/build/checksum.go +++ b/pkg/build/checksum.go @@ -13,6 +13,7 @@ import ( ) // Checksum computes SHA256 for an artifact and returns the artifact with the Checksum field filled. +// Usage example: call build.Checksum(...) from integrating code. func Checksum(fs io_interface.Medium, artifact Artifact) (Artifact, error) { if artifact.Path == "" { return Artifact{}, coreerr.E("build.Checksum", "artifact path is empty", nil) @@ -43,6 +44,7 @@ func Checksum(fs io_interface.Medium, artifact Artifact) (Artifact, error) { // ChecksumAll computes checksums for all artifacts. // Returns a slice of artifacts with their Checksum fields filled. +// Usage example: call build.ChecksumAll(...) from integrating code. func ChecksumAll(fs io_interface.Medium, artifacts []Artifact) ([]Artifact, error) { if len(artifacts) == 0 { return nil, nil @@ -67,6 +69,7 @@ func ChecksumAll(fs io_interface.Medium, artifacts []Artifact) ([]Artifact, erro // // The artifacts should have their Checksum fields filled (call ChecksumAll first). // Filenames are relative to the output directory (just the basename). +// Usage example: call build.WriteChecksumFile(...) from integrating code. func WriteChecksumFile(fs io_interface.Medium, artifacts []Artifact, path string) error { if len(artifacts) == 0 { return nil diff --git a/pkg/build/checksum_test.go b/pkg/build/checksum_test.go index 78f4ddc..11f2a6a 100644 --- a/pkg/build/checksum_test.go +++ b/pkg/build/checksum_test.go @@ -1,11 +1,10 @@ package build import ( - "os" - "path/filepath" - "strings" "testing" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -16,14 +15,14 @@ func setupChecksumTestFile(t *testing.T, content string) string { t.Helper() dir := t.TempDir() - path := filepath.Join(dir, "testfile") - err := os.WriteFile(path, []byte(content), 0644) + path := ax.Join(dir, "testfile") + err := ax.WriteFile(path, []byte(content), 0644) require.NoError(t, err) return path } -func TestChecksum_Good(t *testing.T) { +func TestChecksum_Checksum_Good(t *testing.T) { fs := io.Local t.Run("computes SHA256 checksum", func(t *testing.T) { // Known SHA256 of "Hello, World!\n" @@ -99,7 +98,7 @@ func TestChecksum_Good(t *testing.T) { }) } -func TestChecksum_Bad(t *testing.T) { +func TestChecksum_Checksum_Bad(t *testing.T) { fs := io.Local t.Run("returns error for empty path", func(t *testing.T) { artifact := Artifact{ @@ -128,7 +127,7 @@ func TestChecksum_Bad(t *testing.T) { }) } -func TestChecksumAll_Good(t *testing.T) { +func TestChecksum_ChecksumAll_Good(t *testing.T) { fs := io.Local t.Run("checksums multiple artifacts", func(t *testing.T) { paths := []string{ @@ -168,7 +167,7 @@ func TestChecksumAll_Good(t *testing.T) { }) } -func TestChecksumAll_Bad(t *testing.T) { +func TestChecksum_ChecksumAll_Bad(t *testing.T) { fs := io.Local t.Run("returns partial results on error", func(t *testing.T) { path := setupChecksumTestFile(t, "valid content") @@ -186,11 +185,11 @@ func TestChecksumAll_Bad(t *testing.T) { }) } -func TestWriteChecksumFile_Good(t *testing.T) { +func TestChecksum_WriteChecksumFile_Good(t *testing.T) { fs := io.Local t.Run("writes checksum file with correct format", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "CHECKSUMS.txt") artifacts := []Artifact{ {Path: "/output/app_linux_amd64.tar.gz", Checksum: "abc123def456", OS: "linux", Arch: "amd64"}, @@ -201,10 +200,10 @@ func TestWriteChecksumFile_Good(t *testing.T) { require.NoError(t, err) // Read and verify content - content, err := os.ReadFile(checksumPath) + content, err := ax.ReadFile(checksumPath) require.NoError(t, err) - lines := strings.Split(strings.TrimSpace(string(content)), "\n") + lines := core.Split(core.Trim(string(content)), "\n") require.Len(t, lines, 2) // Lines should be sorted alphabetically @@ -214,7 +213,7 @@ func TestWriteChecksumFile_Good(t *testing.T) { t.Run("creates parent directories", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "nested", "deep", "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "nested", "deep", "CHECKSUMS.txt") artifacts := []Artifact{ {Path: "/output/app.tar.gz", Checksum: "abc123", OS: "linux", Arch: "amd64"}, @@ -227,19 +226,18 @@ func TestWriteChecksumFile_Good(t *testing.T) { t.Run("does nothing for empty artifacts", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "CHECKSUMS.txt") err := WriteChecksumFile(fs, []Artifact{}, checksumPath) require.NoError(t, err) // File should not exist - _, err = os.Stat(checksumPath) - assert.True(t, os.IsNotExist(err)) + assert.False(t, ax.Exists(checksumPath)) }) t.Run("does nothing for nil artifacts", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "CHECKSUMS.txt") err := WriteChecksumFile(fs, nil, checksumPath) require.NoError(t, err) @@ -247,7 +245,7 @@ func TestWriteChecksumFile_Good(t *testing.T) { t.Run("uses only basename for filenames", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "CHECKSUMS.txt") artifacts := []Artifact{ {Path: "/some/deep/nested/path/myapp_linux_amd64.tar.gz", Checksum: "checksum123", OS: "linux", Arch: "amd64"}, @@ -256,7 +254,7 @@ func TestWriteChecksumFile_Good(t *testing.T) { err := WriteChecksumFile(fs, artifacts, checksumPath) require.NoError(t, err) - content, err := os.ReadFile(checksumPath) + content, err := ax.ReadFile(checksumPath) require.NoError(t, err) // Should only contain the basename @@ -265,11 +263,11 @@ func TestWriteChecksumFile_Good(t *testing.T) { }) } -func TestWriteChecksumFile_Bad(t *testing.T) { +func TestChecksum_WriteChecksumFile_Bad(t *testing.T) { fs := io.Local t.Run("returns error for artifact without checksum", func(t *testing.T) { dir := t.TempDir() - checksumPath := filepath.Join(dir, "CHECKSUMS.txt") + checksumPath := ax.Join(dir, "CHECKSUMS.txt") artifacts := []Artifact{ {Path: "/output/app.tar.gz", Checksum: "", OS: "linux", Arch: "amd64"}, // No checksum diff --git a/pkg/build/config.go b/pkg/build/config.go index ea761f6..7acdbad 100644 --- a/pkg/build/config.go +++ b/pkg/build/config.go @@ -4,9 +4,8 @@ package build import ( "iter" - "os" - "path/filepath" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build/signing" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -14,13 +13,16 @@ import ( ) // ConfigFileName is the name of the build configuration file. +// Usage example: reference build.ConfigFileName from package consumers. const ConfigFileName = "build.yaml" // ConfigDir is the directory where build configuration is stored. +// Usage example: reference build.ConfigDir from package consumers. const ConfigDir = ".core" // BuildConfig holds the complete build configuration loaded from .core/build.yaml. // This is distinct from Config which holds runtime build parameters. +// Usage example: declare a value of type build.BuildConfig in integrating code. type BuildConfig struct { // Version is the config file format version. Version int `yaml:"version"` @@ -35,6 +37,7 @@ type BuildConfig struct { } // Project holds project metadata. +// Usage example: declare a value of type build.Project in integrating code. type Project struct { // Name is the project name. Name string `yaml:"name"` @@ -47,6 +50,7 @@ type Project struct { } // Build holds build-time settings. +// Usage example: declare a value of type build.Build in integrating code. type Build struct { // Type overrides project type auto-detection (e.g., "go", "wails", "docker"). Type string `yaml:"type"` @@ -62,6 +66,7 @@ type Build struct { // TargetConfig defines a build target in the config file. // This is separate from Target to allow for additional config-specific fields. +// Usage example: declare a value of type build.TargetConfig in integrating code. type TargetConfig struct { // OS is the target operating system (e.g., "linux", "darwin", "windows"). OS string `yaml:"os"` @@ -72,12 +77,13 @@ type TargetConfig struct { // LoadConfig loads build configuration from the .core/build.yaml file in the given directory. // If the config file does not exist, it returns DefaultConfig(). // Returns an error if the file exists but cannot be parsed. +// Usage example: call build.LoadConfig(...) from integrating code. func LoadConfig(fs io.Medium, dir string) (*BuildConfig, error) { - configPath := filepath.Join(dir, ConfigDir, ConfigFileName) + configPath := ax.Join(dir, ConfigDir, ConfigFileName) content, err := fs.Read(configPath) if err != nil { - if os.IsNotExist(err) { + if !fs.Exists(configPath) { return DefaultConfig(), nil } return nil, coreerr.E("build.LoadConfig", "failed to read config file", err) @@ -96,6 +102,7 @@ func LoadConfig(fs io.Medium, dir string) (*BuildConfig, error) { } // DefaultConfig returns sensible defaults for Go projects. +// Usage example: call build.DefaultConfig(...) from integrating code. func DefaultConfig() *BuildConfig { return &BuildConfig{ Version: 1, @@ -153,16 +160,19 @@ func applyDefaults(cfg *BuildConfig) { } // ConfigPath returns the path to the build config file for a given directory. +// Usage example: call build.ConfigPath(...) from integrating code. func ConfigPath(dir string) string { - return filepath.Join(dir, ConfigDir, ConfigFileName) + return ax.Join(dir, ConfigDir, ConfigFileName) } // ConfigExists checks if a build config file exists in the given directory. +// Usage example: call build.ConfigExists(...) from integrating code. func ConfigExists(fs io.Medium, dir string) bool { return fileExists(fs, ConfigPath(dir)) } // TargetsIter returns an iterator for the build targets. +// Usage example: call value.TargetsIter(...) from integrating code. func (cfg *BuildConfig) TargetsIter() iter.Seq[TargetConfig] { return func(yield func(TargetConfig) bool) { for _, t := range cfg.Targets { @@ -174,6 +184,7 @@ func (cfg *BuildConfig) TargetsIter() iter.Seq[TargetConfig] { } // ToTargets converts TargetConfig slice to Target slice for use with builders. +// Usage example: call value.ToTargets(...) from integrating code. func (cfg *BuildConfig) ToTargets() []Target { targets := make([]Target, len(cfg.Targets)) for i, t := range cfg.Targets { diff --git a/pkg/build/config_test.go b/pkg/build/config_test.go index 552eec8..e47af3b 100644 --- a/pkg/build/config_test.go +++ b/pkg/build/config_test.go @@ -1,10 +1,10 @@ package build import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -16,19 +16,19 @@ func setupConfigTestDir(t *testing.T, configContent string) string { dir := t.TempDir() if configContent != "" { - coreDir := filepath.Join(dir, ConfigDir) - err := os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(dir, ConfigDir) + err := ax.MkdirAll(coreDir, 0755) require.NoError(t, err) - configPath := filepath.Join(coreDir, ConfigFileName) - err = os.WriteFile(configPath, []byte(configContent), 0644) + configPath := ax.Join(coreDir, ConfigFileName) + err = ax.WriteFile(configPath, []byte(configContent), 0644) require.NoError(t, err) } return dir } -func TestLoadConfig_Good(t *testing.T) { +func TestConfig_LoadConfig_Good(t *testing.T) { fs := io.Local t.Run("loads valid config", func(t *testing.T) { content := ` @@ -142,7 +142,7 @@ targets: }) } -func TestLoadConfig_Bad(t *testing.T) { +func TestConfig_LoadConfig_Bad(t *testing.T) { fs := io.Local t.Run("returns error for invalid YAML", func(t *testing.T) { content := ` @@ -160,13 +160,13 @@ project: t.Run("returns error for unreadable file", func(t *testing.T) { dir := t.TempDir() - coreDir := filepath.Join(dir, ConfigDir) - err := os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(dir, ConfigDir) + err := ax.MkdirAll(coreDir, 0755) require.NoError(t, err) // Create config as a directory instead of file - configPath := filepath.Join(coreDir, ConfigFileName) - err = os.Mkdir(configPath, 0755) + configPath := ax.Join(coreDir, ConfigFileName) + err = ax.Mkdir(configPath, 0755) require.NoError(t, err) cfg, err := LoadConfig(fs, dir) @@ -176,7 +176,7 @@ project: }) } -func TestDefaultConfig_Good(t *testing.T) { +func TestConfig_DefaultConfig_Good(t *testing.T) { t.Run("returns sensible defaults", func(t *testing.T) { cfg := DefaultConfig() @@ -212,14 +212,14 @@ func TestDefaultConfig_Good(t *testing.T) { }) } -func TestConfigPath_Good(t *testing.T) { +func TestConfig_ConfigPath_Good(t *testing.T) { t.Run("returns correct path", func(t *testing.T) { path := ConfigPath("/project/root") assert.Equal(t, "/project/root/.core/build.yaml", path) }) } -func TestConfigExists_Good(t *testing.T) { +func TestConfig_ConfigExists_Good(t *testing.T) { fs := io.Local t.Run("returns true when config exists", func(t *testing.T) { dir := setupConfigTestDir(t, "version: 1") @@ -237,10 +237,10 @@ func TestConfigExists_Good(t *testing.T) { }) } -func TestLoadConfig_Good_SignConfig(t *testing.T) { +func TestConfig_LoadConfigSignConfig_Good(t *testing.T) { tmpDir := t.TempDir() - coreDir := filepath.Join(tmpDir, ".core") - _ = os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(tmpDir, ".core") + _ = ax.MkdirAll(coreDir, 0755) configContent := `version: 1 sign: @@ -251,7 +251,7 @@ sign: identity: "Developer ID Application: Test" notarize: true ` - _ = os.WriteFile(filepath.Join(coreDir, "build.yaml"), []byte(configContent), 0644) + _ = ax.WriteFile(ax.Join(coreDir, "build.yaml"), []byte(configContent), 0644) cfg, err := LoadConfig(io.Local, tmpDir) if err != nil { @@ -272,7 +272,7 @@ sign: } } -func TestBuildConfig_ToTargets_Good(t *testing.T) { +func TestConfig_BuildConfigToTargets_Good(t *testing.T) { t.Run("converts TargetConfig to Target", func(t *testing.T) { cfg := &BuildConfig{ Targets: []TargetConfig{ @@ -301,9 +301,9 @@ func TestBuildConfig_ToTargets_Good(t *testing.T) { } // TestLoadConfig_Testdata tests loading from the testdata fixture. -func TestLoadConfig_Testdata(t *testing.T) { +func TestConfig_LoadConfigTestdata_Good(t *testing.T) { fs := io.Local - abs, err := filepath.Abs("testdata/config-project") + abs, err := ax.Abs("testdata/config-project") require.NoError(t, err) t.Run("loads config-project fixture", func(t *testing.T) { diff --git a/pkg/build/discovery.go b/pkg/build/discovery.go index cc5f4a9..eadb28b 100644 --- a/pkg/build/discovery.go +++ b/pkg/build/discovery.go @@ -1,9 +1,8 @@ package build import ( - "path/filepath" - "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" ) @@ -33,11 +32,12 @@ var markers = []projectMarker{ // Discover detects project types in the given directory by checking for marker files. // Returns a slice of detected project types, ordered by priority (most specific first). // For example, a Wails project returns [wails, go] since it has both wails.json and go.mod. +// Usage example: call build.Discover(...) from integrating code. func Discover(fs io.Medium, dir string) ([]ProjectType, error) { var detected []ProjectType for _, m := range markers { - path := filepath.Join(dir, m.file) + path := ax.Join(dir, m.file) if fileExists(fs, path) { // Avoid duplicates (shouldn't happen with current markers, but defensive) if !core.NewArray(detected...).Contains(m.projectType) { @@ -51,6 +51,7 @@ func Discover(fs io.Medium, dir string) ([]ProjectType, error) { // PrimaryType returns the most specific project type detected in the directory. // Returns empty string if no project type is detected. +// Usage example: call build.PrimaryType(...) from integrating code. func PrimaryType(fs io.Medium, dir string) (ProjectType, error) { types, err := Discover(fs, dir) if err != nil { @@ -63,29 +64,34 @@ func PrimaryType(fs io.Medium, dir string) (ProjectType, error) { } // IsGoProject checks if the directory contains a Go project (go.mod or wails.json). +// Usage example: call build.IsGoProject(...) from integrating code. func IsGoProject(fs io.Medium, dir string) bool { - return fileExists(fs, filepath.Join(dir, markerGoMod)) || - fileExists(fs, filepath.Join(dir, markerWails)) + return fileExists(fs, ax.Join(dir, markerGoMod)) || + fileExists(fs, ax.Join(dir, markerWails)) } // IsWailsProject checks if the directory contains a Wails project. +// Usage example: call build.IsWailsProject(...) from integrating code. func IsWailsProject(fs io.Medium, dir string) bool { - return fileExists(fs, filepath.Join(dir, markerWails)) + return fileExists(fs, ax.Join(dir, markerWails)) } // IsNodeProject checks if the directory contains a Node.js project. +// Usage example: call build.IsNodeProject(...) from integrating code. func IsNodeProject(fs io.Medium, dir string) bool { - return fileExists(fs, filepath.Join(dir, markerNodePackage)) + return fileExists(fs, ax.Join(dir, markerNodePackage)) } // IsPHPProject checks if the directory contains a PHP project. +// Usage example: call build.IsPHPProject(...) from integrating code. func IsPHPProject(fs io.Medium, dir string) bool { - return fileExists(fs, filepath.Join(dir, markerComposer)) + return fileExists(fs, ax.Join(dir, markerComposer)) } // IsCPPProject checks if the directory contains a C++ project (CMakeLists.txt). +// Usage example: call build.IsCPPProject(...) from integrating code. func IsCPPProject(fs io.Medium, dir string) bool { - return fileExists(fs, filepath.Join(dir, "CMakeLists.txt")) + return fileExists(fs, ax.Join(dir, "CMakeLists.txt")) } // fileExists checks if a file exists and is not a directory. diff --git a/pkg/build/discovery_test.go b/pkg/build/discovery_test.go index a4653aa..4794eb0 100644 --- a/pkg/build/discovery_test.go +++ b/pkg/build/discovery_test.go @@ -1,10 +1,10 @@ package build import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -15,14 +15,14 @@ func setupTestDir(t *testing.T, markers ...string) string { t.Helper() dir := t.TempDir() for _, m := range markers { - path := filepath.Join(dir, m) - err := os.WriteFile(path, []byte("{}"), 0644) + path := ax.Join(dir, m) + err := ax.WriteFile(path, []byte("{}"), 0644) require.NoError(t, err) } return dir } -func TestDiscover_Good(t *testing.T) { +func TestDiscovery_Discover_Good(t *testing.T) { fs := io.Local t.Run("detects Go project", func(t *testing.T) { dir := setupTestDir(t, "go.mod") @@ -67,18 +67,18 @@ func TestDiscover_Good(t *testing.T) { }) } -func TestDiscover_Bad(t *testing.T) { +func TestDiscovery_Discover_Bad(t *testing.T) { fs := io.Local t.Run("non-existent directory returns empty slice", func(t *testing.T) { types, err := Discover(fs, "/non/existent/path") - assert.NoError(t, err) // os.Stat fails silently in fileExists + assert.NoError(t, err) // ax.Stat fails silently in fileExists assert.Empty(t, types) }) t.Run("directory marker is ignored", func(t *testing.T) { dir := t.TempDir() // Create go.mod as a directory instead of a file - err := os.Mkdir(filepath.Join(dir, "go.mod"), 0755) + err := ax.Mkdir(ax.Join(dir, "go.mod"), 0755) require.NoError(t, err) types, err := Discover(fs, dir) @@ -87,7 +87,7 @@ func TestDiscover_Bad(t *testing.T) { }) } -func TestPrimaryType_Good(t *testing.T) { +func TestDiscovery_PrimaryType_Good(t *testing.T) { fs := io.Local t.Run("returns wails for wails project", func(t *testing.T) { dir := setupTestDir(t, "wails.json", "go.mod") @@ -111,7 +111,7 @@ func TestPrimaryType_Good(t *testing.T) { }) } -func TestIsGoProject_Good(t *testing.T) { +func TestDiscovery_IsGoProject_Good(t *testing.T) { fs := io.Local t.Run("true with go.mod", func(t *testing.T) { dir := setupTestDir(t, "go.mod") @@ -129,7 +129,7 @@ func TestIsGoProject_Good(t *testing.T) { }) } -func TestIsWailsProject_Good(t *testing.T) { +func TestDiscovery_IsWailsProject_Good(t *testing.T) { fs := io.Local t.Run("true with wails.json", func(t *testing.T) { dir := setupTestDir(t, "wails.json") @@ -142,7 +142,7 @@ func TestIsWailsProject_Good(t *testing.T) { }) } -func TestIsNodeProject_Good(t *testing.T) { +func TestDiscovery_IsNodeProject_Good(t *testing.T) { fs := io.Local t.Run("true with package.json", func(t *testing.T) { dir := setupTestDir(t, "package.json") @@ -155,7 +155,7 @@ func TestIsNodeProject_Good(t *testing.T) { }) } -func TestIsPHPProject_Good(t *testing.T) { +func TestDiscovery_IsPHPProject_Good(t *testing.T) { fs := io.Local t.Run("true with composer.json", func(t *testing.T) { dir := setupTestDir(t, "composer.json") @@ -168,17 +168,17 @@ func TestIsPHPProject_Good(t *testing.T) { }) } -func TestTarget_Good(t *testing.T) { +func TestDiscovery_Target_Good(t *testing.T) { target := Target{OS: "linux", Arch: "amd64"} assert.Equal(t, "linux/amd64", target.String()) } -func TestFileExists_Good(t *testing.T) { +func TestDiscovery_FileExists_Good(t *testing.T) { fs := io.Local t.Run("returns true for existing file", func(t *testing.T) { dir := t.TempDir() - path := filepath.Join(dir, "test.txt") - err := os.WriteFile(path, []byte("content"), 0644) + path := ax.Join(dir, "test.txt") + err := ax.WriteFile(path, []byte("content"), 0644) require.NoError(t, err) assert.True(t, fileExists(fs, path)) }) @@ -195,9 +195,9 @@ func TestFileExists_Good(t *testing.T) { // TestDiscover_Testdata tests discovery using the testdata fixtures. // These serve as integration tests with realistic project structures. -func TestDiscover_Testdata(t *testing.T) { +func TestDiscovery_DiscoverTestdata_Good(t *testing.T) { fs := io.Local - testdataDir, err := filepath.Abs("testdata") + testdataDir, err := ax.Abs("testdata") require.NoError(t, err) tests := []struct { @@ -215,7 +215,7 @@ func TestDiscover_Testdata(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - dir := filepath.Join(testdataDir, tt.dir) + dir := ax.Join(testdataDir, tt.dir) types, err := Discover(fs, dir) assert.NoError(t, err) if len(tt.expected) == 0 { diff --git a/pkg/build/signing/codesign.go b/pkg/build/signing/codesign.go index a2d01fe..62c4e28 100644 --- a/pkg/build/signing/codesign.go +++ b/pkg/build/signing/codesign.go @@ -2,14 +2,15 @@ package signing import ( "context" - "os/exec" "runtime" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // MacOSSigner signs binaries using macOS codesign. +// Usage example: declare a value of type signing.MacOSSigner in integrating code. type MacOSSigner struct { config MacOSConfig } @@ -18,16 +19,19 @@ type MacOSSigner struct { var _ Signer = (*MacOSSigner)(nil) // NewMacOSSigner creates a new macOS signer. +// Usage example: call signing.NewMacOSSigner(...) from integrating code. func NewMacOSSigner(cfg MacOSConfig) *MacOSSigner { return &MacOSSigner{config: cfg} } // Name returns "codesign". +// Usage example: call value.Name(...) from integrating code. func (s *MacOSSigner) Name() string { return "codesign" } // Available checks if running on macOS with codesign and identity configured. +// Usage example: call value.Available(...) from integrating code. func (s *MacOSSigner) Available() bool { if runtime.GOOS != "darwin" { return false @@ -35,11 +39,12 @@ func (s *MacOSSigner) Available() bool { if s.config.Identity == "" { return false } - _, err := exec.LookPath("codesign") + _, err := ax.LookPath("codesign") return err == nil } // Sign codesigns a binary with hardened runtime. +// Usage example: call value.Sign(...) from integrating code. func (s *MacOSSigner) Sign(ctx context.Context, fs io.Medium, binary string) error { if !s.Available() { if runtime.GOOS != "darwin" { @@ -51,17 +56,15 @@ func (s *MacOSSigner) Sign(ctx context.Context, fs io.Medium, binary string) err return coreerr.E("codesign.Sign", "codesign tool not found in PATH", nil) } - cmd := exec.CommandContext(ctx, "codesign", + output, err := ax.CombinedOutput(ctx, "", nil, "codesign", "--sign", s.config.Identity, "--timestamp", "--options", "runtime", // Hardened runtime for notarization "--force", binary, ) - - output, err := cmd.CombinedOutput() if err != nil { - return coreerr.E("codesign.Sign", string(output), err) + return coreerr.E("codesign.Sign", output, err) } return nil @@ -69,6 +72,7 @@ func (s *MacOSSigner) Sign(ctx context.Context, fs io.Medium, binary string) err // Notarize submits binary to Apple for notarization and staples the ticket. // This blocks until Apple responds (typically 1-5 minutes). +// Usage example: call value.Notarize(...) from integrating code. func (s *MacOSSigner) Notarize(ctx context.Context, fs io.Medium, binary string) error { if s.config.AppleID == "" || s.config.TeamID == "" || s.config.AppPassword == "" { return coreerr.E("codesign.Notarize", "missing Apple credentials (apple_id, team_id, app_password)", nil) @@ -76,34 +80,32 @@ func (s *MacOSSigner) Notarize(ctx context.Context, fs io.Medium, binary string) // Create ZIP for submission zipPath := binary + ".zip" - zipCmd := exec.CommandContext(ctx, "zip", "-j", zipPath, binary) - if output, err := zipCmd.CombinedOutput(); err != nil { - return coreerr.E("codesign.Notarize", "failed to create zip: "+string(output), err) + if output, err := ax.CombinedOutput(ctx, "", nil, "zip", "-j", zipPath, binary); err != nil { + return coreerr.E("codesign.Notarize", "failed to create zip: "+output, err) } defer func() { _ = fs.Delete(zipPath) }() // Submit to Apple and wait - submitCmd := exec.CommandContext(ctx, "xcrun", "notarytool", "submit", + if output, err := ax.CombinedOutput(ctx, "", nil, "xcrun", "notarytool", "submit", zipPath, "--apple-id", s.config.AppleID, "--team-id", s.config.TeamID, "--password", s.config.AppPassword, "--wait", - ) - if output, err := submitCmd.CombinedOutput(); err != nil { - return coreerr.E("codesign.Notarize", "notarization failed: "+string(output), err) + ); err != nil { + return coreerr.E("codesign.Notarize", "notarization failed: "+output, err) } // Staple the ticket - stapleCmd := exec.CommandContext(ctx, "xcrun", "stapler", "staple", binary) - if output, err := stapleCmd.CombinedOutput(); err != nil { - return coreerr.E("codesign.Notarize", "failed to staple: "+string(output), err) + if output, err := ax.CombinedOutput(ctx, "", nil, "xcrun", "stapler", "staple", binary); err != nil { + return coreerr.E("codesign.Notarize", "failed to staple: "+output, err) } return nil } // ShouldNotarize returns true if notarization is enabled. +// Usage example: call value.ShouldNotarize(...) from integrating code. func (s *MacOSSigner) ShouldNotarize() bool { return s.config.Notarize } diff --git a/pkg/build/signing/codesign_test.go b/pkg/build/signing/codesign_test.go index dd6c43e..91857bf 100644 --- a/pkg/build/signing/codesign_test.go +++ b/pkg/build/signing/codesign_test.go @@ -9,12 +9,12 @@ import ( "github.com/stretchr/testify/assert" ) -func TestMacOSSigner_Good_Name(t *testing.T) { +func TestCodesign_MacOSSignerName_Good(t *testing.T) { s := NewMacOSSigner(MacOSConfig{Identity: "Developer ID Application: Test"}) assert.Equal(t, "codesign", s.Name()) } -func TestMacOSSigner_Good_Available(t *testing.T) { +func TestCodesign_MacOSSignerAvailable_Good(t *testing.T) { s := NewMacOSSigner(MacOSConfig{Identity: "Developer ID Application: Test"}) if runtime.GOOS == "darwin" { @@ -25,12 +25,12 @@ func TestMacOSSigner_Good_Available(t *testing.T) { } } -func TestMacOSSigner_Bad_NoIdentity(t *testing.T) { +func TestCodesign_MacOSSignerNoIdentity_Bad(t *testing.T) { s := NewMacOSSigner(MacOSConfig{}) assert.False(t, s.Available()) } -func TestMacOSSigner_Sign_Bad(t *testing.T) { +func TestCodesign_MacOSSignerSign_Bad(t *testing.T) { t.Run("fails when not available", func(t *testing.T) { if runtime.GOOS == "darwin" { t.Skip("skipping on macOS") @@ -43,7 +43,7 @@ func TestMacOSSigner_Sign_Bad(t *testing.T) { }) } -func TestMacOSSigner_Notarize_Bad(t *testing.T) { +func TestCodesign_MacOSSignerNotarize_Bad(t *testing.T) { fs := io.Local t.Run("fails with missing credentials", func(t *testing.T) { s := NewMacOSSigner(MacOSConfig{}) @@ -53,7 +53,7 @@ func TestMacOSSigner_Notarize_Bad(t *testing.T) { }) } -func TestMacOSSigner_ShouldNotarize(t *testing.T) { +func TestCodesign_MacOSSignerShouldNotarize_Good(t *testing.T) { s := NewMacOSSigner(MacOSConfig{Notarize: true}) assert.True(t, s.ShouldNotarize()) diff --git a/pkg/build/signing/gpg.go b/pkg/build/signing/gpg.go index 9106482..2c3a370 100644 --- a/pkg/build/signing/gpg.go +++ b/pkg/build/signing/gpg.go @@ -2,13 +2,14 @@ package signing import ( "context" - "os/exec" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // GPGSigner signs files using GPG. +// Usage example: declare a value of type signing.GPGSigner in integrating code. type GPGSigner struct { KeyID string } @@ -17,42 +18,44 @@ type GPGSigner struct { var _ Signer = (*GPGSigner)(nil) // NewGPGSigner creates a new GPG signer. +// Usage example: call signing.NewGPGSigner(...) from integrating code. func NewGPGSigner(keyID string) *GPGSigner { return &GPGSigner{KeyID: keyID} } // Name returns "gpg". +// Usage example: call value.Name(...) from integrating code. func (s *GPGSigner) Name() string { return "gpg" } // Available checks if gpg is installed and key is configured. +// Usage example: call value.Available(...) from integrating code. func (s *GPGSigner) Available() bool { if s.KeyID == "" { return false } - _, err := exec.LookPath("gpg") + _, err := ax.LookPath("gpg") return err == nil } // Sign creates a detached ASCII-armored signature. // For file.txt, creates file.txt.asc +// Usage example: call value.Sign(...) from integrating code. func (s *GPGSigner) Sign(ctx context.Context, fs io.Medium, file string) error { if !s.Available() { return coreerr.E("gpg.Sign", "gpg not available or key not configured", nil) } - cmd := exec.CommandContext(ctx, "gpg", + output, err := ax.CombinedOutput(ctx, "", nil, "gpg", "--detach-sign", "--armor", "--local-user", s.KeyID, "--output", file+".asc", file, ) - - output, err := cmd.CombinedOutput() if err != nil { - return coreerr.E("gpg.Sign", string(output), err) + return coreerr.E("gpg.Sign", output, err) } return nil diff --git a/pkg/build/signing/gpg_test.go b/pkg/build/signing/gpg_test.go index b67cda8..9ff57df 100644 --- a/pkg/build/signing/gpg_test.go +++ b/pkg/build/signing/gpg_test.go @@ -8,22 +8,22 @@ import ( "github.com/stretchr/testify/assert" ) -func TestGPGSigner_Good_Name(t *testing.T) { +func TestGPG_GPGSignerName_Good(t *testing.T) { s := NewGPGSigner("ABCD1234") assert.Equal(t, "gpg", s.Name()) } -func TestGPGSigner_Good_Available(t *testing.T) { +func TestGPG_GPGSignerAvailable_Good(t *testing.T) { s := NewGPGSigner("ABCD1234") _ = s.Available() } -func TestGPGSigner_Bad_NoKey(t *testing.T) { +func TestGPG_GPGSignerNoKey_Bad(t *testing.T) { s := NewGPGSigner("") assert.False(t, s.Available()) } -func TestGPGSigner_Sign_Bad(t *testing.T) { +func TestGPG_GPGSignerSign_Bad(t *testing.T) { fs := io.Local t.Run("fails when no key", func(t *testing.T) { s := NewGPGSigner("") diff --git a/pkg/build/signing/sign.go b/pkg/build/signing/sign.go index 5c39e49..155cee5 100644 --- a/pkg/build/signing/sign.go +++ b/pkg/build/signing/sign.go @@ -2,15 +2,16 @@ package signing import ( "context" - "fmt" "runtime" + "dappco.re/go/core" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // Artifact represents a build output that can be signed. // This mirrors build.Artifact to avoid import cycles. +// Usage example: declare a value of type signing.Artifact in integrating code. type Artifact struct { Path string OS string @@ -19,6 +20,7 @@ type Artifact struct { // SignBinaries signs macOS binaries in the artifacts list. // Only signs darwin binaries when running on macOS with a configured identity. +// Usage example: call signing.SignBinaries(...) from integrating code. func SignBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifacts []Artifact) error { if !cfg.Enabled { return nil @@ -39,7 +41,7 @@ func SignBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifacts [ continue } - fmt.Printf(" Signing %s...\n", artifact.Path) + core.Print(nil, " Signing %s...", artifact.Path) if err := signer.Sign(ctx, fs, artifact.Path); err != nil { return coreerr.E("signing.SignBinaries", "failed to sign "+artifact.Path, err) } @@ -49,6 +51,7 @@ func SignBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifacts [ } // NotarizeBinaries notarizes macOS binaries if enabled. +// Usage example: call signing.NotarizeBinaries(...) from integrating code. func NotarizeBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifacts []Artifact) error { if !cfg.Enabled || !cfg.MacOS.Notarize { return nil @@ -68,7 +71,7 @@ func NotarizeBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifac continue } - fmt.Printf(" Notarizing %s (this may take a few minutes)...\n", artifact.Path) + core.Print(nil, " Notarizing %s (this may take a few minutes)...", artifact.Path) if err := signer.Notarize(ctx, fs, artifact.Path); err != nil { return coreerr.E("signing.NotarizeBinaries", "failed to notarize "+artifact.Path, err) } @@ -78,6 +81,7 @@ func NotarizeBinaries(ctx context.Context, fs io.Medium, cfg SignConfig, artifac } // SignChecksums signs the checksums file with GPG. +// Usage example: call signing.SignChecksums(...) from integrating code. func SignChecksums(ctx context.Context, fs io.Medium, cfg SignConfig, checksumFile string) error { if !cfg.Enabled { return nil @@ -88,7 +92,7 @@ func SignChecksums(ctx context.Context, fs io.Medium, cfg SignConfig, checksumFi return nil // Silently skip if not configured } - fmt.Printf(" Signing %s with GPG...\n", checksumFile) + core.Print(nil, " Signing %s with GPG...", checksumFile) if err := signer.Sign(ctx, fs, checksumFile); err != nil { return coreerr.E("signing.SignChecksums", "failed to sign checksums file "+checksumFile, err) } diff --git a/pkg/build/signing/signer.go b/pkg/build/signing/signer.go index 906d90e..a88591d 100644 --- a/pkg/build/signing/signer.go +++ b/pkg/build/signing/signer.go @@ -3,13 +3,13 @@ package signing import ( "context" - "os" - "strings" + "dappco.re/go/core" "dappco.re/go/core/io" ) // Signer defines the interface for code signing implementations. +// Usage example: declare a value of type signing.Signer in integrating code. type Signer interface { // Name returns the signer's identifier. Name() string @@ -20,6 +20,7 @@ type Signer interface { } // SignConfig holds signing configuration from .core/build.yaml. +// Usage example: declare a value of type signing.SignConfig in integrating code. type SignConfig struct { Enabled bool `yaml:"enabled"` GPG GPGConfig `yaml:"gpg,omitempty"` @@ -28,11 +29,13 @@ type SignConfig struct { } // GPGConfig holds GPG signing configuration. +// Usage example: declare a value of type signing.GPGConfig in integrating code. type GPGConfig struct { Key string `yaml:"key"` // Key ID or fingerprint, supports $ENV } // MacOSConfig holds macOS codesign configuration. +// Usage example: declare a value of type signing.MacOSConfig in integrating code. type MacOSConfig struct { Identity string `yaml:"identity"` // Developer ID Application: ... Notarize bool `yaml:"notarize"` // Submit to Apple for notarization @@ -42,28 +45,31 @@ type MacOSConfig struct { } // WindowsConfig holds Windows signtool configuration (placeholder). +// Usage example: declare a value of type signing.WindowsConfig in integrating code. type WindowsConfig struct { Certificate string `yaml:"certificate"` // Path to .pfx Password string `yaml:"password"` // Certificate password } // DefaultSignConfig returns sensible defaults. +// Usage example: call signing.DefaultSignConfig(...) from integrating code. func DefaultSignConfig() SignConfig { return SignConfig{ Enabled: true, GPG: GPGConfig{ - Key: os.Getenv("GPG_KEY_ID"), + Key: core.Env("GPG_KEY_ID"), }, MacOS: MacOSConfig{ - Identity: os.Getenv("CODESIGN_IDENTITY"), - AppleID: os.Getenv("APPLE_ID"), - TeamID: os.Getenv("APPLE_TEAM_ID"), - AppPassword: os.Getenv("APPLE_APP_PASSWORD"), + Identity: core.Env("CODESIGN_IDENTITY"), + AppleID: core.Env("APPLE_ID"), + TeamID: core.Env("APPLE_TEAM_ID"), + AppPassword: core.Env("APPLE_APP_PASSWORD"), }, } } // ExpandEnv expands environment variables in config values. +// Usage example: call value.ExpandEnv(...) from integrating code. func (c *SignConfig) ExpandEnv() { c.GPG.Key = expandEnv(c.GPG.Key) c.MacOS.Identity = expandEnv(c.MacOS.Identity) @@ -76,8 +82,47 @@ func (c *SignConfig) ExpandEnv() { // expandEnv expands $VAR or ${VAR} in a string. func expandEnv(s string) string { - if strings.HasPrefix(s, "$") { - return os.ExpandEnv(s) + if !core.Contains(s, "$") { + return s } - return s + + buf := core.NewBuilder() + for i := 0; i < len(s); { + if s[i] != '$' { + buf.WriteByte(s[i]) + i++ + continue + } + + if i+1 < len(s) && s[i+1] == '{' { + j := i + 2 + for j < len(s) && s[j] != '}' { + j++ + } + if j < len(s) { + buf.WriteString(core.Env(s[i+2 : j])) + i = j + 1 + continue + } + } + + j := i + 1 + for j < len(s) { + c := s[j] + if c != '_' && (c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') { + break + } + j++ + } + if j > i+1 { + buf.WriteString(core.Env(s[i+1 : j])) + i = j + continue + } + + buf.WriteByte(s[i]) + i++ + } + + return buf.String() } diff --git a/pkg/build/signing/signing_test.go b/pkg/build/signing/signing_test.go index 93a938c..c420afd 100644 --- a/pkg/build/signing/signing_test.go +++ b/pkg/build/signing/signing_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestSignBinaries_Good_SkipsNonDarwin(t *testing.T) { +func TestSigning_SignBinariesSkipsNonDarwin_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -31,7 +31,7 @@ func TestSignBinaries_Good_SkipsNonDarwin(t *testing.T) { } } -func TestSignBinaries_Good_DisabledConfig(t *testing.T) { +func TestSigning_SignBinariesDisabledConfig_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -48,7 +48,7 @@ func TestSignBinaries_Good_DisabledConfig(t *testing.T) { } } -func TestSignBinaries_Good_SkipsOnNonMacOS(t *testing.T) { +func TestSigning_SignBinariesSkipsOnNonMacOS_Good(t *testing.T) { if runtime.GOOS == "darwin" { t.Skip("Skipping on macOS - this tests non-macOS behavior") } @@ -72,7 +72,7 @@ func TestSignBinaries_Good_SkipsOnNonMacOS(t *testing.T) { } } -func TestNotarizeBinaries_Good_DisabledConfig(t *testing.T) { +func TestSigning_NotarizeBinariesDisabledConfig_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -89,7 +89,7 @@ func TestNotarizeBinaries_Good_DisabledConfig(t *testing.T) { } } -func TestNotarizeBinaries_Good_NotarizeDisabled(t *testing.T) { +func TestSigning_NotarizeBinariesNotarizeDisabled_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -109,7 +109,7 @@ func TestNotarizeBinaries_Good_NotarizeDisabled(t *testing.T) { } } -func TestSignChecksums_Good_SkipsNoKey(t *testing.T) { +func TestSigning_SignChecksumsSkipsNoKey_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -126,7 +126,7 @@ func TestSignChecksums_Good_SkipsNoKey(t *testing.T) { } } -func TestSignChecksums_Good_Disabled(t *testing.T) { +func TestSigning_SignChecksumsDisabled_Good(t *testing.T) { ctx := context.Background() fs := io.Local cfg := SignConfig{ @@ -139,12 +139,12 @@ func TestSignChecksums_Good_Disabled(t *testing.T) { } } -func TestDefaultSignConfig(t *testing.T) { +func TestSigning_DefaultSignConfig_Good(t *testing.T) { cfg := DefaultSignConfig() assert.True(t, cfg.Enabled) } -func TestSignConfig_ExpandEnv(t *testing.T) { +func TestSigning_SignConfigExpandEnv_Good(t *testing.T) { t.Setenv("TEST_KEY", "ABC") cfg := SignConfig{ GPG: GPGConfig{Key: "$TEST_KEY"}, @@ -153,7 +153,7 @@ func TestSignConfig_ExpandEnv(t *testing.T) { assert.Equal(t, "ABC", cfg.GPG.Key) } -func TestWindowsSigner_Good(t *testing.T) { +func TestSigning_WindowsSigner_Good(t *testing.T) { fs := io.Local s := NewWindowsSigner(WindowsConfig{}) assert.Equal(t, "signtool", s.Name()) @@ -163,10 +163,10 @@ func TestWindowsSigner_Good(t *testing.T) { // mockSigner is a test double that records calls to Sign. type mockSigner struct { - name string - available bool + name string + available bool signedPaths []string - signError error + signError error } func (m *mockSigner) Name() string { @@ -185,7 +185,7 @@ func (m *mockSigner) Sign(ctx context.Context, fs io.Medium, path string) error // Verify mockSigner implements Signer var _ Signer = (*mockSigner)(nil) -func TestSignBinaries_Good_MockSigner(t *testing.T) { +func TestSigning_SignBinariesMockSigner_Good(t *testing.T) { t.Run("signs only darwin artifacts", func(t *testing.T) { artifacts := []Artifact{ {Path: "/dist/linux_amd64/myapp", OS: "linux", Arch: "amd64"}, @@ -230,7 +230,7 @@ func TestSignBinaries_Good_MockSigner(t *testing.T) { }) } -func TestSignChecksums_Good_MockSigner(t *testing.T) { +func TestSigning_SignChecksumsMockSigner_Good(t *testing.T) { t.Run("skips when GPG key is empty", func(t *testing.T) { cfg := SignConfig{ Enabled: true, @@ -252,7 +252,7 @@ func TestSignChecksums_Good_MockSigner(t *testing.T) { }) } -func TestNotarizeBinaries_Good_MockSigner(t *testing.T) { +func TestSigning_NotarizeBinariesMockSigner_Good(t *testing.T) { t.Run("skips when notarize is false", func(t *testing.T) { cfg := SignConfig{ Enabled: true, @@ -292,7 +292,7 @@ func TestNotarizeBinaries_Good_MockSigner(t *testing.T) { }) } -func TestExpandEnv_Good(t *testing.T) { +func TestSigning_ExpandEnv_Good(t *testing.T) { t.Run("expands all config fields", func(t *testing.T) { t.Setenv("TEST_GPG_KEY", "GPG123") t.Setenv("TEST_IDENTITY", "Developer ID Application: Test") diff --git a/pkg/build/signing/signtool.go b/pkg/build/signing/signtool.go index 1bff21b..1e96ece 100644 --- a/pkg/build/signing/signtool.go +++ b/pkg/build/signing/signtool.go @@ -7,6 +7,7 @@ import ( ) // WindowsSigner signs binaries using Windows signtool (placeholder). +// Usage example: declare a value of type signing.WindowsSigner in integrating code. type WindowsSigner struct { config WindowsConfig } @@ -15,21 +16,25 @@ type WindowsSigner struct { var _ Signer = (*WindowsSigner)(nil) // NewWindowsSigner creates a new Windows signer. +// Usage example: call signing.NewWindowsSigner(...) from integrating code. func NewWindowsSigner(cfg WindowsConfig) *WindowsSigner { return &WindowsSigner{config: cfg} } // Name returns "signtool". +// Usage example: call value.Name(...) from integrating code. func (s *WindowsSigner) Name() string { return "signtool" } // Available returns false (not yet implemented). +// Usage example: call value.Available(...) from integrating code. func (s *WindowsSigner) Available() bool { return false } // Sign is a placeholder that does nothing. +// Usage example: call value.Sign(...) from integrating code. func (s *WindowsSigner) Sign(ctx context.Context, fs io.Medium, binary string) error { // TODO: Implement Windows signing return nil diff --git a/pkg/release/changelog.go b/pkg/release/changelog.go index a7300b8..8059650 100644 --- a/pkg/release/changelog.go +++ b/pkg/release/changelog.go @@ -4,17 +4,19 @@ package release import ( "bufio" "bytes" - "os/exec" + "context" "regexp" "sort" "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreerr "dappco.re/go/core/log" "golang.org/x/text/cases" "golang.org/x/text/language" ) // ConventionalCommit represents a parsed conventional commit. +// Usage example: declare a value of type release.ConventionalCommit in integrating code. type ConventionalCommit struct { Type string // feat, fix, etc. Scope string // optional scope in parentheses @@ -60,6 +62,7 @@ var conventionalCommitRegex = regexp.MustCompile(`^(\w+)(?:\(([^)]+)\))?(!)?:\s* // Generate generates a markdown changelog from git commits between two refs. // If fromRef is empty, it uses the previous tag or initial commit. // If toRef is empty, it uses HEAD. +// Usage example: call release.Generate(...) from integrating code. func Generate(dir, fromRef, toRef string) (string, error) { if toRef == "" { toRef = "HEAD" @@ -96,6 +99,7 @@ func Generate(dir, fromRef, toRef string) (string, error) { } // GenerateWithConfig generates a changelog with filtering based on config. +// Usage example: call release.GenerateWithConfig(...) from integrating code. func GenerateWithConfig(dir, fromRef, toRef string, cfg *ChangelogConfig) (string, error) { if toRef == "" { toRef = "HEAD" @@ -151,13 +155,11 @@ func GenerateWithConfig(dir, fromRef, toRef string, cfg *ChangelogConfig) (strin // getPreviousTag returns the tag before the given ref. func getPreviousTag(dir, ref string) (string, error) { - cmd := exec.Command("git", "describe", "--tags", "--abbrev=0", ref+"^") - cmd.Dir = dir - output, err := cmd.Output() + output, err := ax.RunDir(context.Background(), dir, "git", "describe", "--tags", "--abbrev=0", ref+"^") if err != nil { return "", err } - return core.Trim(string(output)), nil + return core.Trim(output), nil } // getCommits returns a slice of commit strings between two refs. @@ -172,15 +174,13 @@ func getCommits(dir, fromRef, toRef string) ([]string, error) { args = []string{"log", "--oneline", "--no-merges", fromRef + ".." + toRef} } - cmd := exec.Command("git", args...) - cmd.Dir = dir - output, err := cmd.Output() + output, err := ax.RunDir(context.Background(), dir, "git", args...) if err != nil { return nil, err } var commits []string - scanner := bufio.NewScanner(bytes.NewReader(output)) + scanner := bufio.NewScanner(bytes.NewReader([]byte(output))) for scanner.Scan() { line := scanner.Text() if line != "" { @@ -305,6 +305,7 @@ func formatCommitLine(commit ConventionalCommit) string { // ParseCommitType extracts the type from a conventional commit subject. // Returns empty string if not a conventional commit. +// Usage example: call release.ParseCommitType(...) from integrating code. func ParseCommitType(subject string) string { matches := conventionalCommitRegex.FindStringSubmatch(subject) if matches == nil { diff --git a/pkg/release/changelog_test.go b/pkg/release/changelog_test.go index ac7d4de..60f7b88 100644 --- a/pkg/release/changelog_test.go +++ b/pkg/release/changelog_test.go @@ -1,16 +1,15 @@ package release import ( - "os" - "os/exec" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestParseConventionalCommit_Good(t *testing.T) { +func TestChangelog_ParseConventionalCommit_Good(t *testing.T) { tests := []struct { name string input string @@ -108,7 +107,7 @@ func TestParseConventionalCommit_Good(t *testing.T) { } } -func TestParseConventionalCommit_Bad(t *testing.T) { +func TestChangelog_ParseConventionalCommit_Bad(t *testing.T) { tests := []struct { name string input string @@ -143,7 +142,7 @@ func TestParseConventionalCommit_Bad(t *testing.T) { } } -func TestFormatChangelog_Good(t *testing.T) { +func TestChangelog_FormatChangelog_Good(t *testing.T) { t.Run("formats commits by type", func(t *testing.T) { commits := []ConventionalCommit{ {Type: "feat", Description: "add feature A", Hash: "abc1234"}, @@ -194,7 +193,7 @@ func TestFormatChangelog_Good(t *testing.T) { }) } -func TestParseCommitType_Good(t *testing.T) { +func TestChangelog_ParseCommitType_Good(t *testing.T) { tests := []struct { input string expected string @@ -213,7 +212,7 @@ func TestParseCommitType_Good(t *testing.T) { } } -func TestParseCommitType_Bad(t *testing.T) { +func TestChangelog_ParseCommitType_Bad(t *testing.T) { tests := []struct { input string }{ @@ -230,7 +229,7 @@ func TestParseCommitType_Bad(t *testing.T) { } } -func TestGenerateWithConfig_ConfigValues(t *testing.T) { +func TestChangelog_GenerateWithConfigConfigValues_Good(t *testing.T) { t.Run("config filters are parsed correctly", func(t *testing.T) { cfg := &ChangelogConfig{ Include: []string{"feat", "fix"}, @@ -261,18 +260,11 @@ func setupChangelogGitRepo(t *testing.T) string { dir := t.TempDir() // Initialize git repo - cmd := exec.Command("git", "init") - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "init") // Configure git user for commits - cmd = exec.Command("git", "config", "user.email", "test@example.com") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "config", "user.name", "Test User") - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "config", "user.email", "test@example.com") + runGit(t, dir, "config", "user.name", "Test User") return dir } @@ -282,30 +274,23 @@ func createChangelogCommit(t *testing.T, dir, message string) { t.Helper() // Create or modify a file - filePath := filepath.Join(dir, "changelog_test.txt") - content, _ := os.ReadFile(filePath) + filePath := ax.Join(dir, "changelog_test.txt") + content, _ := ax.ReadFile(filePath) content = append(content, []byte(message+"\n")...) - require.NoError(t, os.WriteFile(filePath, content, 0644)) + require.NoError(t, ax.WriteFile(filePath, content, 0644)) // Stage and commit - cmd := exec.Command("git", "add", ".") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "commit", "-m", message) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "add", ".") + runGit(t, dir, "commit", "-m", message) } // createChangelogTag creates a tag in the given directory. func createChangelogTag(t *testing.T, dir, tag string) { t.Helper() - cmd := exec.Command("git", "tag", tag) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "tag", tag) } -func TestGenerate_Good(t *testing.T) { +func TestChangelog_Generate_Good(t *testing.T) { t.Run("generates changelog from commits", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: add new feature") @@ -386,7 +371,7 @@ func TestGenerate_Good(t *testing.T) { }) } -func TestGenerate_Bad(t *testing.T) { +func TestChangelog_Generate_Bad(t *testing.T) { t.Run("returns error for non-git directory", func(t *testing.T) { dir := t.TempDir() @@ -395,7 +380,7 @@ func TestGenerate_Bad(t *testing.T) { }) } -func TestGenerateWithConfig_Good(t *testing.T) { +func TestChangelog_GenerateWithConfig_Good(t *testing.T) { t.Run("filters commits by include list", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: new feature") @@ -452,7 +437,7 @@ func TestGenerateWithConfig_Good(t *testing.T) { }) } -func TestGetCommits_Good(t *testing.T) { +func TestChangelog_GetCommits_Good(t *testing.T) { t.Run("returns all commits when fromRef is empty", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: first") @@ -503,7 +488,7 @@ func TestGetCommits_Good(t *testing.T) { }) } -func TestGetCommits_Bad(t *testing.T) { +func TestChangelog_GetCommits_Bad(t *testing.T) { t.Run("returns error for invalid ref", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: commit") @@ -520,7 +505,7 @@ func TestGetCommits_Bad(t *testing.T) { }) } -func TestGetPreviousTag_Good(t *testing.T) { +func TestChangelog_GetPreviousTag_Good(t *testing.T) { t.Run("returns previous tag", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: first") @@ -545,7 +530,7 @@ func TestGetPreviousTag_Good(t *testing.T) { }) } -func TestGetPreviousTag_Bad(t *testing.T) { +func TestChangelog_GetPreviousTag_Bad(t *testing.T) { t.Run("returns error when no previous tag exists", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: first") @@ -565,7 +550,7 @@ func TestGetPreviousTag_Bad(t *testing.T) { }) } -func TestFormatCommitLine_Good(t *testing.T) { +func TestChangelog_FormatCommitLine_Good(t *testing.T) { t.Run("formats commit without scope", func(t *testing.T) { commit := ConventionalCommit{ Type: "feat", @@ -590,7 +575,7 @@ func TestFormatCommitLine_Good(t *testing.T) { }) } -func TestFormatChangelog_Ugly(t *testing.T) { +func TestChangelog_FormatChangelog_Ugly(t *testing.T) { t.Run("handles custom commit type not in order", func(t *testing.T) { commits := []ConventionalCommit{ {Type: "custom", Description: "custom type", Hash: "abc1234"}, @@ -616,7 +601,7 @@ func TestFormatChangelog_Ugly(t *testing.T) { }) } -func TestGenerateWithConfig_Bad(t *testing.T) { +func TestChangelog_GenerateWithConfig_Bad(t *testing.T) { t.Run("returns error for non-git directory", func(t *testing.T) { dir := t.TempDir() cfg := &ChangelogConfig{ @@ -628,7 +613,7 @@ func TestGenerateWithConfig_Bad(t *testing.T) { }) } -func TestGenerateWithConfig_EdgeCases(t *testing.T) { +func TestChangelog_GenerateWithConfigEdgeCases_Ugly(t *testing.T) { t.Run("uses HEAD when toRef is empty", func(t *testing.T) { dir := setupChangelogGitRepo(t) createChangelogCommit(t, dir, "feat: new feature") diff --git a/pkg/release/config.go b/pkg/release/config.go index 8d48d5b..b5fabde 100644 --- a/pkg/release/config.go +++ b/pkg/release/config.go @@ -3,21 +3,23 @@ package release import ( "iter" - "os" - "path/filepath" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" "gopkg.in/yaml.v3" ) // ConfigFileName is the name of the release configuration file. +// Usage example: reference release.ConfigFileName from package consumers. const ConfigFileName = "release.yaml" // ConfigDir is the directory where release configuration is stored. +// Usage example: reference release.ConfigDir from package consumers. const ConfigDir = ".core" // Config holds the complete release configuration loaded from .core/release.yaml. +// Usage example: declare a value of type release.Config in integrating code. type Config struct { // Version is the config file format version. Version int `yaml:"version"` @@ -38,6 +40,7 @@ type Config struct { } // ProjectConfig holds project metadata for releases. +// Usage example: declare a value of type release.ProjectConfig in integrating code. type ProjectConfig struct { // Name is the project name. Name string `yaml:"name"` @@ -46,12 +49,14 @@ type ProjectConfig struct { } // BuildConfig holds build settings for releases. +// Usage example: declare a value of type release.BuildConfig in integrating code. type BuildConfig struct { // Targets defines the build targets. Targets []TargetConfig `yaml:"targets"` } // TargetConfig defines a build target. +// Usage example: declare a value of type release.TargetConfig in integrating code. type TargetConfig struct { // OS is the target operating system (e.g., "linux", "darwin", "windows"). OS string `yaml:"os"` @@ -60,6 +65,7 @@ type TargetConfig struct { } // PublisherConfig holds configuration for a publisher. +// Usage example: declare a value of type release.PublisherConfig in integrating code. type PublisherConfig struct { // Type is the publisher type (e.g., "github", "linuxkit", "docker"). Type string `yaml:"type"` @@ -118,6 +124,7 @@ type PublisherConfig struct { } // OfficialConfig holds configuration for generating files for official repo PRs. +// Usage example: declare a value of type release.OfficialConfig in integrating code. type OfficialConfig struct { // Enabled determines whether to generate files for official repos. Enabled bool `yaml:"enabled"` @@ -126,6 +133,7 @@ type OfficialConfig struct { } // SDKConfig holds SDK generation configuration. +// Usage example: declare a value of type release.SDKConfig in integrating code. type SDKConfig struct { // Spec is the path to the OpenAPI spec file. Spec string `yaml:"spec,omitempty"` @@ -142,24 +150,28 @@ type SDKConfig struct { } // SDKPackageConfig holds package naming configuration. +// Usage example: declare a value of type release.SDKPackageConfig in integrating code. type SDKPackageConfig struct { Name string `yaml:"name,omitempty"` Version string `yaml:"version,omitempty"` } // SDKDiffConfig holds diff configuration. +// Usage example: declare a value of type release.SDKDiffConfig in integrating code. type SDKDiffConfig struct { Enabled bool `yaml:"enabled,omitempty"` FailOnBreaking bool `yaml:"fail_on_breaking,omitempty"` } // SDKPublishConfig holds monorepo publish configuration. +// Usage example: declare a value of type release.SDKPublishConfig in integrating code. type SDKPublishConfig struct { Repo string `yaml:"repo,omitempty"` Path string `yaml:"path,omitempty"` } // ChangelogConfig holds changelog generation settings. +// Usage example: declare a value of type release.ChangelogConfig in integrating code. type ChangelogConfig struct { // Include specifies commit types to include in the changelog. Include []string `yaml:"include"` @@ -168,6 +180,7 @@ type ChangelogConfig struct { } // PublishersIter returns an iterator for the publishers. +// Usage example: call value.PublishersIter(...) from integrating code. func (c *Config) PublishersIter() iter.Seq[PublisherConfig] { return func(yield func(PublisherConfig) bool) { for _, p := range c.Publishers { @@ -181,18 +194,19 @@ func (c *Config) PublishersIter() iter.Seq[PublisherConfig] { // LoadConfig loads release configuration from the .core/release.yaml file in the given directory. // If the config file does not exist, it returns DefaultConfig(). // Returns an error if the file exists but cannot be parsed. +// Usage example: call release.LoadConfig(...) from integrating code. func LoadConfig(dir string) (*Config, error) { - configPath := filepath.Join(dir, ConfigDir, ConfigFileName) + configPath := ax.Join(dir, ConfigDir, ConfigFileName) // Convert to absolute path for io.Local - absPath, err := filepath.Abs(configPath) + absPath, err := ax.Abs(configPath) if err != nil { return nil, coreerr.E("release.LoadConfig", "failed to resolve path", err) } content, err := io.Local.Read(absPath) if err != nil { - if os.IsNotExist(err) { + if !io.Local.IsFile(absPath) { cfg := DefaultConfig() cfg.projectDir = dir return cfg, nil @@ -213,6 +227,7 @@ func LoadConfig(dir string) (*Config, error) { } // DefaultConfig returns sensible defaults for release configuration. +// Usage example: call release.DefaultConfig(...) from integrating code. func DefaultConfig() *Config { return &Config{ Version: 1, @@ -265,24 +280,28 @@ func applyDefaults(cfg *Config) { } // SetProjectDir sets the project directory on the config. +// Usage example: call value.SetProjectDir(...) from integrating code. func (c *Config) SetProjectDir(dir string) { c.projectDir = dir } // SetVersion sets the version override on the config. +// Usage example: call value.SetVersion(...) from integrating code. func (c *Config) SetVersion(version string) { c.version = version } // ConfigPath returns the path to the release config file for a given directory. +// Usage example: call release.ConfigPath(...) from integrating code. func ConfigPath(dir string) string { - return filepath.Join(dir, ConfigDir, ConfigFileName) + return ax.Join(dir, ConfigDir, ConfigFileName) } // ConfigExists checks if a release config file exists in the given directory. +// Usage example: call release.ConfigExists(...) from integrating code. func ConfigExists(dir string) bool { configPath := ConfigPath(dir) - absPath, err := filepath.Abs(configPath) + absPath, err := ax.Abs(configPath) if err != nil { return false } @@ -290,27 +309,30 @@ func ConfigExists(dir string) bool { } // GetRepository returns the repository from the config. +// Usage example: call value.GetRepository(...) from integrating code. func (c *Config) GetRepository() string { return c.Project.Repository } // GetProjectName returns the project name from the config. +// Usage example: call value.GetProjectName(...) from integrating code. func (c *Config) GetProjectName() string { return c.Project.Name } // WriteConfig writes the config to the .core/release.yaml file. +// Usage example: call release.WriteConfig(...) from integrating code. func WriteConfig(cfg *Config, dir string) error { configPath := ConfigPath(dir) // Convert to absolute path for io.Local - absPath, err := filepath.Abs(configPath) + absPath, err := ax.Abs(configPath) if err != nil { return coreerr.E("release.WriteConfig", "failed to resolve path", err) } // Ensure directory exists - configDir := filepath.Dir(absPath) + configDir := ax.Dir(absPath) if err := io.Local.EnsureDir(configDir); err != nil { return coreerr.E("release.WriteConfig", "failed to create directory", err) } diff --git a/pkg/release/config_test.go b/pkg/release/config_test.go index 44f65c0..e1a9bad 100644 --- a/pkg/release/config_test.go +++ b/pkg/release/config_test.go @@ -1,10 +1,9 @@ package release import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -15,19 +14,19 @@ func setupConfigTestDir(t *testing.T, configContent string) string { dir := t.TempDir() if configContent != "" { - coreDir := filepath.Join(dir, ConfigDir) - err := os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(dir, ConfigDir) + err := ax.MkdirAll(coreDir, 0755) require.NoError(t, err) - configPath := filepath.Join(coreDir, ConfigFileName) - err = os.WriteFile(configPath, []byte(configContent), 0644) + configPath := ax.Join(coreDir, ConfigFileName) + err = ax.WriteFile(configPath, []byte(configContent), 0644) require.NoError(t, err) } return dir } -func TestLoadConfig_Good(t *testing.T) { +func TestConfig_LoadConfig_Good(t *testing.T) { t.Run("loads valid config", func(t *testing.T) { content := ` version: 1 @@ -119,7 +118,7 @@ project: }) } -func TestLoadConfig_Bad(t *testing.T) { +func TestConfig_LoadConfig_Bad(t *testing.T) { t.Run("returns error for invalid YAML", func(t *testing.T) { content := ` version: 1 @@ -134,25 +133,26 @@ project: assert.Contains(t, err.Error(), "failed to parse config file") }) - t.Run("returns error for unreadable file", func(t *testing.T) { + t.Run("returns default config when config path is a directory", func(t *testing.T) { dir := t.TempDir() - coreDir := filepath.Join(dir, ConfigDir) - err := os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(dir, ConfigDir) + err := ax.MkdirAll(coreDir, 0755) require.NoError(t, err) // Create config as a directory instead of file - configPath := filepath.Join(coreDir, ConfigFileName) - err = os.Mkdir(configPath, 0755) + configPath := ax.Join(coreDir, ConfigFileName) + err = ax.Mkdir(configPath, 0755) require.NoError(t, err) cfg, err := LoadConfig(dir) - assert.Error(t, err) - assert.Nil(t, cfg) - assert.Contains(t, err.Error(), "failed to read config file") + assert.NoError(t, err) + require.NotNil(t, cfg) + assert.Equal(t, 1, cfg.Version) + assert.Equal(t, dir, cfg.projectDir) }) } -func TestDefaultConfig_Good(t *testing.T) { +func TestConfig_DefaultConfig_Good(t *testing.T) { t.Run("returns sensible defaults", func(t *testing.T) { cfg := DefaultConfig() @@ -194,14 +194,14 @@ func TestDefaultConfig_Good(t *testing.T) { }) } -func TestConfigPath_Good(t *testing.T) { +func TestConfig_ConfigPath_Good(t *testing.T) { t.Run("returns correct path", func(t *testing.T) { path := ConfigPath("/project/root") assert.Equal(t, "/project/root/.core/release.yaml", path) }) } -func TestConfigExists_Good(t *testing.T) { +func TestConfig_ConfigExists_Good(t *testing.T) { t.Run("returns true when config exists", func(t *testing.T) { dir := setupConfigTestDir(t, "version: 1") assert.True(t, ConfigExists(dir)) @@ -218,7 +218,7 @@ func TestConfigExists_Good(t *testing.T) { }) } -func TestWriteConfig_Good(t *testing.T) { +func TestConfig_WriteConfig_Good(t *testing.T) { t.Run("writes config to file", func(t *testing.T) { dir := t.TempDir() @@ -247,8 +247,8 @@ func TestWriteConfig_Good(t *testing.T) { require.NoError(t, err) // Check directory was created - coreDir := filepath.Join(dir, ConfigDir) - info, err := os.Stat(coreDir) + coreDir := ax.Join(dir, ConfigDir) + info, err := ax.Stat(coreDir) require.NoError(t, err) assert.True(t, info.IsDir()) }) @@ -302,22 +302,22 @@ func TestConfig_SetProjectDir_Good(t *testing.T) { }) } -func TestWriteConfig_Bad(t *testing.T) { +func TestConfig_WriteConfig_Bad(t *testing.T) { t.Run("returns error for unwritable directory", func(t *testing.T) { - if os.Geteuid() == 0 { + if ax.Geteuid() == 0 { t.Skip("root can write to any directory") } dir := t.TempDir() // Create .core directory and make it unwritable - coreDir := filepath.Join(dir, ConfigDir) - err := os.MkdirAll(coreDir, 0755) + coreDir := ax.Join(dir, ConfigDir) + err := ax.MkdirAll(coreDir, 0755) require.NoError(t, err) // Make directory read-only - err = os.Chmod(coreDir, 0555) + err = ax.Chmod(coreDir, 0555) require.NoError(t, err) - defer func() { _ = os.Chmod(coreDir, 0755) }() + defer func() { _ = ax.Chmod(coreDir, 0755) }() cfg := DefaultConfig() err = WriteConfig(cfg, dir) @@ -326,7 +326,7 @@ func TestWriteConfig_Bad(t *testing.T) { }) t.Run("returns error when directory creation fails", func(t *testing.T) { - if os.Geteuid() == 0 { + if ax.Geteuid() == 0 { t.Skip("root can create directories anywhere") } // Use a path that doesn't exist and can't be created @@ -336,7 +336,7 @@ func TestWriteConfig_Bad(t *testing.T) { }) } -func TestApplyDefaults_Good(t *testing.T) { +func TestConfig_ApplyDefaults_Good(t *testing.T) { t.Run("applies version default when zero", func(t *testing.T) { cfg := &Config{Version: 0} applyDefaults(cfg) diff --git a/pkg/release/publishers/aur.go b/pkg/release/publishers/aur.go index ee039f3..1e62758 100644 --- a/pkg/release/publishers/aur.go +++ b/pkg/release/publishers/aur.go @@ -5,13 +5,10 @@ import ( "bytes" "context" "embed" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" "text/template" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -21,6 +18,7 @@ import ( var aurTemplates embed.FS // AURConfig holds AUR-specific configuration. +// Usage example: declare a value of type publishers.AURConfig in integrating code. type AURConfig struct { // Package is the AUR package name. Package string @@ -31,19 +29,23 @@ type AURConfig struct { } // AURPublisher publishes releases to AUR. +// Usage example: declare a value of type publishers.AURPublisher in integrating code. type AURPublisher struct{} // NewAURPublisher creates a new AUR publisher. +// Usage example: call publishers.NewAURPublisher(...) from integrating code. func NewAURPublisher() *AURPublisher { return &AURPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *AURPublisher) Name() string { return "aur" } // Publish publishes the release to AUR. +// Usage example: call value.Publish(...) from integrating code. func (p *AURPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { cfg := p.parseConfig(pubCfg, relCfg) @@ -68,7 +70,7 @@ func (p *AURPublisher) Publish(ctx context.Context, release *Release, pubCfg Pub projectName = relCfg.GetProjectName() } if projectName == "" { - parts := strings.Split(repo, "/") + parts := core.Split(repo, "/") projectName = parts[len(parts)-1] } @@ -77,12 +79,12 @@ func (p *AURPublisher) Publish(ctx context.Context, release *Release, pubCfg Pub packageName = projectName } - version := strings.TrimPrefix(release.Version, "v") + version := core.TrimPrefix(release.Version, "v") checksums := buildChecksumMap(release.Artifacts) data := aurTemplateData{ PackageName: packageName, - Description: fmt.Sprintf("%s CLI", projectName), + Description: core.Sprintf("%s CLI", projectName), Repository: repo, Version: version, License: "MIT", @@ -134,38 +136,38 @@ func (p *AURPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseConfig) } func (p *AURPublisher) dryRunPublish(m coreio.Medium, data aurTemplateData, cfg AURConfig) error { - fmt.Println() - fmt.Println("=== DRY RUN: AUR Publish ===") - fmt.Println() - fmt.Printf("Package: %s-bin\n", data.PackageName) - fmt.Printf("Version: %s\n", data.Version) - fmt.Printf("Maintainer: %s\n", data.Maintainer) - fmt.Printf("Repository: %s\n", data.Repository) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: AUR Publish ===") + publisherPrintln() + publisherPrint("Package: %s-bin", data.PackageName) + publisherPrint("Version: %s", data.Version) + publisherPrint("Maintainer: %s", data.Maintainer) + publisherPrint("Repository: %s", data.Repository) + publisherPrintln() pkgbuild, err := p.renderTemplate(m, "templates/aur/PKGBUILD.tmpl", data) if err != nil { return coreerr.E("aur.dryRunPublish", "failed to render PKGBUILD template", err) } - fmt.Println("Generated PKGBUILD:") - fmt.Println("---") - fmt.Println(pkgbuild) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated PKGBUILD:") + publisherPrintln("---") + publisherPrintln(pkgbuild) + publisherPrintln("---") + publisherPrintln() srcinfo, err := p.renderTemplate(m, "templates/aur/.SRCINFO.tmpl", data) if err != nil { return coreerr.E("aur.dryRunPublish", "failed to render .SRCINFO template", err) } - fmt.Println("Generated .SRCINFO:") - fmt.Println("---") - fmt.Println(srcinfo) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated .SRCINFO:") + publisherPrintln("---") + publisherPrintln(srcinfo) + publisherPrintln("---") + publisherPrintln() - fmt.Printf("Would push to AUR: ssh://aur@aur.archlinux.org/%s-bin.git\n", data.PackageName) - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrint("Would push to AUR: ssh://aur@aur.archlinux.org/%s-bin.git", data.PackageName) + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -185,25 +187,25 @@ func (p *AURPublisher) executePublish(ctx context.Context, projectDir string, da if cfg.Official != nil && cfg.Official.Enabled { output := cfg.Official.Output if output == "" { - output = filepath.Join(projectDir, "dist", "aur") - } else if !filepath.IsAbs(output) { - output = filepath.Join(projectDir, output) + output = ax.Join(projectDir, "dist", "aur") + } else if !ax.IsAbs(output) { + output = ax.Join(projectDir, output) } if err := release.FS.EnsureDir(output); err != nil { return coreerr.E("aur.Publish", "failed to create output directory", err) } - pkgbuildPath := filepath.Join(output, "PKGBUILD") + pkgbuildPath := ax.Join(output, "PKGBUILD") if err := release.FS.Write(pkgbuildPath, pkgbuild); err != nil { return coreerr.E("aur.Publish", "failed to write PKGBUILD", err) } - srcinfoPath := filepath.Join(output, ".SRCINFO") + srcinfoPath := ax.Join(output, ".SRCINFO") if err := release.FS.Write(srcinfoPath, srcinfo); err != nil { return coreerr.E("aur.Publish", "failed to write .SRCINFO", err) } - fmt.Printf("Wrote AUR files: %s\n", output) + publisherPrint("Wrote AUR files: %s", output) } // Push to AUR if not in official-only mode @@ -217,62 +219,49 @@ func (p *AURPublisher) executePublish(ctx context.Context, projectDir string, da } func (p *AURPublisher) pushToAUR(ctx context.Context, data aurTemplateData, pkgbuild, srcinfo string) error { - aurURL := fmt.Sprintf("ssh://aur@aur.archlinux.org/%s-bin.git", data.PackageName) + aurURL := core.Sprintf("ssh://aur@aur.archlinux.org/%s-bin.git", data.PackageName) - tmpDir, err := os.MkdirTemp("", "aur-package-*") + tmpDir, err := ax.TempDir("aur-package-*") if err != nil { return coreerr.E("aur.pushToAUR", "failed to create temp directory", err) } - defer func() { _ = coreio.Local.DeleteAll(tmpDir) }() + defer func() { _ = ax.RemoveAll(tmpDir) }() // Clone existing AUR repo (or initialise new one) - fmt.Printf("Cloning AUR package %s-bin...\n", data.PackageName) - cmd := exec.CommandContext(ctx, "git", "clone", aurURL, tmpDir) - if err := cmd.Run(); err != nil { + publisherPrint("Cloning AUR package %s-bin...", data.PackageName) + if err := ax.Exec(ctx, "git", "clone", aurURL, tmpDir); err != nil { // If clone fails, init a new repo - cmd = exec.CommandContext(ctx, "git", "init", tmpDir) - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "git", "init", tmpDir); err != nil { return coreerr.E("aur.pushToAUR", "failed to initialise repo", err) } - cmd = exec.CommandContext(ctx, "git", "-C", tmpDir, "remote", "add", "origin", aurURL) - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "git", "-C", tmpDir, "remote", "add", "origin", aurURL); err != nil { return coreerr.E("aur.pushToAUR", "failed to add remote", err) } } // Write files - if err := coreio.Local.Write(filepath.Join(tmpDir, "PKGBUILD"), pkgbuild); err != nil { + if err := coreio.Local.Write(ax.Join(tmpDir, "PKGBUILD"), pkgbuild); err != nil { return coreerr.E("aur.pushToAUR", "failed to write PKGBUILD", err) } - if err := coreio.Local.Write(filepath.Join(tmpDir, ".SRCINFO"), srcinfo); err != nil { + if err := coreio.Local.Write(ax.Join(tmpDir, ".SRCINFO"), srcinfo); err != nil { return coreerr.E("aur.pushToAUR", "failed to write .SRCINFO", err) } - commitMsg := fmt.Sprintf("Update to %s", data.Version) + commitMsg := core.Sprintf("Update to %s", data.Version) - cmd = exec.CommandContext(ctx, "git", "add", ".") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(ctx, tmpDir, "git", "add", "."); err != nil { return coreerr.E("aur.pushToAUR", "git add failed", err) } - cmd = exec.CommandContext(ctx, "git", "commit", "-m", commitMsg) - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "commit", "-m", commitMsg); err != nil { return coreerr.E("aur.pushToAUR", "git commit failed", err) } - cmd = exec.CommandContext(ctx, "git", "push", "origin", "master") - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "push", "origin", "master"); err != nil { return coreerr.E("aur.pushToAUR", "git push failed", err) } - fmt.Printf("Published to AUR: https://aur.archlinux.org/packages/%s-bin\n", data.PackageName) + publisherPrint("Published to AUR: https://aur.archlinux.org/packages/%s-bin", data.PackageName) return nil } @@ -281,7 +270,7 @@ func (p *AURPublisher) renderTemplate(m coreio.Medium, name string, data aurTemp var err error // Try custom template from medium - customPath := filepath.Join(".core", name) + customPath := ax.Join(".core", name) if m != nil && m.IsFile(customPath) { customContent, err := m.Read(customPath) if err == nil { @@ -297,7 +286,7 @@ func (p *AURPublisher) renderTemplate(m coreio.Medium, name string, data aurTemp } } - tmpl, err := template.New(filepath.Base(name)).Parse(string(content)) + tmpl, err := template.New(ax.Base(name)).Parse(string(content)) if err != nil { return "", coreerr.E("aur.renderTemplate", "failed to parse template "+name, err) } diff --git a/pkg/release/publishers/aur_test.go b/pkg/release/publishers/aur_test.go index 0402963..06b365b 100644 --- a/pkg/release/publishers/aur_test.go +++ b/pkg/release/publishers/aur_test.go @@ -1,9 +1,7 @@ package publishers import ( - "bytes" "context" - "os" "testing" "dappco.re/go/core/io" @@ -11,14 +9,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestAURPublisher_Name_Good(t *testing.T) { +func TestAUR_AURPublisherName_Good(t *testing.T) { t.Run("returns aur", func(t *testing.T) { p := NewAURPublisher() assert.Equal(t, "aur", p.Name()) }) } -func TestAURPublisher_ParseConfig_Good(t *testing.T) { +func TestAUR_AURPublisherParseConfig_Good(t *testing.T) { p := NewAURPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -80,7 +78,7 @@ func TestAURPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestAURPublisher_RenderTemplate_Good(t *testing.T) { +func TestAUR_AURPublisherRenderTemplate_Good(t *testing.T) { p := NewAURPublisher() t.Run("renders PKGBUILD template with data", func(t *testing.T) { @@ -140,7 +138,7 @@ func TestAURPublisher_RenderTemplate_Good(t *testing.T) { }) } -func TestAURPublisher_RenderTemplate_Bad(t *testing.T) { +func TestAUR_AURPublisherRenderTemplate_Bad(t *testing.T) { p := NewAURPublisher() t.Run("returns error for non-existent template", func(t *testing.T) { @@ -151,14 +149,10 @@ func TestAURPublisher_RenderTemplate_Bad(t *testing.T) { }) } -func TestAURPublisher_DryRunPublish_Good(t *testing.T) { +func TestAUR_AURPublisherDryRunPublish_Good(t *testing.T) { p := NewAURPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := aurTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -171,15 +165,11 @@ func TestAURPublisher_DryRunPublish_Good(t *testing.T) { Maintainer: "John Doe ", } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: AUR Publish") assert.Contains(t, output, "Package: myapp-bin") @@ -193,7 +183,7 @@ func TestAURPublisher_DryRunPublish_Good(t *testing.T) { }) } -func TestAURPublisher_Publish_Bad(t *testing.T) { +func TestAUR_AURPublisherPublish_Bad(t *testing.T) { p := NewAURPublisher() t.Run("fails when maintainer not configured", func(t *testing.T) { @@ -211,7 +201,7 @@ func TestAURPublisher_Publish_Bad(t *testing.T) { }) } -func TestAURConfig_Defaults_Good(t *testing.T) { +func TestAUR_AURConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewAURPublisher() pubCfg := PublisherConfig{Type: "aur"} diff --git a/pkg/release/publishers/chocolatey.go b/pkg/release/publishers/chocolatey.go index 6fd9f4f..46d19fd 100644 --- a/pkg/release/publishers/chocolatey.go +++ b/pkg/release/publishers/chocolatey.go @@ -5,13 +5,10 @@ import ( "bytes" "context" "embed" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" "text/template" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/i18n" "dappco.re/go/core/io" @@ -22,6 +19,7 @@ import ( var chocolateyTemplates embed.FS // ChocolateyConfig holds Chocolatey-specific configuration. +// Usage example: declare a value of type publishers.ChocolateyConfig in integrating code. type ChocolateyConfig struct { // Package is the Chocolatey package name. Package string @@ -32,19 +30,23 @@ type ChocolateyConfig struct { } // ChocolateyPublisher publishes releases to Chocolatey. +// Usage example: declare a value of type publishers.ChocolateyPublisher in integrating code. type ChocolateyPublisher struct{} // NewChocolateyPublisher creates a new Chocolatey publisher. +// Usage example: call publishers.NewChocolateyPublisher(...) from integrating code. func NewChocolateyPublisher() *ChocolateyPublisher { return &ChocolateyPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *ChocolateyPublisher) Name() string { return "chocolatey" } // Publish publishes the release to Chocolatey. +// Usage example: call value.Publish(...) from integrating code. func (p *ChocolateyPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { cfg := p.parseConfig(pubCfg, relCfg) @@ -65,7 +67,7 @@ func (p *ChocolateyPublisher) Publish(ctx context.Context, release *Release, pub projectName = relCfg.GetProjectName() } if projectName == "" { - parts := strings.Split(repo, "/") + parts := core.Split(repo, "/") projectName = parts[len(parts)-1] } @@ -74,22 +76,22 @@ func (p *ChocolateyPublisher) Publish(ctx context.Context, release *Release, pub packageName = projectName } - version := strings.TrimPrefix(release.Version, "v") + version := core.TrimPrefix(release.Version, "v") checksums := buildChecksumMap(release.Artifacts) // Extract authors from repository - authors := strings.Split(repo, "/")[0] + authors := core.Split(repo, "/")[0] data := chocolateyTemplateData{ PackageName: packageName, - Title: fmt.Sprintf("%s CLI", i18n.Title(projectName)), - Description: fmt.Sprintf("%s CLI", projectName), + Title: core.Sprintf("%s CLI", i18n.Title(projectName)), + Description: core.Sprintf("%s CLI", projectName), Repository: repo, Version: version, License: "MIT", BinaryName: projectName, Authors: authors, - Tags: fmt.Sprintf("cli %s", projectName), + Tags: core.Sprintf("cli %s", projectName), Checksums: checksums, } @@ -140,42 +142,42 @@ func (p *ChocolateyPublisher) parseConfig(pubCfg PublisherConfig, relCfg Release } func (p *ChocolateyPublisher) dryRunPublish(m io.Medium, data chocolateyTemplateData, cfg ChocolateyConfig) error { - fmt.Println() - fmt.Println("=== DRY RUN: Chocolatey Publish ===") - fmt.Println() - fmt.Printf("Package: %s\n", data.PackageName) - fmt.Printf("Version: %s\n", data.Version) - fmt.Printf("Push: %t\n", cfg.Push) - fmt.Printf("Repository: %s\n", data.Repository) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: Chocolatey Publish ===") + publisherPrintln() + publisherPrint("Package: %s", data.PackageName) + publisherPrint("Version: %s", data.Version) + publisherPrint("Push: %t", cfg.Push) + publisherPrint("Repository: %s", data.Repository) + publisherPrintln() nuspec, err := p.renderTemplate(m, "templates/chocolatey/package.nuspec.tmpl", data) if err != nil { return coreerr.E("chocolatey.dryRunPublish", "failed to render nuspec", err) } - fmt.Println("Generated package.nuspec:") - fmt.Println("---") - fmt.Println(nuspec) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated package.nuspec:") + publisherPrintln("---") + publisherPrintln(nuspec) + publisherPrintln("---") + publisherPrintln() install, err := p.renderTemplate(m, "templates/chocolatey/tools/chocolateyinstall.ps1.tmpl", data) if err != nil { return coreerr.E("chocolatey.dryRunPublish", "failed to render install script", err) } - fmt.Println("Generated chocolateyinstall.ps1:") - fmt.Println("---") - fmt.Println(install) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated chocolateyinstall.ps1:") + publisherPrintln("---") + publisherPrintln(install) + publisherPrintln("---") + publisherPrintln() if cfg.Push { - fmt.Println("Would push to Chocolatey community repo") + publisherPrintln("Would push to Chocolatey community repo") } else { - fmt.Println("Would generate package files only (push=false)") + publisherPrintln("Would generate package files only (push=false)") } - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -192,31 +194,31 @@ func (p *ChocolateyPublisher) executePublish(ctx context.Context, projectDir str } // Create package directory - output := filepath.Join(projectDir, "dist", "chocolatey") + output := ax.Join(projectDir, "dist", "chocolatey") if cfg.Official != nil && cfg.Official.Enabled && cfg.Official.Output != "" { output = cfg.Official.Output - if !filepath.IsAbs(output) { - output = filepath.Join(projectDir, output) + if !ax.IsAbs(output) { + output = ax.Join(projectDir, output) } } - toolsDir := filepath.Join(output, "tools") + toolsDir := ax.Join(output, "tools") if err := release.FS.EnsureDir(toolsDir); err != nil { return coreerr.E("chocolatey.Publish", "failed to create output directory", err) } // Write files - nuspecPath := filepath.Join(output, fmt.Sprintf("%s.nuspec", data.PackageName)) + nuspecPath := ax.Join(output, core.Sprintf("%s.nuspec", data.PackageName)) if err := release.FS.Write(nuspecPath, nuspec); err != nil { return coreerr.E("chocolatey.Publish", "failed to write nuspec", err) } - installPath := filepath.Join(toolsDir, "chocolateyinstall.ps1") + installPath := ax.Join(toolsDir, "chocolateyinstall.ps1") if err := release.FS.Write(installPath, install); err != nil { return coreerr.E("chocolatey.Publish", "failed to write install script", err) } - fmt.Printf("Wrote Chocolatey package files: %s\n", output) + publisherPrint("Wrote Chocolatey package files: %s", output) // Push to Chocolatey if configured if cfg.Push { @@ -230,31 +232,24 @@ func (p *ChocolateyPublisher) executePublish(ctx context.Context, projectDir str func (p *ChocolateyPublisher) pushToChocolatey(ctx context.Context, packageDir string, data chocolateyTemplateData) error { // Check for CHOCOLATEY_API_KEY - apiKey := os.Getenv("CHOCOLATEY_API_KEY") + apiKey := core.Env("CHOCOLATEY_API_KEY") if apiKey == "" { return coreerr.E("chocolatey.Publish", "CHOCOLATEY_API_KEY environment variable is required for push", nil) } // Pack the package - nupkgPath := filepath.Join(packageDir, fmt.Sprintf("%s.%s.nupkg", data.PackageName, data.Version)) + nupkgPath := ax.Join(packageDir, core.Sprintf("%s.%s.nupkg", data.PackageName, data.Version)) - cmd := exec.CommandContext(ctx, "choco", "pack", filepath.Join(packageDir, fmt.Sprintf("%s.nuspec", data.PackageName)), "-OutputDirectory", packageDir) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, "", nil, "choco", "pack", ax.Join(packageDir, core.Sprintf("%s.nuspec", data.PackageName)), "-OutputDirectory", packageDir); err != nil { return coreerr.E("chocolatey.Publish", "choco pack failed", err) } // Push the package — pass API key via environment variable to avoid exposing it in process listings - cmd = exec.CommandContext(ctx, "choco", "push", nupkgPath, "--source", "https://push.chocolatey.org/") - cmd.Env = append(os.Environ(), "chocolateyApiKey="+apiKey) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, "", []string{"chocolateyApiKey=" + apiKey}, "choco", "push", nupkgPath, "--source", "https://push.chocolatey.org/"); err != nil { return coreerr.E("chocolatey.Publish", "choco push failed", err) } - fmt.Printf("Published to Chocolatey: https://community.chocolatey.org/packages/%s\n", data.PackageName) + publisherPrint("Published to Chocolatey: https://community.chocolatey.org/packages/%s", data.PackageName) return nil } @@ -263,7 +258,7 @@ func (p *ChocolateyPublisher) renderTemplate(m io.Medium, name string, data choc var err error // Try custom template from medium - customPath := filepath.Join(".core", name) + customPath := ax.Join(".core", name) if m != nil && m.IsFile(customPath) { customContent, err := m.Read(customPath) if err == nil { @@ -279,7 +274,7 @@ func (p *ChocolateyPublisher) renderTemplate(m io.Medium, name string, data choc } } - tmpl, err := template.New(filepath.Base(name)).Parse(string(content)) + tmpl, err := template.New(ax.Base(name)).Parse(string(content)) if err != nil { return "", coreerr.E("chocolatey.renderTemplate", "failed to parse template "+name, err) } diff --git a/pkg/release/publishers/chocolatey_test.go b/pkg/release/publishers/chocolatey_test.go index 0932dd5..9bf2a88 100644 --- a/pkg/release/publishers/chocolatey_test.go +++ b/pkg/release/publishers/chocolatey_test.go @@ -1,25 +1,24 @@ package publishers import ( - "bytes" "context" - "os" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestChocolateyPublisher_Name_Good(t *testing.T) { +func TestChocolatey_ChocolateyPublisherName_Good(t *testing.T) { t.Run("returns chocolatey", func(t *testing.T) { p := NewChocolateyPublisher() assert.Equal(t, "chocolatey", p.Name()) }) } -func TestChocolateyPublisher_ParseConfig_Good(t *testing.T) { +func TestChocolatey_ChocolateyPublisherParseConfig_Good(t *testing.T) { p := NewChocolateyPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -107,7 +106,7 @@ func TestChocolateyPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestChocolateyPublisher_RenderTemplate_Good(t *testing.T) { +func TestChocolatey_ChocolateyPublisherRenderTemplate_Good(t *testing.T) { p := NewChocolateyPublisher() t.Run("renders nuspec template with data", func(t *testing.T) { @@ -160,7 +159,7 @@ func TestChocolateyPublisher_RenderTemplate_Good(t *testing.T) { }) } -func TestChocolateyPublisher_RenderTemplate_Bad(t *testing.T) { +func TestChocolatey_ChocolateyPublisherRenderTemplate_Bad(t *testing.T) { p := NewChocolateyPublisher() t.Run("returns error for non-existent template", func(t *testing.T) { @@ -171,14 +170,10 @@ func TestChocolateyPublisher_RenderTemplate_Bad(t *testing.T) { }) } -func TestChocolateyPublisher_DryRunPublish_Good(t *testing.T) { +func TestChocolatey_ChocolateyPublisherDryRunPublish_Good(t *testing.T) { p := NewChocolateyPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := chocolateyTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -192,15 +187,11 @@ func TestChocolateyPublisher_DryRunPublish_Good(t *testing.T) { Push: false, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Chocolatey Publish") assert.Contains(t, output, "Package: myapp") @@ -214,10 +205,6 @@ func TestChocolateyPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows push message when push is enabled", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := chocolateyTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -230,37 +217,25 @@ func TestChocolateyPublisher_DryRunPublish_Good(t *testing.T) { Push: true, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Push: true") assert.Contains(t, output, "Would push to Chocolatey community repo") }) } -func TestChocolateyPublisher_ExecutePublish_Bad(t *testing.T) { +func TestChocolatey_ChocolateyPublisherExecutePublish_Bad(t *testing.T) { p := NewChocolateyPublisher() t.Run("fails when CHOCOLATEY_API_KEY not set for push", func(t *testing.T) { - // Ensure CHOCOLATEY_API_KEY is not set - oldKey := os.Getenv("CHOCOLATEY_API_KEY") - _ = os.Unsetenv("CHOCOLATEY_API_KEY") - defer func() { - if oldKey != "" { - _ = os.Setenv("CHOCOLATEY_API_KEY", oldKey) - } - }() + t.Setenv("CHOCOLATEY_API_KEY", "") // Create a temp directory for the test - tmpDir, err := os.MkdirTemp("", "choco-test-*") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() + require.True(t, ax.IsDir(tmpDir)) data := chocolateyTemplateData{ PackageName: "testpkg", @@ -272,13 +247,13 @@ func TestChocolateyPublisher_ExecutePublish_Bad(t *testing.T) { Checksums: ChecksumMap{}, } - err = p.pushToChocolatey(context.TODO(), tmpDir, data) + err := p.pushToChocolatey(context.TODO(), tmpDir, data) assert.Error(t, err) assert.Contains(t, err.Error(), "CHOCOLATEY_API_KEY environment variable is required") }) } -func TestChocolateyConfig_Defaults_Good(t *testing.T) { +func TestChocolatey_ChocolateyConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewChocolateyPublisher() pubCfg := PublisherConfig{Type: "chocolatey"} @@ -292,7 +267,7 @@ func TestChocolateyConfig_Defaults_Good(t *testing.T) { }) } -func TestChocolateyTemplateData_Good(t *testing.T) { +func TestChocolatey_ChocolateyTemplateData_Good(t *testing.T) { t.Run("struct has all expected fields", func(t *testing.T) { data := chocolateyTemplateData{ PackageName: "myapp", diff --git a/pkg/release/publishers/docker.go b/pkg/release/publishers/docker.go index 926ee9a..96559b2 100644 --- a/pkg/release/publishers/docker.go +++ b/pkg/release/publishers/docker.go @@ -3,16 +3,14 @@ package publishers import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreerr "dappco.re/go/core/log" ) // DockerConfig holds configuration for the Docker publisher. +// Usage example: declare a value of type publishers.DockerConfig in integrating code. type DockerConfig struct { // Registry is the container registry (default: ghcr.io). Registry string `yaml:"registry"` @@ -29,19 +27,23 @@ type DockerConfig struct { } // DockerPublisher builds and publishes Docker images. +// Usage example: declare a value of type publishers.DockerPublisher in integrating code. type DockerPublisher struct{} // NewDockerPublisher creates a new Docker publisher. +// Usage example: call publishers.NewDockerPublisher(...) from integrating code. func NewDockerPublisher() *DockerPublisher { return &DockerPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *DockerPublisher) Name() string { return "docker" } // Publish builds and pushes Docker images. +// Usage example: call value.Publish(...) from integrating code. func (p *DockerPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { // Validate docker CLI is available if err := validateDockerCli(); err != nil { @@ -68,7 +70,7 @@ func (p *DockerPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseConf cfg := DockerConfig{ Registry: "ghcr.io", Image: "", - Dockerfile: filepath.Join(projectDir, "Dockerfile"), + Dockerfile: ax.Join(projectDir, "Dockerfile"), Platforms: []string{"linux/amd64", "linux/arm64"}, Tags: []string{"latest", "{{.Version}}"}, BuildArgs: make(map[string]string), @@ -88,10 +90,10 @@ func (p *DockerPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseConf cfg.Image = image } if dockerfile, ok := ext["dockerfile"].(string); ok && dockerfile != "" { - if filepath.IsAbs(dockerfile) { + if ax.IsAbs(dockerfile) { cfg.Dockerfile = dockerfile } else { - cfg.Dockerfile = filepath.Join(projectDir, dockerfile) + cfg.Dockerfile = ax.Join(projectDir, dockerfile) } } if platforms, ok := ext["platforms"].([]any); ok && len(platforms) > 0 { @@ -124,39 +126,39 @@ func (p *DockerPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseConf // dryRunPublish shows what would be done without actually building. func (p *DockerPublisher) dryRunPublish(release *Release, cfg DockerConfig) error { - fmt.Println() - fmt.Println("=== DRY RUN: Docker Build & Push ===") - fmt.Println() - fmt.Printf("Version: %s\n", release.Version) - fmt.Printf("Registry: %s\n", cfg.Registry) - fmt.Printf("Image: %s\n", cfg.Image) - fmt.Printf("Dockerfile: %s\n", cfg.Dockerfile) - fmt.Printf("Platforms: %s\n", strings.Join(cfg.Platforms, ", ")) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: Docker Build & Push ===") + publisherPrintln() + publisherPrint("Version: %s", release.Version) + publisherPrint("Registry: %s", cfg.Registry) + publisherPrint("Image: %s", cfg.Image) + publisherPrint("Dockerfile: %s", cfg.Dockerfile) + publisherPrint("Platforms: %s", core.Join(", ", cfg.Platforms...)) + publisherPrintln() // Resolve tags tags := p.resolveTags(cfg.Tags, release.Version) - fmt.Println("Tags to be applied:") + publisherPrintln("Tags to be applied:") for _, tag := range tags { fullTag := p.buildFullTag(cfg.Registry, cfg.Image, tag) - fmt.Printf(" - %s\n", fullTag) + publisherPrint(" - %s", fullTag) } - fmt.Println() + publisherPrintln() - fmt.Println("Would execute command:") + publisherPrintln("Would execute command:") args := p.buildBuildxArgs(cfg, tags, release.Version) - fmt.Printf(" docker %s\n", strings.Join(args, " ")) + publisherPrint(" docker %s", core.Join(" ", args...)) if len(cfg.BuildArgs) > 0 { - fmt.Println() - fmt.Println("Build arguments:") + publisherPrintln() + publisherPrintln("Build arguments:") for k, v := range cfg.BuildArgs { - fmt.Printf(" %s=%s\n", k, v) + publisherPrint(" %s=%s", k, v) } } - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -174,13 +176,8 @@ func (p *DockerPublisher) executePublish(ctx context.Context, release *Release, // Build the docker buildx command args := p.buildBuildxArgs(cfg, tags, release.Version) - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Dir = release.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - fmt.Printf("Building and pushing Docker image: %s\n", cfg.Image) - if err := cmd.Run(); err != nil { + publisherPrint("Building and pushing Docker image: %s", cfg.Image) + if err := publisherRun(ctx, release.ProjectDir, nil, "docker", args...); err != nil { return coreerr.E("docker.Publish", "buildx build failed", err) } @@ -192,9 +189,9 @@ func (p *DockerPublisher) resolveTags(tags []string, version string) []string { resolved := make([]string, 0, len(tags)) for _, tag := range tags { // Replace {{.Version}} with actual version - resolvedTag := strings.ReplaceAll(tag, "{{.Version}}", version) + resolvedTag := core.Replace(tag, "{{.Version}}", version) // Also support simpler {{Version}} syntax - resolvedTag = strings.ReplaceAll(resolvedTag, "{{Version}}", version) + resolvedTag = core.Replace(resolvedTag, "{{Version}}", version) resolved = append(resolved, resolvedTag) } return resolved @@ -203,9 +200,9 @@ func (p *DockerPublisher) resolveTags(tags []string, version string) []string { // buildFullTag builds the full image tag including registry. func (p *DockerPublisher) buildFullTag(registry, image, tag string) string { if registry != "" { - return fmt.Sprintf("%s/%s:%s", registry, image, tag) + return core.Sprintf("%s/%s:%s", registry, image, tag) } - return fmt.Sprintf("%s:%s", image, tag) + return core.Sprintf("%s:%s", image, tag) } // buildBuildxArgs builds the arguments for docker buildx build command. @@ -214,7 +211,7 @@ func (p *DockerPublisher) buildBuildxArgs(cfg DockerConfig, tags []string, versi // Multi-platform support if len(cfg.Platforms) > 0 { - args = append(args, "--platform", strings.Join(cfg.Platforms, ",")) + args = append(args, "--platform", core.Join(",", cfg.Platforms...)) } // Add all tags @@ -230,13 +227,13 @@ func (p *DockerPublisher) buildBuildxArgs(cfg DockerConfig, tags []string, versi // Build arguments for k, v := range cfg.BuildArgs { // Expand version in build args - expandedValue := strings.ReplaceAll(v, "{{.Version}}", version) - expandedValue = strings.ReplaceAll(expandedValue, "{{Version}}", version) - args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, expandedValue)) + expandedValue := core.Replace(v, "{{.Version}}", version) + expandedValue = core.Replace(expandedValue, "{{Version}}", version) + args = append(args, "--build-arg", core.Sprintf("%s=%s", k, expandedValue)) } // Always add VERSION build arg - args = append(args, "--build-arg", fmt.Sprintf("VERSION=%s", version)) + args = append(args, "--build-arg", core.Sprintf("VERSION=%s", version)) // Push the image args = append(args, "--push") @@ -250,19 +247,14 @@ func (p *DockerPublisher) buildBuildxArgs(cfg DockerConfig, tags []string, versi // ensureBuildx ensures docker buildx is available and has a builder. func (p *DockerPublisher) ensureBuildx(ctx context.Context) error { // Check if buildx is available - cmd := exec.CommandContext(ctx, "docker", "buildx", "version") - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", "buildx", "version"); err != nil { return coreerr.E("docker.ensureBuildx", "buildx is not available. Install it from https://docs.docker.com/buildx/working-with-buildx/", nil) } // Check if we have a builder, create one if not - cmd = exec.CommandContext(ctx, "docker", "buildx", "inspect", "--bootstrap") - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", "buildx", "inspect", "--bootstrap"); err != nil { // Try to create a builder - cmd = exec.CommandContext(ctx, "docker", "buildx", "create", "--use", "--bootstrap") - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, "", nil, "docker", "buildx", "create", "--use", "--bootstrap"); err != nil { return coreerr.E("docker.ensureBuildx", "failed to create buildx builder", err) } } @@ -272,8 +264,7 @@ func (p *DockerPublisher) ensureBuildx(ctx context.Context) error { // validateDockerCli checks if the docker CLI is available. func validateDockerCli() error { - cmd := exec.Command("docker", "--version") - if err := cmd.Run(); err != nil { + if _, err := ax.LookPath("docker"); err != nil { return coreerr.E("docker.validateDockerCli", "docker CLI not found. Install it from https://docs.docker.com/get-docker/", nil) } return nil diff --git a/pkg/release/publishers/docker_test.go b/pkg/release/publishers/docker_test.go index cbad8f7..9a1dfee 100644 --- a/pkg/release/publishers/docker_test.go +++ b/pkg/release/publishers/docker_test.go @@ -1,25 +1,23 @@ package publishers import ( - "bytes" "context" - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestDockerPublisher_Name_Good(t *testing.T) { +func TestDocker_DockerPublisherName_Good(t *testing.T) { t.Run("returns docker", func(t *testing.T) { p := NewDockerPublisher() assert.Equal(t, "docker", p.Name()) }) } -func TestDockerPublisher_ParseConfig_Good(t *testing.T) { +func TestDocker_DockerPublisherParseConfig_Good(t *testing.T) { p := NewDockerPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -73,7 +71,7 @@ func TestDockerPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestDockerPublisher_ResolveTags_Good(t *testing.T) { +func TestDocker_DockerPublisherResolveTags_Good(t *testing.T) { p := NewDockerPublisher() t.Run("resolves version template", func(t *testing.T) { @@ -95,7 +93,7 @@ func TestDockerPublisher_ResolveTags_Good(t *testing.T) { }) } -func TestDockerPublisher_BuildFullTag_Good(t *testing.T) { +func TestDocker_DockerPublisherBuildFullTag_Good(t *testing.T) { p := NewDockerPublisher() tests := []struct { @@ -136,7 +134,7 @@ func TestDockerPublisher_BuildFullTag_Good(t *testing.T) { } } -func TestDockerPublisher_BuildBuildxArgs_Good(t *testing.T) { +func TestDocker_DockerPublisherBuildBuildxArgs_Good(t *testing.T) { p := NewDockerPublisher() t.Run("builds basic args", func(t *testing.T) { @@ -228,7 +226,7 @@ func TestDockerPublisher_BuildBuildxArgs_Good(t *testing.T) { }) } -func TestDockerPublisher_Publish_Bad(t *testing.T) { +func TestDocker_DockerPublisherPublish_Bad(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } @@ -255,7 +253,7 @@ func TestDockerPublisher_Publish_Bad(t *testing.T) { }) } -func TestDockerConfig_Defaults_Good(t *testing.T) { +func TestDocker_DockerConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewDockerPublisher() pubCfg := PublisherConfig{Type: "docker"} @@ -273,14 +271,10 @@ func TestDockerConfig_Defaults_Good(t *testing.T) { }) } -func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { +func TestDocker_DockerPublisherDryRunPublish_Good(t *testing.T) { p := NewDockerPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: "/project", @@ -295,15 +289,11 @@ func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { BuildArgs: make(map[string]string), } - err := p.dryRunPublish(release, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Docker Build & Push") assert.Contains(t, output, "Version: v1.0.0") @@ -320,10 +310,6 @@ func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows build args when present", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: "/project", @@ -341,15 +327,11 @@ func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { }, } - err := p.dryRunPublish(release, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Build arguments:") assert.Contains(t, output, "GO_VERSION=1.21") @@ -357,10 +339,6 @@ func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("handles single platform", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v2.0.0", ProjectDir: "/project", @@ -375,22 +353,18 @@ func TestDockerPublisher_DryRunPublish_Good(t *testing.T) { BuildArgs: make(map[string]string), } - err := p.dryRunPublish(release, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Platforms: linux/amd64") assert.Contains(t, output, "ghcr.io/owner/repo:stable") }) } -func TestDockerPublisher_ParseConfig_EdgeCases_Good(t *testing.T) { +func TestDocker_DockerPublisherParseConfigEdgeCases_Good(t *testing.T) { p := NewDockerPublisher() t.Run("handles nil release config", func(t *testing.T) { @@ -455,7 +429,7 @@ func TestDockerPublisher_ParseConfig_EdgeCases_Good(t *testing.T) { }) } -func TestDockerPublisher_ResolveTags_EdgeCases_Good(t *testing.T) { +func TestDocker_DockerPublisherResolveTagsEdgeCases_Good(t *testing.T) { p := NewDockerPublisher() t.Run("handles empty tags", func(t *testing.T) { @@ -474,7 +448,7 @@ func TestDockerPublisher_ResolveTags_EdgeCases_Good(t *testing.T) { }) } -func TestDockerPublisher_BuildBuildxArgs_EdgeCases_Good(t *testing.T) { +func TestDocker_DockerPublisherBuildBuildxArgsEdgeCases_Good(t *testing.T) { p := NewDockerPublisher() t.Run("handles empty platforms", func(t *testing.T) { @@ -563,7 +537,7 @@ func TestDockerPublisher_BuildBuildxArgs_EdgeCases_Good(t *testing.T) { }) } -func TestDockerPublisher_Publish_DryRun_Good(t *testing.T) { +func TestDocker_DockerPublisherPublishDryRun_Good(t *testing.T) { // Skip if docker CLI is not available - dry run still validates docker is installed if err := validateDockerCli(); err != nil { t.Skip("skipping test: docker CLI not available") @@ -573,17 +547,8 @@ func TestDockerPublisher_Publish_DryRun_Good(t *testing.T) { t.Run("dry run succeeds with valid Dockerfile", func(t *testing.T) { // Create temp directory with Dockerfile - tmpDir, err := os.MkdirTemp("", "docker-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - dockerfilePath := filepath.Join(tmpDir, "Dockerfile") - err = os.WriteFile(dockerfilePath, []byte("FROM alpine:latest\n"), 0644) - require.NoError(t, err) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + tmpDir := t.TempDir() + require.NoError(t, ax.WriteFile(ax.Join(tmpDir, "Dockerfile"), []byte("FROM alpine:latest\n"), 0o644)) release := &Release{ Version: "v1.0.0", @@ -593,35 +558,20 @@ func TestDockerPublisher_Publish_DryRun_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "docker"} relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Docker Build & Push") }) t.Run("dry run uses custom dockerfile path", func(t *testing.T) { // Create temp directory with custom Dockerfile - tmpDir, err := os.MkdirTemp("", "docker-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - customDir := filepath.Join(tmpDir, "docker") - err = os.MkdirAll(customDir, 0755) - require.NoError(t, err) - - dockerfilePath := filepath.Join(customDir, "Dockerfile.prod") - err = os.WriteFile(dockerfilePath, []byte("FROM alpine:latest\n"), 0644) - require.NoError(t, err) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + tmpDir := t.TempDir() + customDir := ax.Join(tmpDir, "docker") + require.NoError(t, ax.MkdirAll(customDir, 0o755)) + require.NoError(t, ax.WriteFile(ax.Join(customDir, "Dockerfile.prod"), []byte("FROM alpine:latest\n"), 0o644)) release := &Release{ Version: "v1.0.0", @@ -636,20 +586,16 @@ func TestDockerPublisher_Publish_DryRun_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Dockerfile.prod") }) } -func TestDockerPublisher_Publish_Validation_Bad(t *testing.T) { +func TestDocker_DockerPublisherPublishValidation_Bad(t *testing.T) { p := NewDockerPublisher() t.Run("fails when Dockerfile not found with docker installed", func(t *testing.T) { @@ -689,7 +635,7 @@ func TestDockerPublisher_Publish_Validation_Bad(t *testing.T) { }) } -func TestValidateDockerCli_Good(t *testing.T) { +func TestDocker_ValidateDockerCli_Good(t *testing.T) { t.Run("returns nil when docker is installed", func(t *testing.T) { err := validateDockerCli() if err != nil { @@ -700,7 +646,7 @@ func TestValidateDockerCli_Good(t *testing.T) { }) } -func TestDockerPublisher_Publish_WithCLI_Good(t *testing.T) { +func TestDocker_DockerPublisherPublishWithCLI_Good(t *testing.T) { // These tests run only when docker CLI is available if err := validateDockerCli(); err != nil { t.Skip("skipping test: docker CLI not available") @@ -709,17 +655,8 @@ func TestDockerPublisher_Publish_WithCLI_Good(t *testing.T) { p := NewDockerPublisher() t.Run("dry run succeeds with all config options", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "docker-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - dockerfilePath := filepath.Join(tmpDir, "Dockerfile") - err = os.WriteFile(dockerfilePath, []byte("FROM alpine:latest\n"), 0644) - require.NoError(t, err) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + tmpDir := t.TempDir() + require.NoError(t, ax.WriteFile(ax.Join(tmpDir, "Dockerfile"), []byte("FROM alpine:latest\n"), 0o644)) release := &Release{ Version: "v1.0.0", @@ -738,32 +675,19 @@ func TestDockerPublisher_Publish_WithCLI_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Docker Build & Push") assert.Contains(t, output, "docker.io") assert.Contains(t, output, "myorg/myapp") }) t.Run("dry run with nil relCfg uses extended image", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "docker-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - dockerfilePath := filepath.Join(tmpDir, "Dockerfile") - err = os.WriteFile(dockerfilePath, []byte("FROM alpine:latest\n"), 0644) - require.NoError(t, err) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + tmpDir := t.TempDir() + require.NoError(t, ax.WriteFile(ax.Join(tmpDir, "Dockerfile"), []byte("FROM alpine:latest\n"), 0o644)) release := &Release{ Version: "v1.0.0", @@ -777,22 +701,16 @@ func TestDockerPublisher_Publish_WithCLI_Good(t *testing.T) { }, } - err = p.Publish(context.TODO(), release, pubCfg, nil, true) // nil relCfg - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, nil, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "standalone/image") }) t.Run("fails with non-existent Dockerfile in non-dry-run", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "docker-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Don't create a Dockerfile release := &Release{ @@ -803,7 +721,7 @@ func TestDockerPublisher_Publish_WithCLI_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "docker"} relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, false) + err := p.Publish(context.TODO(), release, pubCfg, relCfg, false) assert.Error(t, err) assert.Contains(t, err.Error(), "Dockerfile not found") }) diff --git a/pkg/release/publishers/github.go b/pkg/release/publishers/github.go index b80001a..d060c67 100644 --- a/pkg/release/publishers/github.go +++ b/pkg/release/publishers/github.go @@ -3,30 +3,31 @@ package publishers import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreerr "dappco.re/go/core/log" ) // GitHubPublisher publishes releases to GitHub using the gh CLI. +// Usage example: declare a value of type publishers.GitHubPublisher in integrating code. type GitHubPublisher struct{} // NewGitHubPublisher creates a new GitHub publisher. +// Usage example: call publishers.NewGitHubPublisher(...) from integrating code. func NewGitHubPublisher() *GitHubPublisher { return &GitHubPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *GitHubPublisher) Name() string { return "github" } // Publish publishes the release to GitHub. // Uses the gh CLI for creating releases and uploading assets. +// Usage example: call value.Publish(...) from integrating code. func (p *GitHubPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { // Determine repository repo := "" @@ -56,34 +57,34 @@ func (p *GitHubPublisher) Publish(ctx context.Context, release *Release, pubCfg // dryRunPublish shows what would be done without actually publishing. func (p *GitHubPublisher) dryRunPublish(release *Release, pubCfg PublisherConfig, repo string) error { - fmt.Println() - fmt.Println("=== DRY RUN: GitHub Release ===") - fmt.Println() - fmt.Printf("Repository: %s\n", repo) - fmt.Printf("Version: %s\n", release.Version) - fmt.Printf("Draft: %t\n", pubCfg.Draft) - fmt.Printf("Prerelease: %t\n", pubCfg.Prerelease) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: GitHub Release ===") + publisherPrintln() + publisherPrint("Repository: %s", repo) + publisherPrint("Version: %s", release.Version) + publisherPrint("Draft: %t", pubCfg.Draft) + publisherPrint("Prerelease: %t", pubCfg.Prerelease) + publisherPrintln() - fmt.Println("Would create release with command:") + publisherPrintln("Would create release with command:") args := p.buildCreateArgs(release, pubCfg, repo) - fmt.Printf(" gh %s\n", strings.Join(args, " ")) - fmt.Println() + publisherPrint(" gh %s", core.Join(" ", args...)) + publisherPrintln() if len(release.Artifacts) > 0 { - fmt.Println("Would upload artifacts:") + publisherPrintln("Would upload artifacts:") for _, artifact := range release.Artifacts { - fmt.Printf(" - %s\n", filepath.Base(artifact.Path)) + publisherPrint(" - %s", ax.Base(artifact.Path)) } } - fmt.Println() - fmt.Println("Changelog:") - fmt.Println("---") - fmt.Println(release.Changelog) - fmt.Println("---") - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("Changelog:") + publisherPrintln("---") + publisherPrintln(release.Changelog) + publisherPrintln("---") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -99,12 +100,7 @@ func (p *GitHubPublisher) executePublish(ctx context.Context, release *Release, } // Execute gh release create - cmd := exec.CommandContext(ctx, "gh", args...) - cmd.Dir = release.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, release.ProjectDir, nil, "gh", args...); err != nil { return coreerr.E("github.Publish", "gh release create failed", err) } @@ -145,20 +141,16 @@ func (p *GitHubPublisher) buildCreateArgs(release *Release, pubCfg PublisherConf // validateGhCli checks if the gh CLI is available and authenticated. func validateGhCli() error { - // Check if gh is installed - cmd := exec.Command("gh", "--version") - if err := cmd.Run(); err != nil { + if _, err := ax.LookPath("gh"); err != nil { return coreerr.E("github.validateGhCli", "gh CLI not found. Install it from https://cli.github.com", err) } - // Check if authenticated - cmd = exec.Command("gh", "auth", "status") - output, err := cmd.CombinedOutput() + output, err := ax.CombinedOutput(context.Background(), "", nil, "gh", "auth", "status") if err != nil { return coreerr.E("github.validateGhCli", "not authenticated with gh CLI. Run 'gh auth login' first", err) } - if !strings.Contains(string(output), "Logged in") { + if !core.Contains(output, "Logged in") { return coreerr.E("github.validateGhCli", "not authenticated with gh CLI. Run 'gh auth login' first", nil) } @@ -167,15 +159,12 @@ func validateGhCli() error { // detectRepository detects the GitHub repository from git remote. func detectRepository(dir string) (string, error) { - cmd := exec.Command("git", "remote", "get-url", "origin") - cmd.Dir = dir - output, err := cmd.Output() + output, err := ax.RunDir(context.Background(), dir, "git", "remote", "get-url", "origin") if err != nil { return "", coreerr.E("github.detectRepository", "failed to get git remote", err) } - url := strings.TrimSpace(string(output)) - return parseGitHubRepo(url) + return parseGitHubRepo(core.Trim(output)) } // parseGitHubRepo extracts owner/repo from a GitHub URL. @@ -185,16 +174,16 @@ func detectRepository(dir string) (string, error) { // - https://github.com/owner/repo func parseGitHubRepo(url string) (string, error) { // SSH format - if strings.HasPrefix(url, "git@github.com:") { - repo := strings.TrimPrefix(url, "git@github.com:") - repo = strings.TrimSuffix(repo, ".git") + if core.HasPrefix(url, "git@github.com:") { + repo := core.TrimPrefix(url, "git@github.com:") + repo = core.TrimSuffix(repo, ".git") return repo, nil } // HTTPS format - if strings.HasPrefix(url, "https://github.com/") { - repo := strings.TrimPrefix(url, "https://github.com/") - repo = strings.TrimSuffix(repo, ".git") + if core.HasPrefix(url, "https://github.com/") { + repo := core.TrimPrefix(url, "https://github.com/") + repo = core.TrimSuffix(repo, ".git") return repo, nil } @@ -203,12 +192,9 @@ func parseGitHubRepo(url string) (string, error) { // UploadArtifact uploads a single artifact to an existing release. // This can be used to add artifacts to a release after creation. +// Usage example: call publishers.UploadArtifact(...) from integrating code. func UploadArtifact(ctx context.Context, repo, version, artifactPath string) error { - cmd := exec.CommandContext(ctx, "gh", "release", "upload", version, artifactPath, "--repo", repo) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, "", nil, "gh", "release", "upload", version, artifactPath, "--repo", repo); err != nil { return coreerr.E("github.UploadArtifact", "failed to upload "+artifactPath, err) } @@ -216,12 +202,9 @@ func UploadArtifact(ctx context.Context, repo, version, artifactPath string) err } // DeleteRelease deletes a release by tag name. +// Usage example: call publishers.DeleteRelease(...) from integrating code. func DeleteRelease(ctx context.Context, repo, version string) error { - cmd := exec.CommandContext(ctx, "gh", "release", "delete", version, "--repo", repo, "--yes") - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, "", nil, "gh", "release", "delete", version, "--repo", repo, "--yes"); err != nil { return coreerr.E("github.DeleteRelease", "failed to delete "+version, err) } @@ -229,7 +212,7 @@ func DeleteRelease(ctx context.Context, repo, version string) error { } // ReleaseExists checks if a release exists for the given version. +// Usage example: call publishers.ReleaseExists(...) from integrating code. func ReleaseExists(ctx context.Context, repo, version string) bool { - cmd := exec.CommandContext(ctx, "gh", "release", "view", version, "--repo", repo) - return cmd.Run() == nil + return ax.Exec(ctx, "gh", "release", "view", version, "--repo", repo) == nil } diff --git a/pkg/release/publishers/github_test.go b/pkg/release/publishers/github_test.go index 2cb87a5..2733223 100644 --- a/pkg/release/publishers/github_test.go +++ b/pkg/release/publishers/github_test.go @@ -1,20 +1,17 @@ package publishers import ( - "bytes" "context" - "os" - "os/exec" - "strings" "testing" + "dappco.re/go/core" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestParseGitHubRepo_Good(t *testing.T) { +func TestGitHub_ParseGitHubRepo_Good(t *testing.T) { tests := []struct { name string input string @@ -51,7 +48,7 @@ func TestParseGitHubRepo_Good(t *testing.T) { } } -func TestParseGitHubRepo_Bad(t *testing.T) { +func TestGitHub_ParseGitHubRepo_Bad(t *testing.T) { tests := []struct { name string input string @@ -82,14 +79,14 @@ func TestParseGitHubRepo_Bad(t *testing.T) { } } -func TestGitHubPublisher_Name_Good(t *testing.T) { +func TestGitHub_GitHubPublisherName_Good(t *testing.T) { t.Run("returns github", func(t *testing.T) { p := NewGitHubPublisher() assert.Equal(t, "github", p.Name()) }) } -func TestNewRelease_Good(t *testing.T) { +func TestGitHub_NewRelease_Good(t *testing.T) { t.Run("creates release struct", func(t *testing.T) { r := NewRelease("v1.0.0", nil, "changelog", "/project", io.Local) assert.Equal(t, "v1.0.0", r.Version) @@ -99,7 +96,7 @@ func TestNewRelease_Good(t *testing.T) { }) } -func TestNewPublisherConfig_Good(t *testing.T) { +func TestGitHub_NewPublisherConfig_Good(t *testing.T) { t.Run("creates config struct", func(t *testing.T) { cfg := NewPublisherConfig("github", true, false, nil) assert.Equal(t, "github", cfg.Type) @@ -116,7 +113,7 @@ func TestNewPublisherConfig_Good(t *testing.T) { }) } -func TestBuildCreateArgs_Good(t *testing.T) { +func TestGitHub_BuildCreateArgs_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("basic args", func(t *testing.T) { @@ -221,14 +218,10 @@ func TestBuildCreateArgs_Good(t *testing.T) { }) } -func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { +func TestGitHub_GitHubPublisherDryRunPublish_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", Changelog: "## Changes\n\n- Feature A\n- Bug fix B", @@ -241,15 +234,11 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { Prerelease: false, } - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: GitHub Release") assert.Contains(t, output, "Repository: owner/repo") @@ -264,10 +253,6 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows artifacts when present", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", Changelog: "Changes", @@ -280,15 +265,11 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { } cfg := PublisherConfig{Type: "github"} - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would upload artifacts:") assert.Contains(t, output, "myapp-darwin-amd64.tar.gz") @@ -296,10 +277,6 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows draft and prerelease flags", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0-beta", Changelog: "Beta release", @@ -312,15 +289,11 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { Prerelease: true, } - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Draft: true") assert.Contains(t, output, "Prerelease: true") @@ -329,14 +302,10 @@ func TestGitHubPublisher_DryRunPublish_Good(t *testing.T) { }) } -func TestGitHubPublisher_Publish_Good(t *testing.T) { +func TestGitHub_GitHubPublisherPublish_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("dry run uses repository from config", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", Changelog: "Changes", @@ -347,20 +316,16 @@ func TestGitHubPublisher_Publish_Good(t *testing.T) { relCfg := &mockReleaseConfig{repository: "custom/repo"} // Dry run should succeed without needing gh CLI - err := p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Repository: custom/repo") }) } -func TestGitHubPublisher_Publish_Bad(t *testing.T) { +func TestGitHub_GitHubPublisherPublish_Bad(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } @@ -387,9 +352,7 @@ func TestGitHubPublisher_Publish_Bad(t *testing.T) { t.Run("fails when repository cannot be detected", func(t *testing.T) { // Create a temp directory that is NOT a git repo - tmpDir, err := os.MkdirTemp("", "github-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() release := &Release{ Version: "v1.0.0", @@ -400,7 +363,7 @@ func TestGitHubPublisher_Publish_Bad(t *testing.T) { pubCfg := PublisherConfig{Type: "github"} relCfg := &mockReleaseConfig{repository: ""} // Empty repository - err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + err := p.Publish(context.Background(), release, pubCfg, relCfg, true) // Should fail because detectRepository will fail on non-git dir assert.Error(t, err) @@ -408,21 +371,14 @@ func TestGitHubPublisher_Publish_Bad(t *testing.T) { }) } -func TestDetectRepository_Good(t *testing.T) { +func TestGitHub_DetectRepository_Good(t *testing.T) { t.Run("detects repository from git remote", func(t *testing.T) { // Create a temp git repo - tmpDir, err := os.MkdirTemp("", "git-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Initialize git repo and set remote - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:test-owner/test-repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "git@github.com:test-owner/test-repo.git") repo, err := detectRepository(tmpDir) require.NoError(t, err) @@ -430,17 +386,9 @@ func TestDetectRepository_Good(t *testing.T) { }) t.Run("detects repository from HTTPS remote", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "git-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "https://github.com/another-owner/another-repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) + tmpDir := t.TempDir() + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "https://github.com/another-owner/another-repo.git") repo, err := detectRepository(tmpDir) require.NoError(t, err) @@ -448,13 +396,11 @@ func TestDetectRepository_Good(t *testing.T) { }) } -func TestDetectRepository_Bad(t *testing.T) { +func TestGitHub_DetectRepository_Bad(t *testing.T) { t.Run("fails when not a git repository", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "no-git-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() - _, err = detectRepository(tmpDir) + _, err := detectRepository(tmpDir) assert.Error(t, err) assert.Contains(t, err.Error(), "failed to get git remote") }) @@ -465,25 +411,17 @@ func TestDetectRepository_Bad(t *testing.T) { }) t.Run("fails when remote is not GitHub", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "git-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "git@gitlab.com:owner/repo.git") - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "git@gitlab.com:owner/repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - _, err = detectRepository(tmpDir) + _, err := detectRepository(tmpDir) assert.Error(t, err) assert.Contains(t, err.Error(), "not a GitHub URL") }) } -func TestValidateGhCli_Bad(t *testing.T) { +func TestGitHub_ValidateGhCli_Bad(t *testing.T) { // This test verifies the error messages from validateGhCli // We can't easily mock exec.Command, but we can at least // verify the function exists and returns expected error types @@ -494,15 +432,15 @@ func TestValidateGhCli_Bad(t *testing.T) { if err != nil { // Either gh is not installed or not authenticated assert.True(t, - strings.Contains(err.Error(), "gh CLI not found") || - strings.Contains(err.Error(), "not authenticated"), + core.Contains(err.Error(), "gh CLI not found") || + core.Contains(err.Error(), "not authenticated"), "unexpected error: %s", err.Error()) } // If err is nil, gh is installed and authenticated - that's OK too }) } -func TestGitHubPublisher_ExecutePublish_Good(t *testing.T) { +func TestGitHub_GitHubPublisherExecutePublish_Good(t *testing.T) { // These tests run only when gh CLI is available and authenticated if err := validateGhCli(); err != nil { t.Skip("skipping test: gh CLI not available or not authenticated") @@ -535,7 +473,7 @@ func TestGitHubPublisher_ExecutePublish_Good(t *testing.T) { }) } -func TestReleaseExists_Good(t *testing.T) { +func TestGitHub_ReleaseExists_Good(t *testing.T) { // These tests run only when gh CLI is available if err := validateGhCli(); err != nil { t.Skip("skipping test: gh CLI not available or not authenticated") diff --git a/pkg/release/publishers/homebrew.go b/pkg/release/publishers/homebrew.go index d36340a..fa26077 100644 --- a/pkg/release/publishers/homebrew.go +++ b/pkg/release/publishers/homebrew.go @@ -5,13 +5,10 @@ import ( "bytes" "context" "embed" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" "text/template" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -21,6 +18,7 @@ import ( var homebrewTemplates embed.FS // HomebrewConfig holds Homebrew-specific configuration. +// Usage example: declare a value of type publishers.HomebrewConfig in integrating code. type HomebrewConfig struct { // Tap is the Homebrew tap repository (e.g., "host-uk/homebrew-tap"). Tap string @@ -31,6 +29,7 @@ type HomebrewConfig struct { } // OfficialConfig holds configuration for generating files for official repo PRs. +// Usage example: declare a value of type publishers.OfficialConfig in integrating code. type OfficialConfig struct { // Enabled determines whether to generate files for official repos. Enabled bool @@ -39,19 +38,23 @@ type OfficialConfig struct { } // HomebrewPublisher publishes releases to Homebrew. +// Usage example: declare a value of type publishers.HomebrewPublisher in integrating code. type HomebrewPublisher struct{} // NewHomebrewPublisher creates a new Homebrew publisher. +// Usage example: call publishers.NewHomebrewPublisher(...) from integrating code. func NewHomebrewPublisher() *HomebrewPublisher { return &HomebrewPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *HomebrewPublisher) Name() string { return "homebrew" } // Publish publishes the release to Homebrew. +// Usage example: call value.Publish(...) from integrating code. func (p *HomebrewPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { // Parse config cfg := p.parseConfig(pubCfg, relCfg) @@ -79,7 +82,7 @@ func (p *HomebrewPublisher) Publish(ctx context.Context, release *Release, pubCf projectName = relCfg.GetProjectName() } if projectName == "" { - parts := strings.Split(repo, "/") + parts := core.Split(repo, "/") projectName = parts[len(parts)-1] } @@ -89,7 +92,7 @@ func (p *HomebrewPublisher) Publish(ctx context.Context, release *Release, pubCf } // Strip leading 'v' from version - version := strings.TrimPrefix(release.Version, "v") + version := core.TrimPrefix(release.Version, "v") // Build checksums map from artifacts checksums := buildChecksumMap(release.Artifacts) @@ -97,7 +100,7 @@ func (p *HomebrewPublisher) Publish(ctx context.Context, release *Release, pubCf // Template data data := homebrewTemplateData{ FormulaClass: toFormulaClass(formulaName), - Description: fmt.Sprintf("%s CLI", projectName), + Description: core.Sprintf("%s CLI", projectName), Repository: repo, Version: version, License: "MIT", @@ -124,6 +127,7 @@ type homebrewTemplateData struct { } // ChecksumMap holds checksums for different platform/arch combinations. +// Usage example: declare a value of type publishers.ChecksumMap in integrating code. type ChecksumMap struct { DarwinAmd64 string DarwinArm64 string @@ -163,38 +167,38 @@ func (p *HomebrewPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseCo // dryRunPublish shows what would be done. func (p *HomebrewPublisher) dryRunPublish(m coreio.Medium, data homebrewTemplateData, cfg HomebrewConfig) error { - fmt.Println() - fmt.Println("=== DRY RUN: Homebrew Publish ===") - fmt.Println() - fmt.Printf("Formula: %s\n", data.FormulaClass) - fmt.Printf("Version: %s\n", data.Version) - fmt.Printf("Tap: %s\n", cfg.Tap) - fmt.Printf("Repository: %s\n", data.Repository) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: Homebrew Publish ===") + publisherPrintln() + publisherPrint("Formula: %s", data.FormulaClass) + publisherPrint("Version: %s", data.Version) + publisherPrint("Tap: %s", cfg.Tap) + publisherPrint("Repository: %s", data.Repository) + publisherPrintln() // Generate and show formula formula, err := p.renderTemplate(m, "templates/homebrew/formula.rb.tmpl", data) if err != nil { return coreerr.E("homebrew.dryRunPublish", "failed to render template", err) } - fmt.Println("Generated formula.rb:") - fmt.Println("---") - fmt.Println(formula) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated formula.rb:") + publisherPrintln("---") + publisherPrintln(formula) + publisherPrintln("---") + publisherPrintln() if cfg.Tap != "" { - fmt.Printf("Would commit to tap: %s\n", cfg.Tap) + publisherPrint("Would commit to tap: %s", cfg.Tap) } if cfg.Official != nil && cfg.Official.Enabled { output := cfg.Official.Output if output == "" { output = "dist/homebrew" } - fmt.Printf("Would write files for official PR to: %s\n", output) + publisherPrint("Would write files for official PR to: %s", output) } - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -211,20 +215,20 @@ func (p *HomebrewPublisher) executePublish(ctx context.Context, projectDir strin if cfg.Official != nil && cfg.Official.Enabled { output := cfg.Official.Output if output == "" { - output = filepath.Join(projectDir, "dist", "homebrew") - } else if !filepath.IsAbs(output) { - output = filepath.Join(projectDir, output) + output = ax.Join(projectDir, "dist", "homebrew") + } else if !ax.IsAbs(output) { + output = ax.Join(projectDir, output) } if err := release.FS.EnsureDir(output); err != nil { return coreerr.E("homebrew.Publish", "failed to create output directory", err) } - formulaPath := filepath.Join(output, fmt.Sprintf("%s.rb", strings.ToLower(data.FormulaClass))) + formulaPath := ax.Join(output, core.Sprintf("%s.rb", core.Lower(data.FormulaClass))) if err := release.FS.Write(formulaPath, formula); err != nil { return coreerr.E("homebrew.Publish", "failed to write formula", err) } - fmt.Printf("Wrote Homebrew formula for official PR: %s\n", formulaPath) + publisherPrint("Wrote Homebrew formula for official PR: %s", formulaPath) } // If tap is configured, commit to it @@ -240,59 +244,46 @@ func (p *HomebrewPublisher) executePublish(ctx context.Context, projectDir strin // commitToTap commits the formula to the tap repository. func (p *HomebrewPublisher) commitToTap(ctx context.Context, tap string, data homebrewTemplateData, formula string) error { // Clone tap repo to temp directory - tmpDir, err := os.MkdirTemp("", "homebrew-tap-*") + tmpDir, err := ax.TempDir("homebrew-tap-*") if err != nil { return coreerr.E("homebrew.commitToTap", "failed to create temp directory", err) } - defer func() { _ = coreio.Local.DeleteAll(tmpDir) }() + defer func() { _ = ax.RemoveAll(tmpDir) }() // Clone the tap - fmt.Printf("Cloning tap %s...\n", tap) - cmd := exec.CommandContext(ctx, "gh", "repo", "clone", tap, tmpDir, "--", "--depth=1") - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + publisherPrint("Cloning tap %s...", tap) + if err := publisherRun(ctx, "", nil, "gh", "repo", "clone", tap, tmpDir, "--", "--depth=1"); err != nil { return coreerr.E("homebrew.commitToTap", "failed to clone tap", err) } // Ensure Formula directory exists - formulaDir := filepath.Join(tmpDir, "Formula") + formulaDir := ax.Join(tmpDir, "Formula") if err := coreio.Local.EnsureDir(formulaDir); err != nil { return coreerr.E("homebrew.commitToTap", "failed to create Formula directory", err) } // Write formula - formulaPath := filepath.Join(formulaDir, fmt.Sprintf("%s.rb", strings.ToLower(data.FormulaClass))) + formulaPath := ax.Join(formulaDir, core.Sprintf("%s.rb", core.Lower(data.FormulaClass))) if err := coreio.Local.Write(formulaPath, formula); err != nil { return coreerr.E("homebrew.commitToTap", "failed to write formula", err) } // Git add, commit, push - commitMsg := fmt.Sprintf("Update %s to %s", data.FormulaClass, data.Version) + commitMsg := core.Sprintf("Update %s to %s", data.FormulaClass, data.Version) - cmd = exec.CommandContext(ctx, "git", "add", ".") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(ctx, tmpDir, "git", "add", "."); err != nil { return coreerr.E("homebrew.commitToTap", "git add failed", err) } - cmd = exec.CommandContext(ctx, "git", "commit", "-m", commitMsg) - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "commit", "-m", commitMsg); err != nil { return coreerr.E("homebrew.commitToTap", "git commit failed", err) } - cmd = exec.CommandContext(ctx, "git", "push") - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "push"); err != nil { return coreerr.E("homebrew.commitToTap", "git push failed", err) } - fmt.Printf("Updated Homebrew tap: %s\n", tap) + publisherPrint("Updated Homebrew tap: %s", tap) return nil } @@ -302,7 +293,7 @@ func (p *HomebrewPublisher) renderTemplate(m coreio.Medium, name string, data ho var err error // Try custom template from medium - customPath := filepath.Join(".core", name) + customPath := ax.Join(".core", name) if m != nil && m.IsFile(customPath) { customContent, err := m.Read(customPath) if err == nil { @@ -318,7 +309,7 @@ func (p *HomebrewPublisher) renderTemplate(m coreio.Medium, name string, data ho } } - tmpl, err := template.New(filepath.Base(name)).Parse(string(content)) + tmpl, err := template.New(ax.Base(name)).Parse(string(content)) if err != nil { return "", coreerr.E("homebrew.renderTemplate", "failed to parse template "+name, err) } @@ -334,13 +325,13 @@ func (p *HomebrewPublisher) renderTemplate(m coreio.Medium, name string, data ho // toFormulaClass converts a package name to a Ruby class name. func toFormulaClass(name string) string { // Convert kebab-case to PascalCase - parts := strings.Split(name, "-") + parts := core.Split(name, "-") for i, part := range parts { if len(part) > 0 { - parts[i] = strings.ToUpper(part[:1]) + part[1:] + parts[i] = core.Upper(part[:1]) + part[1:] } } - return strings.Join(parts, "") + return core.Join("", parts...) } // buildChecksumMap extracts checksums from artifacts into a structured map. @@ -349,21 +340,21 @@ func buildChecksumMap(artifacts []build.Artifact) ChecksumMap { for _, a := range artifacts { // Parse artifact name to determine platform - name := filepath.Base(a.Path) + name := ax.Base(a.Path) checksum := a.Checksum switch { - case strings.Contains(name, "darwin-amd64"): + case core.Contains(name, "darwin-amd64"): checksums.DarwinAmd64 = checksum - case strings.Contains(name, "darwin-arm64"): + case core.Contains(name, "darwin-arm64"): checksums.DarwinArm64 = checksum - case strings.Contains(name, "linux-amd64"): + case core.Contains(name, "linux-amd64"): checksums.LinuxAmd64 = checksum - case strings.Contains(name, "linux-arm64"): + case core.Contains(name, "linux-arm64"): checksums.LinuxArm64 = checksum - case strings.Contains(name, "windows-amd64"): + case core.Contains(name, "windows-amd64"): checksums.WindowsAmd64 = checksum - case strings.Contains(name, "windows-arm64"): + case core.Contains(name, "windows-arm64"): checksums.WindowsArm64 = checksum } } diff --git a/pkg/release/publishers/homebrew_test.go b/pkg/release/publishers/homebrew_test.go index 74094e2..c0bb662 100644 --- a/pkg/release/publishers/homebrew_test.go +++ b/pkg/release/publishers/homebrew_test.go @@ -1,9 +1,7 @@ package publishers import ( - "bytes" "context" - "os" "testing" "dappco.re/go/core/build/pkg/build" @@ -12,14 +10,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestHomebrewPublisher_Name_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherName_Good(t *testing.T) { t.Run("returns homebrew", func(t *testing.T) { p := NewHomebrewPublisher() assert.Equal(t, "homebrew", p.Name()) }) } -func TestHomebrewPublisher_ParseConfig_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherParseConfig_Good(t *testing.T) { p := NewHomebrewPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -81,7 +79,7 @@ func TestHomebrewPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestHomebrewPublisher_ToFormulaClass_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherToFormulaClass_Good(t *testing.T) { tests := []struct { name string input string @@ -122,7 +120,7 @@ func TestHomebrewPublisher_ToFormulaClass_Good(t *testing.T) { } } -func TestHomebrewPublisher_BuildChecksumMap_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherBuildChecksumMap_Good(t *testing.T) { t.Run("maps artifacts to checksums by platform", func(t *testing.T) { artifacts := []build.Artifact{ {Path: "/dist/myapp-darwin-amd64.tar.gz", OS: "darwin", Arch: "amd64", Checksum: "abc123"}, @@ -167,7 +165,7 @@ func TestHomebrewPublisher_BuildChecksumMap_Good(t *testing.T) { }) } -func TestHomebrewPublisher_RenderTemplate_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherRenderTemplate_Good(t *testing.T) { p := NewHomebrewPublisher() t.Run("renders formula template with data", func(t *testing.T) { @@ -202,7 +200,7 @@ func TestHomebrewPublisher_RenderTemplate_Good(t *testing.T) { }) } -func TestHomebrewPublisher_RenderTemplate_Bad(t *testing.T) { +func TestHomebrew_HomebrewPublisherRenderTemplate_Bad(t *testing.T) { p := NewHomebrewPublisher() t.Run("returns error for non-existent template", func(t *testing.T) { @@ -213,15 +211,10 @@ func TestHomebrewPublisher_RenderTemplate_Bad(t *testing.T) { }) } -func TestHomebrewPublisher_DryRunPublish_Good(t *testing.T) { +func TestHomebrew_HomebrewPublisherDryRunPublish_Good(t *testing.T) { p := NewHomebrewPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - // Capture stdout - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := homebrewTemplateData{ FormulaClass: "MyApp", Description: "My CLI", @@ -235,15 +228,11 @@ func TestHomebrewPublisher_DryRunPublish_Good(t *testing.T) { Tap: "owner/homebrew-tap", } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Homebrew Publish") assert.Contains(t, output, "Formula: MyApp") @@ -255,10 +244,6 @@ func TestHomebrewPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows official output path when enabled", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := homebrewTemplateData{ FormulaClass: "MyApp", Version: "1.0.0", @@ -272,23 +257,15 @@ func TestHomebrewPublisher_DryRunPublish_Good(t *testing.T) { }, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would write files for official PR to: custom/path") }) t.Run("uses default official output path when not specified", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := homebrewTemplateData{ FormulaClass: "MyApp", Version: "1.0.0", @@ -301,20 +278,16 @@ func TestHomebrewPublisher_DryRunPublish_Good(t *testing.T) { }, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would write files for official PR to: dist/homebrew") }) } -func TestHomebrewPublisher_Publish_Bad(t *testing.T) { +func TestHomebrew_HomebrewPublisherPublish_Bad(t *testing.T) { p := NewHomebrewPublisher() t.Run("fails when tap not configured and not official mode", func(t *testing.T) { @@ -332,7 +305,7 @@ func TestHomebrewPublisher_Publish_Bad(t *testing.T) { }) } -func TestHomebrewConfig_Defaults_Good(t *testing.T) { +func TestHomebrew_HomebrewConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewHomebrewPublisher() pubCfg := PublisherConfig{Type: "homebrew"} diff --git a/pkg/release/publishers/integration_test.go b/pkg/release/publishers/integration_test.go index 3e653cf..fae64ba 100644 --- a/pkg/release/publishers/integration_test.go +++ b/pkg/release/publishers/integration_test.go @@ -1,13 +1,10 @@ package publishers import ( - "bytes" "context" - "os" - "os/exec" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" @@ -16,7 +13,7 @@ import ( // --- GitHub Publisher Integration Tests --- -func TestGitHubPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_GitHubPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("dry run creates no files on disk", func(t *testing.T) { @@ -27,9 +24,9 @@ func TestGitHubPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { ProjectDir: tmpDir, FS: io.Local, Artifacts: []build.Artifact{ - {Path: filepath.Join(tmpDir, "app-linux-amd64.tar.gz")}, - {Path: filepath.Join(tmpDir, "app-darwin-arm64.tar.gz")}, - {Path: filepath.Join(tmpDir, "CHECKSUMS.txt")}, + {Path: ax.Join(tmpDir, "app-linux-amd64.tar.gz")}, + {Path: ax.Join(tmpDir, "app-darwin-arm64.tar.gz")}, + {Path: ax.Join(tmpDir, "CHECKSUMS.txt")}, }, } pubCfg := PublisherConfig{ @@ -39,20 +36,11 @@ func TestGitHubPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/test-repo", projectName: "testapp"} - // Capture stdout - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() // Verify dry run output contains expected information assert.Contains(t, output, "DRY RUN: GitHub Release") @@ -69,7 +57,7 @@ func TestGitHubPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "--prerelease") // Verify no files were created in the temp directory - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries, "dry run should not create any files") }) @@ -131,14 +119,10 @@ func TestGitHubPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { }) } -func TestGitHubPublisher_Integration_RepositoryDetection_Good(t *testing.T) { +func TestIntegration_GitHubPublisherIntegrationRepositoryDetection_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("uses relCfg repository when provided", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", Changelog: "Changes", @@ -148,31 +132,19 @@ func TestGitHubPublisher_Integration_RepositoryDetection_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "github"} relCfg := &mockReleaseConfig{repository: "explicit/repo"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - assert.Contains(t, buf.String(), "Repository: explicit/repo") + assert.Contains(t, output, "Repository: explicit/repo") }) t.Run("detects repository from git remote when relCfg empty", func(t *testing.T) { tmpDir := t.TempDir() - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "https://github.com/detected/from-git.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "https://github.com/detected/from-git.git") release := &Release{ Version: "v1.0.0", @@ -183,15 +155,12 @@ func TestGitHubPublisher_Integration_RepositoryDetection_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "github"} relCfg := &mockReleaseConfig{repository: ""} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - assert.Contains(t, buf.String(), "Repository: detected/from-git") + assert.Contains(t, output, "Repository: detected/from-git") }) t.Run("fails when no repository available", func(t *testing.T) { @@ -212,14 +181,10 @@ func TestGitHubPublisher_Integration_RepositoryDetection_Good(t *testing.T) { }) } -func TestGitHubPublisher_Integration_ArtifactUpload_Good(t *testing.T) { +func TestIntegration_GitHubPublisherIntegrationArtifactUpload_Good(t *testing.T) { p := NewGitHubPublisher() t.Run("dry run lists all artifact types", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", Changelog: "Release notes", @@ -235,15 +200,11 @@ func TestGitHubPublisher_Integration_ArtifactUpload_Good(t *testing.T) { } pubCfg := PublisherConfig{Type: "github"} - err := p.dryRunPublish(release, pubCfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, pubCfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would upload artifacts:") assert.Contains(t, output, "app-linux-amd64.tar.gz") @@ -281,7 +242,7 @@ func TestGitHubPublisher_Integration_ArtifactUpload_Good(t *testing.T) { // --- Docker Publisher Integration Tests --- -func TestDockerPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_DockerPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { if err := validateDockerCli(); err != nil { t.Skip("skipping: docker CLI not available") } @@ -292,13 +253,9 @@ func TestDockerPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { tmpDir := t.TempDir() // Create a Dockerfile - err := os.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte("FROM alpine:latest\n"), 0644) + err := ax.WriteFile(ax.Join(tmpDir, "Dockerfile"), []byte("FROM alpine:latest\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.2.3", ProjectDir: tmpDir, @@ -319,15 +276,10 @@ func TestDockerPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/test-app"} - err = p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() // Verify dry run output assert.Contains(t, output, "DRY RUN: Docker Build & Push") @@ -399,7 +351,7 @@ func TestDockerPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { }) } -func TestDockerPublisher_Integration_ConfigParsing_Good(t *testing.T) { +func TestIntegration_DockerPublisherIntegrationConfigParsing_Good(t *testing.T) { p := NewDockerPublisher() t.Run("full config round-trip from PublisherConfig to DockerConfig", func(t *testing.T) { @@ -437,16 +389,12 @@ func TestDockerPublisher_Integration_ConfigParsing_Good(t *testing.T) { // --- Homebrew Publisher Integration Tests --- -func TestHomebrewPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_HomebrewPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewHomebrewPublisher() t.Run("dry run generates formula without writing files", func(t *testing.T) { tmpDir := t.TempDir() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v2.1.0", ProjectDir: tmpDir, @@ -467,15 +415,11 @@ func TestHomebrewPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/my-cli", projectName: "my-cli"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() // Verify dry run output assert.Contains(t, output, "DRY RUN: Homebrew Publish") @@ -495,16 +439,12 @@ func TestHomebrewPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "Would commit to tap: test-org/homebrew-tap") // Verify no files created - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries, "dry run should not create any files") }) t.Run("dry run with official config shows output path", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: "/project", @@ -522,20 +462,16 @@ func TestHomebrewPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "owner/repo", projectName: "repo"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would write files for official PR to: dist/homebrew-official") }) } -func TestHomebrewPublisher_Integration_FormulaGeneration_Good(t *testing.T) { +func TestIntegration_HomebrewPublisherIntegrationFormulaGeneration_Good(t *testing.T) { p := NewHomebrewPublisher() t.Run("generated formula contains correct Ruby class structure", func(t *testing.T) { @@ -599,16 +535,12 @@ func TestHomebrewPublisher_Integration_FormulaGeneration_Good(t *testing.T) { // --- Scoop Publisher Integration Tests --- -func TestScoopPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_ScoopPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewScoopPublisher() t.Run("dry run generates manifest without writing files", func(t *testing.T) { tmpDir := t.TempDir() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.5.0", ProjectDir: tmpDir, @@ -626,15 +558,11 @@ func TestScoopPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/myapp", projectName: "myapp"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Scoop Publish") assert.Contains(t, output, "Package: myapp") @@ -645,7 +573,7 @@ func TestScoopPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "Would commit to bucket: test-org/scoop-bucket") // Verify no files created - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries) }) @@ -653,16 +581,12 @@ func TestScoopPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { // --- AUR Publisher Integration Tests --- -func TestAURPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_AURPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewAURPublisher() t.Run("dry run generates PKGBUILD and SRCINFO without writing files", func(t *testing.T) { tmpDir := t.TempDir() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v2.0.0", ProjectDir: tmpDir, @@ -680,15 +604,11 @@ func TestAURPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/myapp", projectName: "myapp"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: AUR Publish") assert.Contains(t, output, "Package: myapp-bin") @@ -702,7 +622,7 @@ func TestAURPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "Would push to AUR:") // Verify no files created - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries) }) @@ -710,16 +630,12 @@ func TestAURPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { // --- Chocolatey Publisher Integration Tests --- -func TestChocolateyPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_ChocolateyPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewChocolateyPublisher() t.Run("dry run generates nuspec and install script without side effects", func(t *testing.T) { tmpDir := t.TempDir() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: tmpDir, @@ -737,15 +653,11 @@ func TestChocolateyPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) } relCfg := &mockReleaseConfig{repository: "owner/my-cli-tool", projectName: "my-cli-tool"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Chocolatey Publish") assert.Contains(t, output, "Package: my-cli-tool") @@ -757,7 +669,7 @@ func TestChocolateyPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) assert.Contains(t, output, "Would generate package files only") // Verify no files created - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries) }) @@ -765,16 +677,12 @@ func TestChocolateyPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) // --- npm Publisher Integration Tests --- -func TestNpmPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_NpmPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { p := NewNpmPublisher() t.Run("dry run generates package.json without writing files or publishing", func(t *testing.T) { tmpDir := t.TempDir() - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v3.0.0", ProjectDir: tmpDir, @@ -789,15 +697,11 @@ func TestNpmPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/my-cli", projectName: "my-cli"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: npm Publish") assert.Contains(t, output, "Package: @test-org/my-cli") @@ -809,7 +713,7 @@ func TestNpmPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "Would run: npm publish --access public") // Verify no files created - entries, err := os.ReadDir(tmpDir) + entries, err := ax.ReadDir(tmpDir) require.NoError(t, err) assert.Empty(t, entries) }) @@ -817,7 +721,7 @@ func TestNpmPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { // --- LinuxKit Publisher Integration Tests --- -func TestLinuxKitPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { +func TestIntegration_LinuxKitPublisherIntegrationDryRunNoSideEffects_Good(t *testing.T) { if err := validateLinuxKitCli(); err != nil { t.Skip("skipping: linuxkit CLI not available") } @@ -828,13 +732,9 @@ func TestLinuxKitPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { tmpDir := t.TempDir() // Create config file - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - require.NoError(t, os.MkdirAll(configDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(configDir, "server.yml"), []byte("kernel:\n image: test\n"), 0644)) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + configDir := ax.Join(tmpDir, ".core", "linuxkit") + require.NoError(t, ax.MkdirAll(configDir, 0o755)) + require.NoError(t, ax.WriteFile(ax.Join(configDir, "server.yml"), []byte("kernel:\n image: test\n"), 0o644)) release := &Release{ Version: "v1.0.0", @@ -850,15 +750,11 @@ func TestLinuxKitPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "test-org/my-os"} - err := p.Publish(context.Background(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.Publish(context.Background(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: LinuxKit Build & Publish") assert.Contains(t, output, "Formats: iso, qcow2, docker") @@ -876,15 +772,14 @@ func TestLinuxKitPublisher_Integration_DryRunNoSideEffects_Good(t *testing.T) { assert.Contains(t, output, "docker load") // Verify no files created in dist - distDir := filepath.Join(tmpDir, "dist") - _, err = os.Stat(distDir) - assert.True(t, os.IsNotExist(err), "dry run should not create dist directory") + distDir := ax.Join(tmpDir, "dist") + assert.False(t, ax.Exists(distDir), "dry run should not create dist directory") }) } // --- Cross-Publisher Integration Tests --- -func TestAllPublishers_Integration_NameUniqueness_Good(t *testing.T) { +func TestIntegration_AllPublishersIntegrationNameUniqueness_Good(t *testing.T) { t.Run("all publishers have unique names", func(t *testing.T) { publishers := []Publisher{ NewGitHubPublisher(), @@ -909,21 +804,12 @@ func TestAllPublishers_Integration_NameUniqueness_Good(t *testing.T) { }) } -func TestAllPublishers_Integration_NilRelCfg_Good(t *testing.T) { +func TestIntegration_AllPublishersIntegrationNilRelCfg_Good(t *testing.T) { t.Run("github handles nil relCfg with git repo", func(t *testing.T) { tmpDir := t.TempDir() - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:niltest/repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "git@github.com:niltest/repo.git") release := &Release{ Version: "v1.0.0", @@ -933,19 +819,16 @@ func TestAllPublishers_Integration_NilRelCfg_Good(t *testing.T) { } pubCfg := PublisherConfig{Type: "github"} - err := NewGitHubPublisher().Publish(context.Background(), release, pubCfg, nil, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = NewGitHubPublisher().Publish(context.Background(), release, pubCfg, nil, true) + }) require.NoError(t, err) - assert.Contains(t, buf.String(), "niltest/repo") + assert.Contains(t, output, "niltest/repo") }) } -func TestBuildChecksumMap_Integration_Good(t *testing.T) { +func TestIntegration_BuildChecksumMapIntegration_Good(t *testing.T) { t.Run("maps all platforms correctly from realistic artifacts", func(t *testing.T) { artifacts := []build.Artifact{ {Path: "/dist/core-v1.0.0-darwin-amd64.tar.gz", Checksum: "da64"}, diff --git a/pkg/release/publishers/linuxkit.go b/pkg/release/publishers/linuxkit.go index a71a446..add478e 100644 --- a/pkg/release/publishers/linuxkit.go +++ b/pkg/release/publishers/linuxkit.go @@ -3,16 +3,14 @@ package publishers import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreerr "dappco.re/go/core/log" ) // LinuxKitConfig holds configuration for the LinuxKit publisher. +// Usage example: declare a value of type publishers.LinuxKitConfig in integrating code. type LinuxKitConfig struct { // Config is the path to the LinuxKit YAML configuration file. Config string `yaml:"config"` @@ -26,19 +24,23 @@ type LinuxKitConfig struct { } // LinuxKitPublisher builds and publishes LinuxKit images. +// Usage example: declare a value of type publishers.LinuxKitPublisher in integrating code. type LinuxKitPublisher struct{} // NewLinuxKitPublisher creates a new LinuxKit publisher. +// Usage example: call publishers.NewLinuxKitPublisher(...) from integrating code. func NewLinuxKitPublisher() *LinuxKitPublisher { return &LinuxKitPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *LinuxKitPublisher) Name() string { return "linuxkit" } // Publish builds LinuxKit images and uploads them to the GitHub release. +// Usage example: call value.Publish(...) from integrating code. func (p *LinuxKitPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { // Validate linuxkit CLI is available if err := validateLinuxKitCli(); err != nil { @@ -79,7 +81,7 @@ func (p *LinuxKitPublisher) Publish(ctx context.Context, release *Release, pubCf // parseConfig extracts LinuxKit-specific configuration. func (p *LinuxKitPublisher) parseConfig(pubCfg PublisherConfig, projectDir string) LinuxKitConfig { cfg := LinuxKitConfig{ - Config: filepath.Join(projectDir, ".core", "linuxkit", "server.yml"), + Config: ax.Join(projectDir, ".core", "linuxkit", "server.yml"), Formats: []string{"iso"}, Platforms: []string{"linux/amd64"}, } @@ -87,10 +89,10 @@ func (p *LinuxKitPublisher) parseConfig(pubCfg PublisherConfig, projectDir strin // Override from extended config if present if ext, ok := pubCfg.Extended.(map[string]any); ok { if configPath, ok := ext["config"].(string); ok && configPath != "" { - if filepath.IsAbs(configPath) { + if ax.IsAbs(configPath) { cfg.Config = configPath } else { - cfg.Config = filepath.Join(projectDir, configPath) + cfg.Config = ax.Join(projectDir, configPath) } } if formats, ok := ext["formats"].([]any); ok && len(formats) > 0 { @@ -116,62 +118,62 @@ func (p *LinuxKitPublisher) parseConfig(pubCfg PublisherConfig, projectDir strin // dryRunPublish shows what would be done without actually building. func (p *LinuxKitPublisher) dryRunPublish(release *Release, cfg LinuxKitConfig, repo string) error { - fmt.Println() - fmt.Println("=== DRY RUN: LinuxKit Build & Publish ===") - fmt.Println() - fmt.Printf("Repository: %s\n", repo) - fmt.Printf("Version: %s\n", release.Version) - fmt.Printf("Config: %s\n", cfg.Config) - fmt.Printf("Formats: %s\n", strings.Join(cfg.Formats, ", ")) - fmt.Printf("Platforms: %s\n", strings.Join(cfg.Platforms, ", ")) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: LinuxKit Build & Publish ===") + publisherPrintln() + publisherPrint("Repository: %s", repo) + publisherPrint("Version: %s", release.Version) + publisherPrint("Config: %s", cfg.Config) + publisherPrint("Formats: %s", core.Join(", ", cfg.Formats...)) + publisherPrint("Platforms: %s", core.Join(", ", cfg.Platforms...)) + publisherPrintln() - outputDir := filepath.Join(release.ProjectDir, "dist", "linuxkit") + outputDir := ax.Join(release.ProjectDir, "dist", "linuxkit") baseName := p.buildBaseName(release.Version) - fmt.Println("Would execute commands:") + publisherPrintln("Would execute commands:") for _, platform := range cfg.Platforms { - parts := strings.Split(platform, "/") + parts := core.Split(platform, "/") arch := "amd64" if len(parts) == 2 { arch = parts[1] } for _, format := range cfg.Formats { - outputName := fmt.Sprintf("%s-%s", baseName, arch) + outputName := core.Sprintf("%s-%s", baseName, arch) args := p.buildLinuxKitArgs(cfg.Config, format, outputName, outputDir, arch) - fmt.Printf(" linuxkit %s\n", strings.Join(args, " ")) + publisherPrint(" linuxkit %s", core.Join(" ", args...)) } } - fmt.Println() + publisherPrintln() - fmt.Println("Would upload artifacts to release:") + publisherPrintln("Would upload artifacts to release:") for _, platform := range cfg.Platforms { - parts := strings.Split(platform, "/") + parts := core.Split(platform, "/") arch := "amd64" if len(parts) == 2 { arch = parts[1] } for _, format := range cfg.Formats { - outputName := fmt.Sprintf("%s-%s", baseName, arch) + outputName := core.Sprintf("%s-%s", baseName, arch) artifactPath := p.getArtifactPath(outputDir, outputName, format) - fmt.Printf(" - %s\n", filepath.Base(artifactPath)) + publisherPrint(" - %s", ax.Base(artifactPath)) if format == "docker" { - fmt.Printf(" Usage: docker load < %s\n", filepath.Base(artifactPath)) + publisherPrint(" Usage: docker load < %s", ax.Base(artifactPath)) } } } - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } // executePublish builds LinuxKit images and uploads them. func (p *LinuxKitPublisher) executePublish(ctx context.Context, release *Release, cfg LinuxKitConfig, repo string) error { - outputDir := filepath.Join(release.ProjectDir, "dist", "linuxkit") + outputDir := ax.Join(release.ProjectDir, "dist", "linuxkit") // Create output directory if err := release.FS.EnsureDir(outputDir); err != nil { @@ -183,24 +185,19 @@ func (p *LinuxKitPublisher) executePublish(ctx context.Context, release *Release // Build for each platform and format for _, platform := range cfg.Platforms { - parts := strings.Split(platform, "/") + parts := core.Split(platform, "/") arch := "amd64" if len(parts) == 2 { arch = parts[1] } for _, format := range cfg.Formats { - outputName := fmt.Sprintf("%s-%s", baseName, arch) + outputName := core.Sprintf("%s-%s", baseName, arch) // Build the image args := p.buildLinuxKitArgs(cfg.Config, format, outputName, outputDir, arch) - cmd := exec.CommandContext(ctx, "linuxkit", args...) - cmd.Dir = release.ProjectDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - fmt.Printf("Building LinuxKit image: %s (%s)\n", outputName, format) - if err := cmd.Run(); err != nil { + publisherPrint("Building LinuxKit image: %s (%s)", outputName, format) + if err := publisherRun(ctx, release.ProjectDir, nil, "linuxkit", args...); err != nil { return coreerr.E("linuxkit.Publish", "build failed for "+platform+"/"+format, err) } @@ -217,12 +214,12 @@ func (p *LinuxKitPublisher) executePublish(ctx context.Context, release *Release } if err := UploadArtifact(ctx, repo, release.Version, artifactPath); err != nil { - return coreerr.E("linuxkit.Publish", "failed to upload "+filepath.Base(artifactPath), err) + return coreerr.E("linuxkit.Publish", "failed to upload "+ax.Base(artifactPath), err) } // Print helpful usage info for docker format - if strings.HasSuffix(artifactPath, ".docker.tar") { - fmt.Printf(" Load with: docker load < %s\n", filepath.Base(artifactPath)) + if core.HasSuffix(artifactPath, ".docker.tar") { + publisherPrint(" Load with: docker load < %s", ax.Base(artifactPath)) } } @@ -232,8 +229,8 @@ func (p *LinuxKitPublisher) executePublish(ctx context.Context, release *Release // buildBaseName creates the base name for output files. func (p *LinuxKitPublisher) buildBaseName(version string) string { // Strip leading 'v' if present for cleaner filenames - name := strings.TrimPrefix(version, "v") - return fmt.Sprintf("linuxkit-%s", name) + name := core.TrimPrefix(version, "v") + return core.Sprintf("linuxkit-%s", name) } // buildLinuxKitArgs builds the arguments for linuxkit build command. @@ -263,7 +260,7 @@ func (p *LinuxKitPublisher) buildLinuxKitArgs(configPath, format, outputName, ou // getArtifactPath returns the expected path of the built artifact. func (p *LinuxKitPublisher) getArtifactPath(outputDir, outputName, format string) string { ext := p.getFormatExtension(format) - return filepath.Join(outputDir, outputName+ext) + return ax.Join(outputDir, outputName+ext) } // getFormatExtension returns the file extension for a LinuxKit output format. @@ -297,9 +294,8 @@ func (p *LinuxKitPublisher) getFormatExtension(format string) string { // validateLinuxKitCli checks if the linuxkit CLI is available. func validateLinuxKitCli() error { - cmd := exec.Command("linuxkit", "version") - if err := cmd.Run(); err != nil { - return coreerr.E("linuxkit.validateLinuxKitCli", "linuxkit CLI not found. Install it from https://github.com/linuxkit/linuxkit", nil) + if _, err := ax.LookPath("linuxkit"); err != nil { + return coreerr.E("linuxkit.validateLinuxKitCli", "linuxkit CLI not found. Install it from https://github.com/linuxkit/linuxkit", err) } return nil } diff --git a/pkg/release/publishers/linuxkit_test.go b/pkg/release/publishers/linuxkit_test.go index 4fd505a..f714c05 100644 --- a/pkg/release/publishers/linuxkit_test.go +++ b/pkg/release/publishers/linuxkit_test.go @@ -1,26 +1,23 @@ package publishers import ( - "bytes" "context" - "os" - "os/exec" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestLinuxKitPublisher_Name_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherName_Good(t *testing.T) { t.Run("returns linuxkit", func(t *testing.T) { p := NewLinuxKitPublisher() assert.Equal(t, "linuxkit", p.Name()) }) } -func TestLinuxKitPublisher_ParseConfig_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherParseConfig_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -61,7 +58,7 @@ func TestLinuxKitPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestLinuxKitPublisher_BuildLinuxKitArgs_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherBuildLinuxKitArgs_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("builds basic args for amd64", func(t *testing.T) { @@ -88,7 +85,7 @@ func TestLinuxKitPublisher_BuildLinuxKitArgs_Good(t *testing.T) { }) } -func TestLinuxKitPublisher_BuildBaseName_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherBuildBaseName_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("strips v prefix", func(t *testing.T) { @@ -102,7 +99,7 @@ func TestLinuxKitPublisher_BuildBaseName_Good(t *testing.T) { }) } -func TestLinuxKitPublisher_GetArtifactPath_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherGetArtifactPath_Good(t *testing.T) { p := NewLinuxKitPublisher() tests := []struct { @@ -157,7 +154,7 @@ func TestLinuxKitPublisher_GetArtifactPath_Good(t *testing.T) { } } -func TestLinuxKitPublisher_GetFormatExtension_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherGetFormatExtension_Good(t *testing.T) { p := NewLinuxKitPublisher() tests := []struct { @@ -182,7 +179,7 @@ func TestLinuxKitPublisher_GetFormatExtension_Good(t *testing.T) { } } -func TestLinuxKitPublisher_Publish_Bad(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherPublish_Bad(t *testing.T) { p := NewLinuxKitPublisher() t.Run("fails when config file not found with linuxkit installed", func(t *testing.T) { @@ -232,13 +229,11 @@ func TestLinuxKitPublisher_Publish_Bad(t *testing.T) { } // Create temp directory that is NOT a git repo - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Create a config file - configPath := filepath.Join(tmpDir, "config.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0644) + configPath := ax.Join(tmpDir, "config.yml") + err := ax.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0o644) require.NoError(t, err) release := &Release{ @@ -260,7 +255,7 @@ func TestLinuxKitPublisher_Publish_Bad(t *testing.T) { }) } -func TestValidateLinuxKitCli_Good(t *testing.T) { +func TestLinuxKit_ValidateLinuxKitCli_Good(t *testing.T) { t.Run("returns expected error when linuxkit not installed", func(t *testing.T) { err := validateLinuxKitCli() if err != nil { @@ -271,7 +266,7 @@ func TestValidateLinuxKitCli_Good(t *testing.T) { }) } -func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherPublishWithCLI_Good(t *testing.T) { // These tests run only when linuxkit CLI is available if err := validateLinuxKitCli(); err != nil { t.Skip("skipping test: linuxkit CLI not available") @@ -280,23 +275,17 @@ func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("succeeds with dry run and valid config", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Create config directory and file - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - err = os.MkdirAll(configDir, 0755) + configDir := ax.Join(tmpDir, ".core", "linuxkit") + err := ax.MkdirAll(configDir, 0o755) require.NoError(t, err) - configPath := filepath.Join(configDir, "server.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: linuxkit/kernel:5.10\n"), 0644) + configPath := ax.Join(configDir, "server.yml") + err = ax.WriteFile(configPath, []byte("kernel:\n image: linuxkit/kernel:5.10\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: tmpDir, @@ -305,22 +294,15 @@ func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "linuxkit"} relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: LinuxKit Build & Publish") }) t.Run("fails with missing config file", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() release := &Release{ Version: "v1.0.0", @@ -330,28 +312,22 @@ func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "linuxkit"} relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, false) + err := p.Publish(context.TODO(), release, pubCfg, relCfg, false) assert.Error(t, err) assert.Contains(t, err.Error(), "config file not found") }) t.Run("uses relCfg repository", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - err = os.MkdirAll(configDir, 0755) + configDir := ax.Join(tmpDir, ".core", "linuxkit") + err := ax.MkdirAll(configDir, 0o755) require.NoError(t, err) - configPath := filepath.Join(configDir, "server.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0644) + configPath := ax.Join(configDir, "server.yml") + err = ax.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: tmpDir, @@ -360,44 +336,28 @@ func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "linuxkit"} relCfg := &mockReleaseConfig{repository: "custom-owner/custom-repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "custom-owner/custom-repo") }) t.Run("detects repository when not provided", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Create config file - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - err = os.MkdirAll(configDir, 0755) + configDir := ax.Join(tmpDir, ".core", "linuxkit") + err := ax.MkdirAll(configDir, 0o755) require.NoError(t, err) - configPath := filepath.Join(configDir, "server.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0644) + configPath := ax.Join(configDir, "server.yml") + err = ax.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0o644) require.NoError(t, err) // Initialize git repo - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:detected-owner/detected-repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "git@github.com:detected-owner/detected-repo.git") release := &Release{ Version: "v1.0.0", @@ -407,20 +367,15 @@ func TestLinuxKitPublisher_Publish_WithCLI_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "linuxkit"} relCfg := &mockReleaseConfig{repository: ""} // Empty to trigger detection - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "detected-owner/detected-repo") }) } -func TestLinuxKitPublisher_Publish_NilRelCfg_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherPublishNilRelCfg_Good(t *testing.T) { if err := validateLinuxKitCli(); err != nil { t.Skip("skipping test: linuxkit CLI not available") } @@ -428,31 +383,20 @@ func TestLinuxKitPublisher_Publish_NilRelCfg_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("handles nil relCfg by detecting repo", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() // Create config file - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - err = os.MkdirAll(configDir, 0755) + configDir := ax.Join(tmpDir, ".core", "linuxkit") + err := ax.MkdirAll(configDir, 0o755) require.NoError(t, err) - configPath := filepath.Join(configDir, "server.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0644) + configPath := ax.Join(configDir, "server.yml") + err = ax.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0o644) require.NoError(t, err) // Initialize git repo - cmd := exec.Command("git", "init") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:nil-owner/nil-repo.git") - cmd.Dir = tmpDir - require.NoError(t, cmd.Run()) - - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w + runPublisherCommand(t, tmpDir, "git", "init") + runPublisherCommand(t, tmpDir, "git", "remote", "add", "origin", "git@github.com:nil-owner/nil-repo.git") release := &Release{ Version: "v1.0.0", @@ -461,15 +405,10 @@ func TestLinuxKitPublisher_Publish_NilRelCfg_Good(t *testing.T) { } pubCfg := PublisherConfig{Type: "linuxkit"} - err = p.Publish(context.TODO(), release, pubCfg, nil, true) // nil relCfg - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, nil, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "nil-owner/nil-repo") }) } @@ -488,14 +427,10 @@ func (m *mockReleaseConfig) GetProjectName() string { return m.projectName } -func TestLinuxKitPublisher_DryRunPublish_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherDryRunPublish_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: "/project", @@ -507,15 +442,11 @@ func TestLinuxKitPublisher_DryRunPublish_Good(t *testing.T) { Platforms: []string{"linux/amd64", "linux/arm64"}, } - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: LinuxKit Build & Publish") assert.Contains(t, output, "Repository: owner/repo") @@ -534,10 +465,6 @@ func TestLinuxKitPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows docker format usage hint", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: "/project", @@ -549,25 +476,17 @@ func TestLinuxKitPublisher_DryRunPublish_Good(t *testing.T) { Platforms: []string{"linux/amd64"}, } - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "linuxkit-1.0.0-amd64.docker.tar") assert.Contains(t, output, "Usage: docker load <") }) t.Run("handles single platform and format", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v2.0.0", ProjectDir: "/project", @@ -579,22 +498,18 @@ func TestLinuxKitPublisher_DryRunPublish_Good(t *testing.T) { Platforms: []string{"linux/amd64"}, } - err := p.dryRunPublish(release, cfg, "owner/repo") - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(release, cfg, "owner/repo") + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "linuxkit-2.0.0-amd64.iso") assert.NotContains(t, output, "arm64") }) } -func TestLinuxKitPublisher_GetFormatExtension_AllFormats_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherGetFormatExtensionAllFormats_Good(t *testing.T) { p := NewLinuxKitPublisher() tests := []struct { @@ -628,7 +543,7 @@ func TestLinuxKitPublisher_GetFormatExtension_AllFormats_Good(t *testing.T) { } } -func TestLinuxKitPublisher_BuildLinuxKitArgs_AllArchitectures_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherBuildLinuxKitArgsAllArchitectures_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("amd64 does not include arch flag", func(t *testing.T) { @@ -660,7 +575,7 @@ func TestLinuxKitPublisher_BuildLinuxKitArgs_AllArchitectures_Good(t *testing.T) }) } -func TestLinuxKitPublisher_ParseConfig_EdgeCases_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherParseConfigEdgeCases_Good(t *testing.T) { p := NewLinuxKitPublisher() t.Run("handles nil extended config", func(t *testing.T) { @@ -716,7 +631,7 @@ func TestLinuxKitPublisher_ParseConfig_EdgeCases_Good(t *testing.T) { }) } -func TestLinuxKitPublisher_BuildBaseName_EdgeCases_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherBuildBaseNameEdgeCases_Good(t *testing.T) { p := NewLinuxKitPublisher() tests := []struct { @@ -740,7 +655,7 @@ func TestLinuxKitPublisher_BuildBaseName_EdgeCases_Good(t *testing.T) { } } -func TestLinuxKitPublisher_GetArtifactPath_AllFormats_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherGetArtifactPathAllFormats_Good(t *testing.T) { p := NewLinuxKitPublisher() tests := []struct { @@ -802,7 +717,7 @@ func TestLinuxKitPublisher_GetArtifactPath_AllFormats_Good(t *testing.T) { } } -func TestLinuxKitPublisher_Publish_NilFS_Bad(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherPublishNilFS_Bad(t *testing.T) { if err := validateLinuxKitCli(); err != nil { t.Skip("skipping test: linuxkit CLI not available") } @@ -824,7 +739,7 @@ func TestLinuxKitPublisher_Publish_NilFS_Bad(t *testing.T) { }) } -func TestLinuxKitPublisher_Publish_DryRun_Good(t *testing.T) { +func TestLinuxKit_LinuxKitPublisherPublishDryRun_Good(t *testing.T) { if testing.Short() { t.Skip("skipping integration test in short mode") } @@ -838,22 +753,15 @@ func TestLinuxKitPublisher_Publish_DryRun_Good(t *testing.T) { t.Run("dry run succeeds with valid config file", func(t *testing.T) { // Create temp directory with config file - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() - - configDir := filepath.Join(tmpDir, ".core", "linuxkit") - err = os.MkdirAll(configDir, 0755) + tmpDir := t.TempDir() + configDir := ax.Join(tmpDir, ".core", "linuxkit") + err := ax.MkdirAll(configDir, 0o755) require.NoError(t, err) - configPath := filepath.Join(configDir, "server.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: linuxkit/kernel:5.10\n"), 0644) + configPath := ax.Join(configDir, "server.yml") + err = ax.WriteFile(configPath, []byte("kernel:\n image: linuxkit/kernel:5.10\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: tmpDir, @@ -862,31 +770,20 @@ func TestLinuxKitPublisher_Publish_DryRun_Good(t *testing.T) { pubCfg := PublisherConfig{Type: "linuxkit"} relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: LinuxKit Build & Publish") }) t.Run("dry run uses custom config path", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() - customConfigPath := filepath.Join(tmpDir, "custom-config.yml") - err = os.WriteFile(customConfigPath, []byte("kernel:\n image: custom\n"), 0644) + customConfigPath := ax.Join(tmpDir, "custom-config.yml") + err := ax.WriteFile(customConfigPath, []byte("kernel:\n image: custom\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v1.0.0", ProjectDir: tmpDir, @@ -900,31 +797,20 @@ func TestLinuxKitPublisher_Publish_DryRun_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "custom-config.yml") }) t.Run("dry run with multiple formats and platforms", func(t *testing.T) { - tmpDir, err := os.MkdirTemp("", "linuxkit-test") - require.NoError(t, err) - defer func() { _ = os.RemoveAll(tmpDir) }() + tmpDir := t.TempDir() - configPath := filepath.Join(tmpDir, "config.yml") - err = os.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0644) + configPath := ax.Join(tmpDir, "config.yml") + err := ax.WriteFile(configPath, []byte("kernel:\n image: test\n"), 0o644) require.NoError(t, err) - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - release := &Release{ Version: "v2.0.0", ProjectDir: tmpDir, @@ -940,15 +826,10 @@ func TestLinuxKitPublisher_Publish_DryRun_Good(t *testing.T) { } relCfg := &mockReleaseConfig{repository: "owner/repo"} - err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + output := capturePublisherOutput(t, func() { + err = p.Publish(context.TODO(), release, pubCfg, relCfg, true) + }) require.NoError(t, err) - output := buf.String() // Check all format/platform combinations are listed assert.Contains(t, output, "linuxkit-2.0.0-amd64.iso") diff --git a/pkg/release/publishers/npm.go b/pkg/release/publishers/npm.go index b54c497..e617869 100644 --- a/pkg/release/publishers/npm.go +++ b/pkg/release/publishers/npm.go @@ -5,13 +5,10 @@ import ( "bytes" "context" "embed" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" "text/template" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) @@ -20,6 +17,7 @@ import ( var npmTemplates embed.FS // NpmConfig holds npm-specific configuration. +// Usage example: declare a value of type publishers.NpmConfig in integrating code. type NpmConfig struct { // Package is the npm package name (e.g., "@host-uk/core"). Package string @@ -28,20 +26,24 @@ type NpmConfig struct { } // NpmPublisher publishes releases to npm using the binary wrapper pattern. +// Usage example: declare a value of type publishers.NpmPublisher in integrating code. type NpmPublisher struct{} // NewNpmPublisher creates a new npm publisher. +// Usage example: call publishers.NewNpmPublisher(...) from integrating code. func NewNpmPublisher() *NpmPublisher { return &NpmPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *NpmPublisher) Name() string { return "npm" } // Publish publishes the release to npm. // It generates a binary wrapper package that downloads the correct platform binary on postinstall. +// Usage example: call value.Publish(...) from integrating code. func (p *NpmPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { // Parse npm config npmCfg := p.parseConfig(pubCfg, relCfg) @@ -71,18 +73,18 @@ func (p *NpmPublisher) Publish(ctx context.Context, release *Release, pubCfg Pub } if projectName == "" { // Try to infer from package name - parts := strings.Split(npmCfg.Package, "/") + parts := core.Split(npmCfg.Package, "/") projectName = parts[len(parts)-1] } // Strip leading 'v' from version for npm - version := strings.TrimPrefix(release.Version, "v") + version := core.TrimPrefix(release.Version, "v") // Template data data := npmTemplateData{ Package: npmCfg.Package, Version: version, - Description: fmt.Sprintf("%s CLI", projectName), + Description: core.Sprintf("%s CLI", projectName), License: "MIT", Repository: repo, BinaryName: projectName, @@ -131,30 +133,30 @@ type npmTemplateData struct { // dryRunPublish shows what would be done without actually publishing. func (p *NpmPublisher) dryRunPublish(m coreio.Medium, data npmTemplateData) error { - fmt.Println() - fmt.Println("=== DRY RUN: npm Publish ===") - fmt.Println() - fmt.Printf("Package: %s\n", data.Package) - fmt.Printf("Version: %s\n", data.Version) - fmt.Printf("Access: %s\n", data.Access) - fmt.Printf("Repository: %s\n", data.Repository) - fmt.Printf("Binary: %s\n", data.BinaryName) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: npm Publish ===") + publisherPrintln() + publisherPrint("Package: %s", data.Package) + publisherPrint("Version: %s", data.Version) + publisherPrint("Access: %s", data.Access) + publisherPrint("Repository: %s", data.Repository) + publisherPrint("Binary: %s", data.BinaryName) + publisherPrintln() // Generate and show package.json pkgJSON, err := p.renderTemplate(m, "templates/npm/package.json.tmpl", data) if err != nil { return coreerr.E("npm.dryRunPublish", "failed to render template", err) } - fmt.Println("Generated package.json:") - fmt.Println("---") - fmt.Println(pkgJSON) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated package.json:") + publisherPrintln("---") + publisherPrintln(pkgJSON) + publisherPrintln("---") + publisherPrintln() - fmt.Println("Would run: npm publish --access", data.Access) - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln("Would run: npm publish --access", data.Access) + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -162,19 +164,20 @@ func (p *NpmPublisher) dryRunPublish(m coreio.Medium, data npmTemplateData) erro // executePublish actually creates and publishes the npm package. func (p *NpmPublisher) executePublish(ctx context.Context, m coreio.Medium, data npmTemplateData, cfg *NpmConfig) error { // Check for NPM_TOKEN - if os.Getenv("NPM_TOKEN") == "" { + npmToken := core.Env("NPM_TOKEN") + if npmToken == "" { return coreerr.E("npm.Publish", "NPM_TOKEN environment variable is required", nil) } // Create temp directory for package - tmpDir, err := os.MkdirTemp("", "npm-publish-*") + tmpDir, err := ax.TempDir("npm-publish-*") if err != nil { return coreerr.E("npm.Publish", "failed to create temp directory", err) } - defer func() { _ = coreio.Local.DeleteAll(tmpDir) }() + defer func() { _ = ax.RemoveAll(tmpDir) }() // Create bin directory - binDir := filepath.Join(tmpDir, "bin") + binDir := ax.Join(tmpDir, "bin") if err := coreio.Local.EnsureDir(binDir); err != nil { return coreerr.E("npm.Publish", "failed to create bin directory", err) } @@ -184,7 +187,7 @@ func (p *NpmPublisher) executePublish(ctx context.Context, m coreio.Medium, data if err != nil { return coreerr.E("npm.Publish", "failed to render package.json", err) } - if err := coreio.Local.Write(filepath.Join(tmpDir, "package.json"), pkgJSON); err != nil { + if err := coreio.Local.Write(ax.Join(tmpDir, "package.json"), pkgJSON); err != nil { return coreerr.E("npm.Publish", "failed to write package.json", err) } @@ -193,7 +196,7 @@ func (p *NpmPublisher) executePublish(ctx context.Context, m coreio.Medium, data if err != nil { return coreerr.E("npm.Publish", "failed to render install.js", err) } - if err := coreio.Local.Write(filepath.Join(tmpDir, "install.js"), installJS); err != nil { + if err := coreio.Local.Write(ax.Join(tmpDir, "install.js"), installJS); err != nil { return coreerr.E("npm.Publish", "failed to write install.js", err) } @@ -202,30 +205,24 @@ func (p *NpmPublisher) executePublish(ctx context.Context, m coreio.Medium, data if err != nil { return coreerr.E("npm.Publish", "failed to render run.js", err) } - if err := coreio.Local.Write(filepath.Join(binDir, "run.js"), runJS); err != nil { + if err := coreio.Local.Write(ax.Join(binDir, "run.js"), runJS); err != nil { return coreerr.E("npm.Publish", "failed to write run.js", err) } // Create .npmrc with token npmrc := "//registry.npmjs.org/:_authToken=${NPM_TOKEN}\n" - if err := coreio.Local.Write(filepath.Join(tmpDir, ".npmrc"), npmrc); err != nil { + if err := coreio.Local.Write(ax.Join(tmpDir, ".npmrc"), npmrc); err != nil { return coreerr.E("npm.Publish", "failed to write .npmrc", err) } // Run npm publish - cmd := exec.CommandContext(ctx, "npm", "publish", "--access", data.Access) - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - cmd.Env = append(os.Environ(), "NPM_TOKEN="+os.Getenv("NPM_TOKEN")) - - fmt.Printf("Publishing %s@%s to npm...\n", data.Package, data.Version) - if err := cmd.Run(); err != nil { + publisherPrint("Publishing %s@%s to npm...", data.Package, data.Version) + if err := publisherRun(ctx, tmpDir, []string{"NPM_TOKEN=" + npmToken}, "npm", "publish", "--access", data.Access); err != nil { return coreerr.E("npm.Publish", "npm publish failed", err) } - fmt.Printf("Published %s@%s to npm\n", data.Package, data.Version) - fmt.Printf(" https://www.npmjs.com/package/%s\n", data.Package) + publisherPrint("Published %s@%s to npm", data.Package, data.Version) + publisherPrint(" https://www.npmjs.com/package/%s", data.Package) return nil } @@ -236,7 +233,7 @@ func (p *NpmPublisher) renderTemplate(m coreio.Medium, name string, data npmTemp var err error // Try custom template from medium - customPath := filepath.Join(".core", name) + customPath := ax.Join(".core", name) if m != nil && m.IsFile(customPath) { customContent, err := m.Read(customPath) if err == nil { @@ -252,7 +249,7 @@ func (p *NpmPublisher) renderTemplate(m coreio.Medium, name string, data npmTemp } } - tmpl, err := template.New(filepath.Base(name)).Parse(string(content)) + tmpl, err := template.New(ax.Base(name)).Parse(string(content)) if err != nil { return "", coreerr.E("npm.renderTemplate", "failed to parse template "+name, err) } diff --git a/pkg/release/publishers/npm_test.go b/pkg/release/publishers/npm_test.go index 919695c..3767947 100644 --- a/pkg/release/publishers/npm_test.go +++ b/pkg/release/publishers/npm_test.go @@ -1,9 +1,7 @@ package publishers import ( - "bytes" "context" - "os" "testing" "dappco.re/go/core/io" @@ -12,14 +10,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestNpmPublisher_Name_Good(t *testing.T) { +func TestNpm_NpmPublisherName_Good(t *testing.T) { t.Run("returns npm", func(t *testing.T) { p := NewNpmPublisher() assert.Equal(t, "npm", p.Name()) }) } -func TestNpmPublisher_ParseConfig_Good(t *testing.T) { +func TestNpm_NpmPublisherParseConfig_Good(t *testing.T) { p := NewNpmPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -88,7 +86,7 @@ func TestNpmPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestNpmPublisher_RenderTemplate_Good(t *testing.T) { +func TestNpm_NpmPublisherRenderTemplate_Good(t *testing.T) { p := NewNpmPublisher() t.Run("renders package.json template with data", func(t *testing.T) { @@ -134,7 +132,7 @@ func TestNpmPublisher_RenderTemplate_Good(t *testing.T) { }) } -func TestNpmPublisher_RenderTemplate_Bad(t *testing.T) { +func TestNpm_NpmPublisherRenderTemplate_Bad(t *testing.T) { p := NewNpmPublisher() t.Run("returns error for non-existent template", func(t *testing.T) { @@ -145,14 +143,10 @@ func TestNpmPublisher_RenderTemplate_Bad(t *testing.T) { }) } -func TestNpmPublisher_DryRunPublish_Good(t *testing.T) { +func TestNpm_NpmPublisherDryRunPublish_Good(t *testing.T) { p := NewNpmPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := npmTemplateData{ Package: "@myorg/mycli", Version: "1.0.0", @@ -161,15 +155,11 @@ func TestNpmPublisher_DryRunPublish_Good(t *testing.T) { BinaryName: "mycli", Description: "My CLI", } - err := p.dryRunPublish(io.Local, data) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: npm Publish") assert.Contains(t, output, "Package: @myorg/mycli") @@ -183,10 +173,6 @@ func TestNpmPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows restricted access correctly", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := npmTemplateData{ Package: "@private/cli", Version: "2.0.0", @@ -195,22 +181,18 @@ func TestNpmPublisher_DryRunPublish_Good(t *testing.T) { BinaryName: "cli", } - err := p.dryRunPublish(io.Local, data) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Access: restricted") assert.Contains(t, output, "Would run: npm publish --access restricted") }) } -func TestNpmPublisher_Publish_Bad(t *testing.T) { +func TestNpm_NpmPublisherPublish_Bad(t *testing.T) { p := NewNpmPublisher() t.Run("fails when package name not configured", func(t *testing.T) { @@ -228,14 +210,7 @@ func TestNpmPublisher_Publish_Bad(t *testing.T) { }) t.Run("fails when NPM_TOKEN not set in non-dry-run", func(t *testing.T) { - // Ensure NPM_TOKEN is not set - oldToken := os.Getenv("NPM_TOKEN") - _ = os.Unsetenv("NPM_TOKEN") - defer func() { - if oldToken != "" { - _ = os.Setenv("NPM_TOKEN", oldToken) - } - }() + t.Setenv("NPM_TOKEN", "") release := &Release{ Version: "v1.0.0", @@ -256,7 +231,7 @@ func TestNpmPublisher_Publish_Bad(t *testing.T) { }) } -func TestNpmConfig_Defaults_Good(t *testing.T) { +func TestNpm_NpmConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewNpmPublisher() pubCfg := PublisherConfig{Type: "npm"} @@ -269,7 +244,7 @@ func TestNpmConfig_Defaults_Good(t *testing.T) { }) } -func TestNpmTemplateData_Good(t *testing.T) { +func TestNpm_NpmTemplateData_Good(t *testing.T) { t.Run("struct has all expected fields", func(t *testing.T) { data := npmTemplateData{ Package: "@myorg/package", diff --git a/pkg/release/publishers/output.go b/pkg/release/publishers/output.go new file mode 100644 index 0000000..b043571 --- /dev/null +++ b/pkg/release/publishers/output.go @@ -0,0 +1,38 @@ +package publishers + +import ( + "context" + "io" + + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" +) + +var publisherStdout io.Writer +var publisherStderr io.Writer + +func publisherPrint(format string, args ...any) { + core.Print(publisherStdout, format, args...) +} + +func publisherPrintln(args ...any) { + if len(args) == 0 { + publisherPrint("") + return + } + + parts := make([]string, 0, len(args)) + for _, arg := range args { + parts = append(parts, core.Sprintf("%v", arg)) + } + + publisherPrint("%s", core.Join(" ", parts...)) +} + +func publisherRun(ctx context.Context, dir string, env []string, command string, args ...string) error { + output, err := ax.CombinedOutput(ctx, dir, env, command, args...) + if output != "" { + publisherPrint("%s", output) + } + return err +} diff --git a/pkg/release/publishers/publisher.go b/pkg/release/publishers/publisher.go index 4da5bcd..724b5d6 100644 --- a/pkg/release/publishers/publisher.go +++ b/pkg/release/publishers/publisher.go @@ -9,6 +9,7 @@ import ( ) // Release represents a release to be published. +// Usage example: declare a value of type publishers.Release in integrating code. type Release struct { // Version is the semantic version string (e.g., "v1.2.3"). Version string @@ -23,6 +24,7 @@ type Release struct { } // PublisherConfig holds configuration for a publisher. +// Usage example: declare a value of type publishers.PublisherConfig in integrating code. type PublisherConfig struct { // Type is the publisher type (e.g., "github", "linuxkit", "docker"). Type string @@ -35,12 +37,14 @@ type PublisherConfig struct { } // ReleaseConfig holds release configuration needed by publishers. +// Usage example: declare a value of type publishers.ReleaseConfig in integrating code. type ReleaseConfig interface { GetRepository() string GetProjectName() string } // Publisher defines the interface for release publishers. +// Usage example: declare a value of type publishers.Publisher in integrating code. type Publisher interface { // Name returns the publisher's identifier. Name() string @@ -51,6 +55,7 @@ type Publisher interface { // NewRelease creates a Release from the release package's Release type. // This is a helper to convert between packages. +// Usage example: call publishers.NewRelease(...) from integrating code. func NewRelease(version string, artifacts []build.Artifact, changelog, projectDir string, fs io.Medium) *Release { return &Release{ Version: version, @@ -62,6 +67,7 @@ func NewRelease(version string, artifacts []build.Artifact, changelog, projectDi } // NewPublisherConfig creates a PublisherConfig. +// Usage example: call publishers.NewPublisherConfig(...) from integrating code. func NewPublisherConfig(pubType string, prerelease, draft bool, extended any) PublisherConfig { return PublisherConfig{ Type: pubType, diff --git a/pkg/release/publishers/scoop.go b/pkg/release/publishers/scoop.go index 09437e8..c439613 100644 --- a/pkg/release/publishers/scoop.go +++ b/pkg/release/publishers/scoop.go @@ -5,13 +5,10 @@ import ( "bytes" "context" "embed" - "fmt" - "os" - "os/exec" - "path/filepath" - "strings" "text/template" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" @@ -21,6 +18,7 @@ import ( var scoopTemplates embed.FS // ScoopConfig holds Scoop-specific configuration. +// Usage example: declare a value of type publishers.ScoopConfig in integrating code. type ScoopConfig struct { // Bucket is the Scoop bucket repository (e.g., "host-uk/scoop-bucket"). Bucket string @@ -29,19 +27,23 @@ type ScoopConfig struct { } // ScoopPublisher publishes releases to Scoop. +// Usage example: declare a value of type publishers.ScoopPublisher in integrating code. type ScoopPublisher struct{} // NewScoopPublisher creates a new Scoop publisher. +// Usage example: call publishers.NewScoopPublisher(...) from integrating code. func NewScoopPublisher() *ScoopPublisher { return &ScoopPublisher{} } // Name returns the publisher's identifier. +// Usage example: call value.Name(...) from integrating code. func (p *ScoopPublisher) Name() string { return "scoop" } // Publish publishes the release to Scoop. +// Usage example: call value.Publish(...) from integrating code. func (p *ScoopPublisher) Publish(ctx context.Context, release *Release, pubCfg PublisherConfig, relCfg ReleaseConfig, dryRun bool) error { cfg := p.parseConfig(pubCfg, relCfg) @@ -66,16 +68,16 @@ func (p *ScoopPublisher) Publish(ctx context.Context, release *Release, pubCfg P projectName = relCfg.GetProjectName() } if projectName == "" { - parts := strings.Split(repo, "/") + parts := core.Split(repo, "/") projectName = parts[len(parts)-1] } - version := strings.TrimPrefix(release.Version, "v") + version := core.TrimPrefix(release.Version, "v") checksums := buildChecksumMap(release.Artifacts) data := scoopTemplateData{ PackageName: projectName, - Description: fmt.Sprintf("%s CLI", projectName), + Description: core.Sprintf("%s CLI", projectName), Repository: repo, Version: version, License: "MIT", @@ -122,37 +124,37 @@ func (p *ScoopPublisher) parseConfig(pubCfg PublisherConfig, relCfg ReleaseConfi } func (p *ScoopPublisher) dryRunPublish(m coreio.Medium, data scoopTemplateData, cfg ScoopConfig) error { - fmt.Println() - fmt.Println("=== DRY RUN: Scoop Publish ===") - fmt.Println() - fmt.Printf("Package: %s\n", data.PackageName) - fmt.Printf("Version: %s\n", data.Version) - fmt.Printf("Bucket: %s\n", cfg.Bucket) - fmt.Printf("Repository: %s\n", data.Repository) - fmt.Println() + publisherPrintln() + publisherPrintln("=== DRY RUN: Scoop Publish ===") + publisherPrintln() + publisherPrint("Package: %s", data.PackageName) + publisherPrint("Version: %s", data.Version) + publisherPrint("Bucket: %s", cfg.Bucket) + publisherPrint("Repository: %s", data.Repository) + publisherPrintln() manifest, err := p.renderTemplate(m, "templates/scoop/manifest.json.tmpl", data) if err != nil { return coreerr.E("scoop.dryRunPublish", "failed to render template", err) } - fmt.Println("Generated manifest.json:") - fmt.Println("---") - fmt.Println(manifest) - fmt.Println("---") - fmt.Println() + publisherPrintln("Generated manifest.json:") + publisherPrintln("---") + publisherPrintln(manifest) + publisherPrintln("---") + publisherPrintln() if cfg.Bucket != "" { - fmt.Printf("Would commit to bucket: %s\n", cfg.Bucket) + publisherPrint("Would commit to bucket: %s", cfg.Bucket) } if cfg.Official != nil && cfg.Official.Enabled { output := cfg.Official.Output if output == "" { output = "dist/scoop" } - fmt.Printf("Would write files for official PR to: %s\n", output) + publisherPrint("Would write files for official PR to: %s", output) } - fmt.Println() - fmt.Println("=== END DRY RUN ===") + publisherPrintln() + publisherPrintln("=== END DRY RUN ===") return nil } @@ -167,20 +169,20 @@ func (p *ScoopPublisher) executePublish(ctx context.Context, projectDir string, if cfg.Official != nil && cfg.Official.Enabled { output := cfg.Official.Output if output == "" { - output = filepath.Join(projectDir, "dist", "scoop") - } else if !filepath.IsAbs(output) { - output = filepath.Join(projectDir, output) + output = ax.Join(projectDir, "dist", "scoop") + } else if !ax.IsAbs(output) { + output = ax.Join(projectDir, output) } if err := release.FS.EnsureDir(output); err != nil { return coreerr.E("scoop.Publish", "failed to create output directory", err) } - manifestPath := filepath.Join(output, fmt.Sprintf("%s.json", data.PackageName)) + manifestPath := ax.Join(output, core.Sprintf("%s.json", data.PackageName)) if err := release.FS.Write(manifestPath, manifest); err != nil { return coreerr.E("scoop.Publish", "failed to write manifest", err) } - fmt.Printf("Wrote Scoop manifest for official PR: %s\n", manifestPath) + publisherPrint("Wrote Scoop manifest for official PR: %s", manifestPath) } // If bucket is configured, commit to it @@ -194,56 +196,43 @@ func (p *ScoopPublisher) executePublish(ctx context.Context, projectDir string, } func (p *ScoopPublisher) commitToBucket(ctx context.Context, bucket string, data scoopTemplateData, manifest string) error { - tmpDir, err := os.MkdirTemp("", "scoop-bucket-*") + tmpDir, err := ax.TempDir("scoop-bucket-*") if err != nil { return coreerr.E("scoop.commitToBucket", "failed to create temp directory", err) } - defer func() { _ = coreio.Local.DeleteAll(tmpDir) }() + defer func() { _ = ax.RemoveAll(tmpDir) }() - fmt.Printf("Cloning bucket %s...\n", bucket) - cmd := exec.CommandContext(ctx, "gh", "repo", "clone", bucket, tmpDir, "--", "--depth=1") - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + publisherPrint("Cloning bucket %s...", bucket) + if err := publisherRun(ctx, "", nil, "gh", "repo", "clone", bucket, tmpDir, "--", "--depth=1"); err != nil { return coreerr.E("scoop.commitToBucket", "failed to clone bucket", err) } // Ensure bucket directory exists - bucketDir := filepath.Join(tmpDir, "bucket") + bucketDir := ax.Join(tmpDir, "bucket") if !coreio.Local.IsDir(bucketDir) { bucketDir = tmpDir // Some repos put manifests in root } - manifestPath := filepath.Join(bucketDir, fmt.Sprintf("%s.json", data.PackageName)) + manifestPath := ax.Join(bucketDir, core.Sprintf("%s.json", data.PackageName)) if err := coreio.Local.Write(manifestPath, manifest); err != nil { return coreerr.E("scoop.commitToBucket", "failed to write manifest", err) } - commitMsg := fmt.Sprintf("Update %s to %s", data.PackageName, data.Version) + commitMsg := core.Sprintf("Update %s to %s", data.PackageName, data.Version) - cmd = exec.CommandContext(ctx, "git", "add", ".") - cmd.Dir = tmpDir - if err := cmd.Run(); err != nil { + if err := ax.ExecDir(ctx, tmpDir, "git", "add", "."); err != nil { return coreerr.E("scoop.commitToBucket", "git add failed", err) } - cmd = exec.CommandContext(ctx, "git", "commit", "-m", commitMsg) - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "commit", "-m", commitMsg); err != nil { return coreerr.E("scoop.commitToBucket", "git commit failed", err) } - cmd = exec.CommandContext(ctx, "git", "push") - cmd.Dir = tmpDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - if err := cmd.Run(); err != nil { + if err := publisherRun(ctx, tmpDir, nil, "git", "push"); err != nil { return coreerr.E("scoop.commitToBucket", "git push failed", err) } - fmt.Printf("Updated Scoop bucket: %s\n", bucket) + publisherPrint("Updated Scoop bucket: %s", bucket) return nil } @@ -252,7 +241,7 @@ func (p *ScoopPublisher) renderTemplate(m coreio.Medium, name string, data scoop var err error // Try custom template from medium - customPath := filepath.Join(".core", name) + customPath := ax.Join(".core", name) if m != nil && m.IsFile(customPath) { customContent, err := m.Read(customPath) if err != nil { @@ -269,7 +258,7 @@ func (p *ScoopPublisher) renderTemplate(m coreio.Medium, name string, data scoop } } - tmpl, err := template.New(filepath.Base(name)).Parse(string(content)) + tmpl, err := template.New(ax.Base(name)).Parse(string(content)) if err != nil { return "", coreerr.E("scoop.renderTemplate", "failed to parse template "+name, err) } diff --git a/pkg/release/publishers/scoop_test.go b/pkg/release/publishers/scoop_test.go index abee811..5333832 100644 --- a/pkg/release/publishers/scoop_test.go +++ b/pkg/release/publishers/scoop_test.go @@ -1,9 +1,7 @@ package publishers import ( - "bytes" "context" - "os" "testing" "dappco.re/go/core/io" @@ -12,14 +10,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestScoopPublisher_Name_Good(t *testing.T) { +func TestScoop_ScoopPublisherName_Good(t *testing.T) { t.Run("returns scoop", func(t *testing.T) { p := NewScoopPublisher() assert.Equal(t, "scoop", p.Name()) }) } -func TestScoopPublisher_ParseConfig_Good(t *testing.T) { +func TestScoop_ScoopPublisherParseConfig_Good(t *testing.T) { p := NewScoopPublisher() t.Run("uses defaults when no extended config", func(t *testing.T) { @@ -90,7 +88,7 @@ func TestScoopPublisher_ParseConfig_Good(t *testing.T) { }) } -func TestScoopPublisher_RenderTemplate_Good(t *testing.T) { +func TestScoop_ScoopPublisherRenderTemplate_Good(t *testing.T) { p := NewScoopPublisher() t.Run("renders manifest template with data", func(t *testing.T) { @@ -143,7 +141,7 @@ func TestScoopPublisher_RenderTemplate_Good(t *testing.T) { }) } -func TestScoopPublisher_RenderTemplate_Bad(t *testing.T) { +func TestScoop_ScoopPublisherRenderTemplate_Bad(t *testing.T) { p := NewScoopPublisher() t.Run("returns error for non-existent template", func(t *testing.T) { @@ -154,14 +152,10 @@ func TestScoopPublisher_RenderTemplate_Bad(t *testing.T) { }) } -func TestScoopPublisher_DryRunPublish_Good(t *testing.T) { +func TestScoop_ScoopPublisherDryRunPublish_Good(t *testing.T) { p := NewScoopPublisher() t.Run("outputs expected dry run information", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := scoopTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -173,15 +167,11 @@ func TestScoopPublisher_DryRunPublish_Good(t *testing.T) { Bucket: "owner/scoop-bucket", } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "DRY RUN: Scoop Publish") assert.Contains(t, output, "Package: myapp") @@ -194,10 +184,6 @@ func TestScoopPublisher_DryRunPublish_Good(t *testing.T) { }) t.Run("shows official output path when enabled", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := scoopTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -211,23 +197,15 @@ func TestScoopPublisher_DryRunPublish_Good(t *testing.T) { }, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would write files for official PR to: custom/scoop/path") }) t.Run("uses default official output path when not specified", func(t *testing.T) { - oldStdout := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - data := scoopTemplateData{ PackageName: "myapp", Version: "1.0.0", @@ -240,20 +218,16 @@ func TestScoopPublisher_DryRunPublish_Good(t *testing.T) { }, } - err := p.dryRunPublish(io.Local, data, cfg) - - _ = w.Close() - var buf bytes.Buffer - _, _ = buf.ReadFrom(r) - os.Stdout = oldStdout - + var err error + output := capturePublisherOutput(t, func() { + err = p.dryRunPublish(io.Local, data, cfg) + }) require.NoError(t, err) - output := buf.String() assert.Contains(t, output, "Would write files for official PR to: dist/scoop") }) } -func TestScoopPublisher_Publish_Bad(t *testing.T) { +func TestScoop_ScoopPublisherPublish_Bad(t *testing.T) { p := NewScoopPublisher() t.Run("fails when bucket not configured and not official mode", func(t *testing.T) { @@ -271,7 +245,7 @@ func TestScoopPublisher_Publish_Bad(t *testing.T) { }) } -func TestScoopConfig_Defaults_Good(t *testing.T) { +func TestScoop_ScoopConfigDefaults_Good(t *testing.T) { t.Run("has sensible defaults", func(t *testing.T) { p := NewScoopPublisher() pubCfg := PublisherConfig{Type: "scoop"} @@ -284,7 +258,7 @@ func TestScoopConfig_Defaults_Good(t *testing.T) { }) } -func TestScoopTemplateData_Good(t *testing.T) { +func TestScoop_ScoopTemplateData_Good(t *testing.T) { t.Run("struct has all expected fields", func(t *testing.T) { data := scoopTemplateData{ PackageName: "myapp", diff --git a/pkg/release/publishers/test_helpers_test.go b/pkg/release/publishers/test_helpers_test.go new file mode 100644 index 0000000..7464cbf --- /dev/null +++ b/pkg/release/publishers/test_helpers_test.go @@ -0,0 +1,32 @@ +package publishers + +import ( + "bytes" + "context" + "testing" + + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/require" +) + +func capturePublisherOutput(t *testing.T, fn func()) string { + t.Helper() + + var buf bytes.Buffer + oldStdout := publisherStdout + oldStderr := publisherStderr + publisherStdout = &buf + publisherStderr = &buf + defer func() { + publisherStdout = oldStdout + publisherStderr = oldStderr + }() + + fn() + return buf.String() +} + +func runPublisherCommand(t *testing.T, dir, command string, args ...string) { + t.Helper() + require.NoError(t, ax.ExecDir(context.Background(), dir, command, args...)) +} diff --git a/pkg/release/release.go b/pkg/release/release.go index 603a1df..4a57b62 100644 --- a/pkg/release/release.go +++ b/pkg/release/release.go @@ -5,10 +5,9 @@ package release import ( "context" - "fmt" - "path/filepath" - "strings" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/build/pkg/build/builders" "dappco.re/go/core/build/pkg/release/publishers" @@ -17,6 +16,7 @@ import ( ) // Release represents a release with its version, artifacts, and changelog. +// Usage example: declare a value of type release.Release in integrating code. type Release struct { // Version is the semantic version string (e.g., "v1.2.3"). Version string @@ -33,6 +33,7 @@ type Release struct { // Publish publishes pre-built artifacts from dist/ to configured targets. // Use this after `core build` to separate build and publish concerns. // If dryRun is true, it will show what would be done without actually publishing. +// Usage example: call release.Publish(...) from integrating code. func Publish(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { if cfg == nil { return nil, coreerr.E("release.Publish", "config is nil", nil) @@ -46,7 +47,7 @@ func Publish(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { } // Resolve to absolute path - absProjectDir, err := filepath.Abs(projectDir) + absProjectDir, err := ax.Abs(projectDir) if err != nil { return nil, coreerr.E("release.Publish", "failed to resolve project directory", err) } @@ -61,7 +62,7 @@ func Publish(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { } // Step 2: Find pre-built artifacts in dist/ - distDir := filepath.Join(absProjectDir, "dist") + distDir := ax.Join(absProjectDir, "dist") artifacts, err := findArtifacts(m, distDir) if err != nil { return nil, coreerr.E("release.Publish", "failed to find artifacts", err) @@ -75,7 +76,7 @@ func Publish(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { changelog, err := Generate(absProjectDir, "", version) if err != nil { // Non-fatal: continue with empty changelog - changelog = fmt.Sprintf("Release %s", version) + changelog = core.Sprintf("Release %s", version) } release := &Release{ @@ -126,13 +127,13 @@ func findArtifacts(m io.Medium, distDir string) ([]build.Artifact, error) { } name := entry.Name() - path := filepath.Join(distDir, name) + path := ax.Join(distDir, name) // Include archives and checksums - if strings.HasSuffix(name, ".tar.gz") || - strings.HasSuffix(name, ".zip") || - strings.HasSuffix(name, ".txt") || - strings.HasSuffix(name, ".sig") { + if core.HasSuffix(name, ".tar.gz") || + core.HasSuffix(name, ".zip") || + core.HasSuffix(name, ".txt") || + core.HasSuffix(name, ".sig") { artifacts = append(artifacts, build.Artifact{Path: path}) } } @@ -144,6 +145,7 @@ func findArtifacts(m io.Medium, distDir string) ([]build.Artifact, error) { // generate changelog, and publish to configured targets. // For separated concerns, prefer using `core build` then `core ci` (Publish). // If dryRun is true, it will show what would be done without actually publishing. +// Usage example: call release.Run(...) from integrating code. func Run(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { if cfg == nil { return nil, coreerr.E("release.Run", "config is nil", nil) @@ -157,7 +159,7 @@ func Run(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { } // Resolve to absolute path - absProjectDir, err := filepath.Abs(projectDir) + absProjectDir, err := ax.Abs(projectDir) if err != nil { return nil, coreerr.E("release.Run", "failed to resolve project directory", err) } @@ -175,7 +177,7 @@ func Run(ctx context.Context, cfg *Config, dryRun bool) (*Release, error) { changelog, err := Generate(absProjectDir, "", version) if err != nil { // Non-fatal: continue with empty changelog - changelog = fmt.Sprintf("Release %s", version) + changelog = core.Sprintf("Release %s", version) } // Step 3: Build artifacts @@ -250,11 +252,11 @@ func buildArtifacts(ctx context.Context, fs io.Medium, cfg *Config, projectDir, binaryName = buildCfg.Project.Name } if binaryName == "" { - binaryName = filepath.Base(projectDir) + binaryName = ax.Base(projectDir) } // Determine output directory - outputDir := filepath.Join(projectDir, "dist") + outputDir := ax.Join(projectDir, "dist") // Get builder (detect project type) projectType, err := build.PrimaryType(fs, projectDir) @@ -296,7 +298,7 @@ func buildArtifacts(ctx context.Context, fs io.Medium, cfg *Config, projectDir, } // Write CHECKSUMS.txt - checksumPath := filepath.Join(outputDir, "CHECKSUMS.txt") + checksumPath := ax.Join(outputDir, "CHECKSUMS.txt") if err := build.WriteChecksumFile(fs, checksummedArtifacts, checksumPath); err != nil { return nil, coreerr.E("release.buildArtifacts", "failed to write checksums file", err) } diff --git a/pkg/release/release_test.go b/pkg/release/release_test.go index afa1e64..c31ace8 100644 --- a/pkg/release/release_test.go +++ b/pkg/release/release_test.go @@ -2,26 +2,24 @@ package release import ( "context" - "os" - "os/exec" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/build" "dappco.re/go/core/io" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestFindArtifacts_Good(t *testing.T) { +func TestRelease_FindArtifacts_Good(t *testing.T) { t.Run("finds tar.gz artifacts", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) // Create test artifact files - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-linux-amd64.tar.gz"), []byte("test"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-darwin-arm64.tar.gz"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-linux-amd64.tar.gz"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-darwin-arm64.tar.gz"), []byte("test"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -31,10 +29,10 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("finds zip artifacts", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-windows-amd64.zip"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-windows-amd64.zip"), []byte("test"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -45,10 +43,10 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("finds checksum files", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -59,10 +57,10 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("finds signature files", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz.sig"), []byte("signature"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz.sig"), []byte("signature"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -72,13 +70,13 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("finds mixed artifact types", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-linux.tar.gz"), []byte("test"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-windows.zip"), []byte("test"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.sig"), []byte("sig"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-linux.tar.gz"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-windows.zip"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.sig"), []byte("sig"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -88,12 +86,12 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("ignores non-artifact files", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "README.md"), []byte("readme"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.exe"), []byte("binary"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("artifact"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "README.md"), []byte("readme"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.exe"), []byte("binary"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("artifact"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -104,12 +102,12 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("ignores subdirectories", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.MkdirAll(filepath.Join(distDir, "subdir"), 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.MkdirAll(ax.Join(distDir, "subdir"), 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("artifact"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "subdir", "nested.tar.gz"), []byte("nested"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("artifact"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "subdir", "nested.tar.gz"), []byte("nested"), 0644)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -120,8 +118,8 @@ func TestFindArtifacts_Good(t *testing.T) { t.Run("returns empty slice for empty dist directory", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) artifacts, err := findArtifacts(io.Local, distDir) require.NoError(t, err) @@ -130,10 +128,10 @@ func TestFindArtifacts_Good(t *testing.T) { }) } -func TestFindArtifacts_Bad(t *testing.T) { +func TestRelease_FindArtifacts_Bad(t *testing.T) { t.Run("returns error when dist directory does not exist", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") + distDir := ax.Join(dir, "dist") _, err := findArtifacts(io.Local, distDir) assert.Error(t, err) @@ -141,17 +139,17 @@ func TestFindArtifacts_Bad(t *testing.T) { }) t.Run("returns error when dist directory is unreadable", func(t *testing.T) { - if os.Geteuid() == 0 { + if ax.Geteuid() == 0 { t.Skip("root can read any directory") } dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) // Create a file that looks like dist but will cause ReadDir to fail // by making the directory unreadable - require.NoError(t, os.Chmod(distDir, 0000)) - defer func() { _ = os.Chmod(distDir, 0755) }() + require.NoError(t, ax.Chmod(distDir, 0000)) + defer func() { _ = ax.Chmod(distDir, 0755) }() _, err := findArtifacts(io.Local, distDir) assert.Error(t, err) @@ -159,7 +157,7 @@ func TestFindArtifacts_Bad(t *testing.T) { }) } -func TestGetBuilder_Good(t *testing.T) { +func TestRelease_GetBuilder_Good(t *testing.T) { t.Run("returns Go builder for go project type", func(t *testing.T) { builder, err := getBuilder(build.ProjectTypeGo) require.NoError(t, err) @@ -175,7 +173,7 @@ func TestGetBuilder_Good(t *testing.T) { }) } -func TestGetBuilder_Bad(t *testing.T) { +func TestRelease_GetBuilder_Bad(t *testing.T) { t.Run("returns error for Node project type", func(t *testing.T) { _, err := getBuilder(build.ProjectTypeNode) assert.Error(t, err) @@ -195,7 +193,7 @@ func TestGetBuilder_Bad(t *testing.T) { }) } -func TestGetPublisher_Good(t *testing.T) { +func TestRelease_GetPublisher_Good(t *testing.T) { tests := []struct { pubType string expectedName string @@ -220,7 +218,7 @@ func TestGetPublisher_Good(t *testing.T) { } } -func TestGetPublisher_Bad(t *testing.T) { +func TestRelease_GetPublisher_Bad(t *testing.T) { t.Run("returns error for unsupported publisher type", func(t *testing.T) { _, err := getPublisher("unsupported") assert.Error(t, err) @@ -234,7 +232,7 @@ func TestGetPublisher_Bad(t *testing.T) { }) } -func TestBuildExtendedConfig_Good(t *testing.T) { +func TestRelease_BuildExtendedConfig_Good(t *testing.T) { t.Run("returns empty map for minimal config", func(t *testing.T) { cfg := PublisherConfig{ Type: "github", @@ -371,7 +369,7 @@ func TestBuildExtendedConfig_Good(t *testing.T) { }) } -func TestToAnySlice_Good(t *testing.T) { +func TestRelease_ToAnySlice_Good(t *testing.T) { t.Run("converts string slice to any slice", func(t *testing.T) { input := []string{"a", "b", "c"} @@ -401,12 +399,12 @@ func TestToAnySlice_Good(t *testing.T) { }) } -func TestPublish_Good(t *testing.T) { +func TestRelease_Publish_Good(t *testing.T) { t.Run("returns release with version from config", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -422,11 +420,11 @@ func TestPublish_Good(t *testing.T) { t.Run("finds artifacts in dist directory", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-linux.tar.gz"), []byte("test"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app-darwin.tar.gz"), []byte("test"), 0644)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-linux.tar.gz"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app-darwin.tar.gz"), []byte("test"), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "CHECKSUMS.txt"), []byte("checksums"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -440,7 +438,7 @@ func TestPublish_Good(t *testing.T) { }) } -func TestPublish_Bad(t *testing.T) { +func TestRelease_Publish_Bad(t *testing.T) { t.Run("returns error when config is nil", func(t *testing.T) { _, err := Publish(context.Background(), nil, true) assert.Error(t, err) @@ -461,8 +459,8 @@ func TestPublish_Bad(t *testing.T) { t.Run("returns error when no artifacts found", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -475,9 +473,9 @@ func TestPublish_Bad(t *testing.T) { t.Run("returns error for unsupported publisher", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -493,9 +491,9 @@ func TestPublish_Bad(t *testing.T) { t.Run("returns error when version determination fails in non-git dir", func(t *testing.T) { dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -510,7 +508,7 @@ func TestPublish_Bad(t *testing.T) { }) } -func TestRun_Good(t *testing.T) { +func TestRelease_Run_Good(t *testing.T) { t.Run("returns release with version from config", func(t *testing.T) { // Create a minimal Go project for testing dir := t.TempDir() @@ -520,14 +518,14 @@ func TestRun_Good(t *testing.T) { go 1.21 ` - require.NoError(t, os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "go.mod"), []byte(goMod), 0644)) // Create main.go mainGo := `package main func main() {} ` - require.NoError(t, os.WriteFile(filepath.Join(dir, "main.go"), []byte(mainGo), 0644)) + require.NoError(t, ax.WriteFile(ax.Join(dir, "main.go"), []byte(mainGo), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -548,7 +546,7 @@ func main() {} }) } -func TestRun_Bad(t *testing.T) { +func TestRelease_Run_Bad(t *testing.T) { t.Run("returns error when config is nil", func(t *testing.T) { _, err := Run(context.Background(), nil, true) assert.Error(t, err) @@ -556,7 +554,7 @@ func TestRun_Bad(t *testing.T) { }) } -func TestRelease_Structure(t *testing.T) { +func TestRelease_Structure_Good(t *testing.T) { t.Run("Release struct holds expected fields", func(t *testing.T) { release := &Release{ Version: "v1.0.0", @@ -572,16 +570,16 @@ func TestRelease_Structure(t *testing.T) { }) } -func TestPublish_VersionFromGit(t *testing.T) { +func TestRelease_PublishVersionFromGit_Good(t *testing.T) { t.Run("determines version from git when not set", func(t *testing.T) { dir := setupPublishGitRepo(t) createPublishCommit(t, dir, "feat: initial commit") createPublishTag(t, dir, "v1.2.3") // Create dist directory with artifact - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -595,7 +593,7 @@ func TestPublish_VersionFromGit(t *testing.T) { }) } -func TestPublish_ChangelogGeneration(t *testing.T) { +func TestRelease_PublishChangelogGeneration_Good(t *testing.T) { t.Run("generates changelog from git commits when available", func(t *testing.T) { dir := setupPublishGitRepo(t) createPublishCommit(t, dir, "feat: add feature") @@ -604,9 +602,9 @@ func TestPublish_ChangelogGeneration(t *testing.T) { createPublishTag(t, dir, "v1.0.1") // Create dist directory with artifact - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -622,9 +620,9 @@ func TestPublish_ChangelogGeneration(t *testing.T) { t.Run("uses fallback changelog on error", func(t *testing.T) { dir := t.TempDir() // Not a git repo - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -639,13 +637,13 @@ func TestPublish_ChangelogGeneration(t *testing.T) { }) } -func TestPublish_DefaultProjectDir(t *testing.T) { +func TestRelease_PublishDefaultProjectDir_Good(t *testing.T) { t.Run("uses current directory when projectDir is empty", func(t *testing.T) { // Create artifacts in current directory's dist folder dir := t.TempDir() - distDir := filepath.Join(dir, "dist") - require.NoError(t, os.MkdirAll(distDir, 0755)) - require.NoError(t, os.WriteFile(filepath.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) + distDir := ax.Join(dir, "dist") + require.NoError(t, ax.MkdirAll(distDir, 0755)) + require.NoError(t, ax.WriteFile(ax.Join(distDir, "app.tar.gz"), []byte("test"), 0644)) cfg := DefaultConfig() cfg.SetProjectDir(dir) @@ -664,17 +662,9 @@ func setupPublishGitRepo(t *testing.T) string { t.Helper() dir := t.TempDir() - cmd := exec.Command("git", "init") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "config", "user.email", "test@example.com") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "config", "user.name", "Test User") - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "init") + runGit(t, dir, "config", "user.email", "test@example.com") + runGit(t, dir, "config", "user.name", "Test User") return dir } @@ -682,23 +672,16 @@ func setupPublishGitRepo(t *testing.T) string { func createPublishCommit(t *testing.T, dir, message string) { t.Helper() - filePath := filepath.Join(dir, "publish_test.txt") - content, _ := os.ReadFile(filePath) + filePath := ax.Join(dir, "publish_test.txt") + content, _ := ax.ReadFile(filePath) content = append(content, []byte(message+"\n")...) - require.NoError(t, os.WriteFile(filePath, content, 0644)) + require.NoError(t, ax.WriteFile(filePath, content, 0644)) - cmd := exec.Command("git", "add", ".") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "commit", "-m", message) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "add", ".") + runGit(t, dir, "commit", "-m", message) } func createPublishTag(t *testing.T, dir, tag string) { t.Helper() - cmd := exec.Command("git", "tag", tag) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "tag", tag) } diff --git a/pkg/release/sdk.go b/pkg/release/sdk.go index 9c34748..4b91fac 100644 --- a/pkg/release/sdk.go +++ b/pkg/release/sdk.go @@ -10,6 +10,7 @@ import ( ) // SDKRelease holds the result of an SDK release. +// Usage example: declare a value of type release.SDKRelease in integrating code. type SDKRelease struct { // Version is the SDK version. Version string @@ -21,6 +22,7 @@ type SDKRelease struct { // RunSDK executes SDK-only release: diff check + generate. // If dryRun is true, it shows what would be done without generating. +// Usage example: call release.RunSDK(...) from integrating code. func RunSDK(ctx context.Context, cfg *Config, dryRun bool) (*SDKRelease, error) { if cfg == nil { return nil, coreerr.E("release.RunSDK", "config is nil", nil) diff --git a/pkg/release/sdk_test.go b/pkg/release/sdk_test.go index f800beb..14130fa 100644 --- a/pkg/release/sdk_test.go +++ b/pkg/release/sdk_test.go @@ -8,13 +8,13 @@ import ( "github.com/stretchr/testify/require" ) -func TestRunSDK_Bad_NilConfig(t *testing.T) { +func TestSDK_RunSDKNilConfig_Bad(t *testing.T) { _, err := RunSDK(context.Background(), nil, true) assert.Error(t, err) assert.Contains(t, err.Error(), "config is nil") } -func TestRunSDK_Bad_NoSDKConfig(t *testing.T) { +func TestSDK_RunSDKNoSDKConfig_Bad(t *testing.T) { cfg := &Config{ SDK: nil, } @@ -25,7 +25,7 @@ func TestRunSDK_Bad_NoSDKConfig(t *testing.T) { assert.Contains(t, err.Error(), "sdk not configured") } -func TestRunSDK_Good_DryRun(t *testing.T) { +func TestSDK_RunSDKDryRun_Good(t *testing.T) { cfg := &Config{ SDK: &SDKConfig{ Languages: []string{"typescript", "python"}, @@ -45,7 +45,7 @@ func TestRunSDK_Good_DryRun(t *testing.T) { assert.Equal(t, "sdk", result.Output) } -func TestRunSDK_Good_DryRunDefaultOutput(t *testing.T) { +func TestSDK_RunSDKDryRunDefaultOutput_Good(t *testing.T) { cfg := &Config{ SDK: &SDKConfig{ Languages: []string{"go"}, @@ -61,7 +61,7 @@ func TestRunSDK_Good_DryRunDefaultOutput(t *testing.T) { assert.Equal(t, "sdk", result.Output) } -func TestRunSDK_Good_DryRunDefaultProjectDir(t *testing.T) { +func TestSDK_RunSDKDryRunDefaultProjectDir_Good(t *testing.T) { cfg := &Config{ SDK: &SDKConfig{ Languages: []string{"typescript"}, @@ -77,7 +77,7 @@ func TestRunSDK_Good_DryRunDefaultProjectDir(t *testing.T) { assert.Equal(t, "v1.0.0", result.Version) } -func TestRunSDK_Bad_BreakingChangesFailOnBreaking(t *testing.T) { +func TestSDK_RunSDKBreakingChangesFailOnBreaking_Bad(t *testing.T) { // This test verifies that when diff.FailOnBreaking is true and breaking changes // are detected, RunSDK returns an error. However, since we can't easily mock // the diff check, this test verifies the config is correctly processed. @@ -102,7 +102,7 @@ func TestRunSDK_Bad_BreakingChangesFailOnBreaking(t *testing.T) { assert.Equal(t, "v1.0.0", result.Version) } -func TestToSDKConfig_Good(t *testing.T) { +func TestSDK_ToSDKConfig_Good(t *testing.T) { sdkCfg := &SDKConfig{ Spec: "api/openapi.yaml", Languages: []string{"typescript", "go"}, @@ -128,12 +128,12 @@ func TestToSDKConfig_Good(t *testing.T) { assert.True(t, result.Diff.FailOnBreaking) } -func TestToSDKConfig_Good_NilInput(t *testing.T) { +func TestSDK_ToSDKConfigNilInput_Good(t *testing.T) { result := toSDKConfig(nil) assert.Nil(t, result) } -func TestRunSDK_Good_WithDiffEnabledNoFailOnBreaking(t *testing.T) { +func TestSDK_RunSDKWithDiffEnabledNoFailOnBreaking_Good(t *testing.T) { // Tests diff enabled but FailOnBreaking=false (should warn but not fail) cfg := &Config{ SDK: &SDKConfig{ @@ -155,7 +155,7 @@ func TestRunSDK_Good_WithDiffEnabledNoFailOnBreaking(t *testing.T) { assert.Contains(t, result.Languages, "typescript") } -func TestRunSDK_Good_MultipleLanguages(t *testing.T) { +func TestSDK_RunSDKMultipleLanguages_Good(t *testing.T) { // Tests multiple language support cfg := &Config{ SDK: &SDKConfig{ @@ -174,7 +174,7 @@ func TestRunSDK_Good_MultipleLanguages(t *testing.T) { assert.Equal(t, "multi-sdk", result.Output) } -func TestRunSDK_Good_WithPackageConfig(t *testing.T) { +func TestSDK_RunSDKWithPackageConfig_Good(t *testing.T) { // Tests that package config is properly handled cfg := &Config{ SDK: &SDKConfig{ @@ -195,7 +195,7 @@ func TestRunSDK_Good_WithPackageConfig(t *testing.T) { assert.Equal(t, "v1.0.0", result.Version) } -func TestToSDKConfig_Good_EmptyPackageConfig(t *testing.T) { +func TestSDK_ToSDKConfigEmptyPackageConfig_Good(t *testing.T) { // Tests conversion with empty package config sdkCfg := &SDKConfig{ Languages: []string{"go"}, @@ -211,7 +211,7 @@ func TestToSDKConfig_Good_EmptyPackageConfig(t *testing.T) { assert.Empty(t, result.Package.Version) } -func TestToSDKConfig_Good_DiffDisabled(t *testing.T) { +func TestSDK_ToSDKConfigDiffDisabled_Good(t *testing.T) { // Tests conversion with diff disabled sdkCfg := &SDKConfig{ Languages: []string{"typescript"}, diff --git a/pkg/release/test_helpers_test.go b/pkg/release/test_helpers_test.go new file mode 100644 index 0000000..79987c4 --- /dev/null +++ b/pkg/release/test_helpers_test.go @@ -0,0 +1,14 @@ +package release + +import ( + "context" + "testing" + + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/require" +) + +func runGit(t *testing.T, dir string, args ...string) { + t.Helper() + require.NoError(t, ax.ExecDir(context.Background(), dir, "git", args...)) +} diff --git a/pkg/release/version.go b/pkg/release/version.go index 5a1323e..0b5d601 100644 --- a/pkg/release/version.go +++ b/pkg/release/version.go @@ -2,11 +2,12 @@ package release import ( - "os/exec" + "context" "regexp" "strconv" "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreerr "dappco.re/go/core/log" ) @@ -18,6 +19,8 @@ var semverRegex = regexp.MustCompile(`^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+) // 1. Git tag on HEAD // 2. Most recent tag + increment patch // 3. Default to v0.0.1 if no tags exist +// +// Usage example: call release.DetermineVersion(...) from integrating code. func DetermineVersion(dir string) (string, error) { // Check if HEAD has a tag headTag, err := getTagOnHead(dir) @@ -41,6 +44,8 @@ func DetermineVersion(dir string) (string, error) { // - "v1.2.3" -> "v1.2.4" // - "1.2.3" -> "v1.2.4" // - "v1.2.3-alpha" -> "v1.2.4" (strips prerelease) +// +// Usage example: call release.IncrementVersion(...) from integrating code. func IncrementVersion(current string) string { matches := semverRegex.FindStringSubmatch(current) if matches == nil { @@ -62,6 +67,8 @@ func IncrementVersion(current string) string { // Examples: // - "v1.2.3" -> "v1.3.0" // - "1.2.3" -> "v1.3.0" +// +// Usage example: call release.IncrementMinor(...) from integrating code. func IncrementMinor(current string) string { matches := semverRegex.FindStringSubmatch(current) if matches == nil { @@ -81,6 +88,8 @@ func IncrementMinor(current string) string { // Examples: // - "v1.2.3" -> "v2.0.0" // - "1.2.3" -> "v2.0.0" +// +// Usage example: call release.IncrementMajor(...) from integrating code. func IncrementMajor(current string) string { matches := semverRegex.FindStringSubmatch(current) if matches == nil { @@ -97,6 +106,7 @@ func IncrementMajor(current string) string { // ParseVersion parses a semver string into its components. // Returns (major, minor, patch, prerelease, build, error). +// Usage example: call release.ParseVersion(...) from integrating code. func ParseVersion(version string) (int, int, int, string, string, error) { matches := semverRegex.FindStringSubmatch(version) if matches == nil { @@ -113,6 +123,7 @@ func ParseVersion(version string) (int, int, int, string, string, error) { } // ValidateVersion checks if a string is a valid semver. +// Usage example: call release.ValidateVersion(...) from integrating code. func ValidateVersion(version string) bool { return semverRegex.MatchString(version) } @@ -127,24 +138,20 @@ func normalizeVersion(version string) string { // getTagOnHead returns the tag on HEAD, if any. func getTagOnHead(dir string) (string, error) { - cmd := exec.Command("git", "describe", "--tags", "--exact-match", "HEAD") - cmd.Dir = dir - output, err := cmd.Output() + output, err := ax.RunDir(context.Background(), dir, "git", "describe", "--tags", "--exact-match", "HEAD") if err != nil { return "", err } - return core.Trim(string(output)), nil + return core.Trim(output), nil } // getLatestTag returns the most recent tag in the repository. func getLatestTag(dir string) (string, error) { - cmd := exec.Command("git", "describe", "--tags", "--abbrev=0") - cmd.Dir = dir - output, err := cmd.Output() + output, err := ax.RunDir(context.Background(), dir, "git", "describe", "--tags", "--abbrev=0") if err != nil { return "", err } - return core.Trim(string(output)), nil + return core.Trim(output), nil } // CompareVersions compares two semver strings. @@ -153,6 +160,8 @@ func getLatestTag(dir string) (string, error) { // -1 if a < b // 0 if a == b // 1 if a > b +// +// Usage example: call release.CompareVersions(...) from integrating code. func CompareVersions(a, b string) int { aMajor, aMinor, aPatch, _, _, errA := ParseVersion(a) bMajor, bMinor, bPatch, _, _, errB := ParseVersion(b) diff --git a/pkg/release/version_test.go b/pkg/release/version_test.go index b170a98..50d23fd 100644 --- a/pkg/release/version_test.go +++ b/pkg/release/version_test.go @@ -1,11 +1,10 @@ package release import ( - "os" - "os/exec" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -16,18 +15,11 @@ func setupGitRepo(t *testing.T) string { dir := t.TempDir() // Initialize git repo - cmd := exec.Command("git", "init") - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "init") // Configure git user for commits - cmd = exec.Command("git", "config", "user.email", "test@example.com") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "config", "user.name", "Test User") - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "config", "user.email", "test@example.com") + runGit(t, dir, "config", "user.name", "Test User") return dir } @@ -37,30 +29,23 @@ func createCommit(t *testing.T, dir, message string) { t.Helper() // Create or modify a file - filePath := filepath.Join(dir, "test.txt") - content, _ := os.ReadFile(filePath) + filePath := ax.Join(dir, "test.txt") + content, _ := ax.ReadFile(filePath) content = append(content, []byte(message+"\n")...) - require.NoError(t, os.WriteFile(filePath, content, 0644)) + require.NoError(t, ax.WriteFile(filePath, content, 0644)) // Stage and commit - cmd := exec.Command("git", "add", ".") - cmd.Dir = dir - require.NoError(t, cmd.Run()) - - cmd = exec.Command("git", "commit", "-m", message) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "add", ".") + runGit(t, dir, "commit", "-m", message) } // createTag creates a tag in the given directory. func createTag(t *testing.T, dir, tag string) { t.Helper() - cmd := exec.Command("git", "tag", tag) - cmd.Dir = dir - require.NoError(t, cmd.Run()) + runGit(t, dir, "tag", tag) } -func TestDetermineVersion_Good(t *testing.T) { +func TestVersion_DetermineVersion_Good(t *testing.T) { t.Run("returns tag when HEAD has tag", func(t *testing.T) { dir := setupGitRepo(t) createCommit(t, dir, "feat: initial commit") @@ -115,7 +100,7 @@ func TestDetermineVersion_Good(t *testing.T) { }) } -func TestDetermineVersion_Bad(t *testing.T) { +func TestVersion_DetermineVersion_Bad(t *testing.T) { t.Run("returns v0.0.1 for empty repo", func(t *testing.T) { dir := setupGitRepo(t) @@ -126,7 +111,7 @@ func TestDetermineVersion_Bad(t *testing.T) { }) } -func TestGetTagOnHead_Good(t *testing.T) { +func TestVersion_GetTagOnHead_Good(t *testing.T) { t.Run("returns tag when HEAD has tag", func(t *testing.T) { dir := setupGitRepo(t) createCommit(t, dir, "feat: initial commit") @@ -150,7 +135,7 @@ func TestGetTagOnHead_Good(t *testing.T) { }) } -func TestGetTagOnHead_Bad(t *testing.T) { +func TestVersion_GetTagOnHead_Bad(t *testing.T) { t.Run("returns error when HEAD has no tag", func(t *testing.T) { dir := setupGitRepo(t) createCommit(t, dir, "feat: initial commit") @@ -170,7 +155,7 @@ func TestGetTagOnHead_Bad(t *testing.T) { }) } -func TestGetLatestTag_Good(t *testing.T) { +func TestVersion_GetLatestTag_Good(t *testing.T) { t.Run("returns latest tag", func(t *testing.T) { dir := setupGitRepo(t) createCommit(t, dir, "feat: initial commit") @@ -195,7 +180,7 @@ func TestGetLatestTag_Good(t *testing.T) { }) } -func TestGetLatestTag_Bad(t *testing.T) { +func TestVersion_GetLatestTag_Bad(t *testing.T) { t.Run("returns error when no tags exist", func(t *testing.T) { dir := setupGitRepo(t) createCommit(t, dir, "feat: initial commit") @@ -212,21 +197,21 @@ func TestGetLatestTag_Bad(t *testing.T) { }) } -func TestIncrementMinor_Bad(t *testing.T) { +func TestVersion_IncrementMinor_Bad(t *testing.T) { t.Run("returns fallback for invalid version", func(t *testing.T) { result := IncrementMinor("not-valid") assert.Equal(t, "not-valid.1", result) }) } -func TestIncrementMajor_Bad(t *testing.T) { +func TestVersion_IncrementMajor_Bad(t *testing.T) { t.Run("returns fallback for invalid version", func(t *testing.T) { result := IncrementMajor("not-valid") assert.Equal(t, "not-valid.1", result) }) } -func TestCompareVersions_Ugly(t *testing.T) { +func TestVersion_CompareVersions_Ugly(t *testing.T) { t.Run("handles both invalid versions", func(t *testing.T) { result := CompareVersions("invalid-a", "invalid-b") // Should do string comparison for invalid versions @@ -244,7 +229,7 @@ func TestCompareVersions_Ugly(t *testing.T) { }) } -func TestIncrementVersion_Good(t *testing.T) { +func TestVersion_IncrementVersion_Good(t *testing.T) { tests := []struct { name string input string @@ -295,14 +280,14 @@ func TestIncrementVersion_Good(t *testing.T) { } } -func TestIncrementVersion_Bad(t *testing.T) { +func TestVersion_IncrementVersion_Bad(t *testing.T) { t.Run("invalid semver returns original with suffix", func(t *testing.T) { result := IncrementVersion("not-a-version") assert.Equal(t, "not-a-version.1", result) }) } -func TestIncrementMinor_Good(t *testing.T) { +func TestVersion_IncrementMinor_Good(t *testing.T) { tests := []struct { name string input string @@ -333,7 +318,7 @@ func TestIncrementMinor_Good(t *testing.T) { } } -func TestIncrementMajor_Good(t *testing.T) { +func TestVersion_IncrementMajor_Good(t *testing.T) { tests := []struct { name string input string @@ -364,7 +349,7 @@ func TestIncrementMajor_Good(t *testing.T) { } } -func TestParseVersion_Good(t *testing.T) { +func TestVersion_ParseVersion_Good(t *testing.T) { tests := []struct { name string input string @@ -418,7 +403,7 @@ func TestParseVersion_Good(t *testing.T) { } } -func TestParseVersion_Bad(t *testing.T) { +func TestVersion_ParseVersion_Bad(t *testing.T) { tests := []struct { name string input string @@ -438,7 +423,7 @@ func TestParseVersion_Bad(t *testing.T) { } } -func TestValidateVersion_Good(t *testing.T) { +func TestVersion_ValidateVersion_Good(t *testing.T) { validVersions := []string{ "v1.0.0", "1.0.0", @@ -456,7 +441,7 @@ func TestValidateVersion_Good(t *testing.T) { } } -func TestValidateVersion_Bad(t *testing.T) { +func TestVersion_ValidateVersion_Bad(t *testing.T) { invalidVersions := []string{ "", "v1", @@ -474,7 +459,7 @@ func TestValidateVersion_Bad(t *testing.T) { } } -func TestCompareVersions_Good(t *testing.T) { +func TestVersion_CompareVersions_Good(t *testing.T) { tests := []struct { name string a string @@ -500,7 +485,7 @@ func TestCompareVersions_Good(t *testing.T) { } } -func TestNormalizeVersion_Good(t *testing.T) { +func TestVersion_NormalizeVersion_Good(t *testing.T) { tests := []struct { input string expected string diff --git a/pkg/sdk/breaking_test.go b/pkg/sdk/breaking_test.go index c8c579b..82adc40 100644 --- a/pkg/sdk/breaking_test.go +++ b/pkg/sdk/breaking_test.go @@ -1,17 +1,17 @@ package sdk import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // --- Breaking Change Detection Tests (oasdiff integration) --- -func TestDiff_Good_AddEndpoint_NonBreaking(t *testing.T) { +func TestBreaking_DiffAddEndpointNonBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -50,10 +50,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -62,7 +62,7 @@ paths: assert.Equal(t, "No breaking changes", result.Summary) } -func TestDiff_Good_RemoveEndpoint_Breaking(t *testing.T) { +func TestBreaking_DiffRemoveEndpointBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -101,10 +101,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -113,7 +113,7 @@ paths: assert.Contains(t, result.Summary, "breaking change") } -func TestDiff_Good_AddRequiredParam_Breaking(t *testing.T) { +func TestBreaking_DiffAddRequiredParamBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -146,10 +146,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -157,7 +157,7 @@ paths: assert.NotEmpty(t, result.Changes) } -func TestDiff_Good_AddOptionalParam_NonBreaking(t *testing.T) { +func TestBreaking_DiffAddOptionalParamNonBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -190,17 +190,17 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) assert.False(t, result.Breaking, "adding optional parameter should not be breaking") } -func TestDiff_Good_ChangeResponseType_Breaking(t *testing.T) { +func TestBreaking_DiffChangeResponseTypeBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -252,17 +252,17 @@ paths: name: type: string ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) assert.True(t, result.Breaking, "changing response schema type should be breaking") } -func TestDiff_Good_RemoveHTTPMethod_Breaking(t *testing.T) { +func TestBreaking_DiffRemoveHTTPMethodBreaking_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -294,10 +294,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -305,7 +305,7 @@ paths: assert.NotEmpty(t, result.Changes) } -func TestDiff_Good_IdenticalSpecs_NonBreaking(t *testing.T) { +func TestBreaking_DiffIdenticalSpecsNonBreaking_Good(t *testing.T) { tmpDir := t.TempDir() spec := `openapi: "3.0.0" @@ -331,10 +331,10 @@ paths: "201": description: Created ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(spec), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(spec), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(spec), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(spec), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -345,45 +345,45 @@ paths: // --- Error Handling Tests --- -func TestDiff_Bad_NonExistentBase(t *testing.T) { +func TestBreaking_DiffNonExistentBase_Bad(t *testing.T) { tmpDir := t.TempDir() - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(revPath, []byte(`openapi: "3.0.0" + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(revPath, []byte(`openapi: "3.0.0" info: title: Test API version: "1.0.0" paths: {} `), 0644)) - _, err := Diff(filepath.Join(tmpDir, "nonexistent.yaml"), revPath) + _, err := Diff(ax.Join(tmpDir, "nonexistent.yaml"), revPath) assert.Error(t, err) assert.Contains(t, err.Error(), "failed to load base spec") } -func TestDiff_Bad_NonExistentRevision(t *testing.T) { +func TestBreaking_DiffNonExistentRevision_Bad(t *testing.T) { tmpDir := t.TempDir() - basePath := filepath.Join(tmpDir, "base.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(`openapi: "3.0.0" + basePath := ax.Join(tmpDir, "base.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(`openapi: "3.0.0" info: title: Test API version: "1.0.0" paths: {} `), 0644)) - _, err := Diff(basePath, filepath.Join(tmpDir, "nonexistent.yaml")) + _, err := Diff(basePath, ax.Join(tmpDir, "nonexistent.yaml")) assert.Error(t, err) assert.Contains(t, err.Error(), "failed to load revision spec") } -func TestDiff_Bad_InvalidYAML(t *testing.T) { +func TestBreaking_DiffInvalidYAML_Bad(t *testing.T) { tmpDir := t.TempDir() - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte("not: valid: openapi: spec: {{{{"), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(`openapi: "3.0.0" + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte("not: valid: openapi: spec: {{{{"), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(`openapi: "3.0.0" info: title: Test API version: "1.0.0" @@ -396,7 +396,7 @@ paths: {} // --- DiffExitCode Tests --- -func TestDiffExitCode_Good(t *testing.T) { +func TestBreaking_DiffExitCode_Good(t *testing.T) { tests := []struct { name string result *DiffResult @@ -433,7 +433,7 @@ func TestDiffExitCode_Good(t *testing.T) { // --- DiffResult Structure Tests --- -func TestDiffResult_Good_Summary(t *testing.T) { +func TestBreaking_DiffResultSummary_Good(t *testing.T) { t.Run("breaking result has count in summary", func(t *testing.T) { tmpDir := t.TempDir() @@ -474,10 +474,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -489,7 +489,7 @@ paths: }) } -func TestDiffResult_Good_ChangesAreHumanReadable(t *testing.T) { +func TestBreaking_DiffResultChangesAreHumanReadable_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -510,10 +510,10 @@ info: version: "2.0.0" paths: {} ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -527,7 +527,7 @@ paths: {} // --- Multiple Changes Detection Tests --- -func TestDiff_Good_MultipleBreakingChanges(t *testing.T) { +func TestBreaking_DiffMultipleBreakingChanges_Good(t *testing.T) { tmpDir := t.TempDir() base := `openapi: "3.0.0" @@ -570,10 +570,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - require.NoError(t, os.WriteFile(basePath, []byte(base), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revision), 0644)) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + require.NoError(t, ax.WriteFile(basePath, []byte(base), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revision), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) @@ -586,7 +586,7 @@ paths: // --- JSON Spec Support Tests --- -func TestDiff_Good_JSONSpecs(t *testing.T) { +func TestBreaking_DiffJSONSpecs_Good(t *testing.T) { tmpDir := t.TempDir() baseJSON := `{ @@ -619,10 +619,10 @@ func TestDiff_Good_JSONSpecs(t *testing.T) { } } }` - basePath := filepath.Join(tmpDir, "base.json") - revPath := filepath.Join(tmpDir, "rev.json") - require.NoError(t, os.WriteFile(basePath, []byte(baseJSON), 0644)) - require.NoError(t, os.WriteFile(revPath, []byte(revJSON), 0644)) + basePath := ax.Join(tmpDir, "base.json") + revPath := ax.Join(tmpDir, "rev.json") + require.NoError(t, ax.WriteFile(basePath, []byte(baseJSON), 0644)) + require.NoError(t, ax.WriteFile(revPath, []byte(revJSON), 0644)) result, err := Diff(basePath, revPath) require.NoError(t, err) diff --git a/pkg/sdk/detect.go b/pkg/sdk/detect.go index 5ed28c8..b78c43e 100644 --- a/pkg/sdk/detect.go +++ b/pkg/sdk/detect.go @@ -1,9 +1,8 @@ package sdk import ( - "path/filepath" - "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) @@ -22,10 +21,11 @@ var commonSpecPaths = []string{ // DetectSpec finds the OpenAPI spec file. // Priority: config path -> common paths -> Laravel Scramble. +// Usage example: call value.DetectSpec(...) from integrating code. func (s *SDK) DetectSpec() (string, error) { // 1. Check configured path if s.config.Spec != "" { - specPath := filepath.Join(s.projectDir, s.config.Spec) + specPath := ax.Join(s.projectDir, s.config.Spec) if coreio.Local.IsFile(specPath) { return specPath, nil } @@ -34,7 +34,7 @@ func (s *SDK) DetectSpec() (string, error) { // 2. Check common paths for _, p := range commonSpecPaths { - specPath := filepath.Join(s.projectDir, p) + specPath := ax.Join(s.projectDir, p) if coreio.Local.IsFile(specPath) { return specPath, nil } @@ -51,7 +51,7 @@ func (s *SDK) DetectSpec() (string, error) { // detectScramble checks for Laravel Scramble and exports the spec. func (s *SDK) detectScramble() (string, error) { - composerPath := filepath.Join(s.projectDir, "composer.json") + composerPath := ax.Join(s.projectDir, "composer.json") if !coreio.Local.IsFile(composerPath) { return "", coreerr.E("sdk.detectScramble", "no composer.json", nil) } diff --git a/pkg/sdk/detect_test.go b/pkg/sdk/detect_test.go index fef2dbc..98986ac 100644 --- a/pkg/sdk/detect_test.go +++ b/pkg/sdk/detect_test.go @@ -1,20 +1,20 @@ package sdk import ( - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestDetectSpec_Good_ConfigPath(t *testing.T) { +func TestDetect_DetectSpecConfigPath_Good(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, "api", "spec.yaml") - err := os.MkdirAll(filepath.Dir(specPath), 0755) + specPath := ax.Join(tmpDir, "api", "spec.yaml") + err := ax.MkdirAll(ax.Dir(specPath), 0755) require.NoError(t, err) - err = os.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) + err = ax.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) require.NoError(t, err) sdk := New(tmpDir, &Config{Spec: "api/spec.yaml"}) @@ -23,10 +23,10 @@ func TestDetectSpec_Good_ConfigPath(t *testing.T) { assert.Equal(t, specPath, got) } -func TestDetectSpec_Good_CommonPath(t *testing.T) { +func TestDetect_DetectSpecCommonPath_Good(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) + specPath := ax.Join(tmpDir, "openapi.yaml") + err := ax.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) require.NoError(t, err) sdk := New(tmpDir, nil) @@ -35,7 +35,7 @@ func TestDetectSpec_Good_CommonPath(t *testing.T) { assert.Equal(t, specPath, got) } -func TestDetectSpec_Bad_NotFound(t *testing.T) { +func TestDetect_DetectSpecNotFound_Bad(t *testing.T) { tmpDir := t.TempDir() sdk := New(tmpDir, nil) _, err := sdk.DetectSpec() @@ -43,7 +43,7 @@ func TestDetectSpec_Bad_NotFound(t *testing.T) { assert.Contains(t, err.Error(), "no OpenAPI spec found") } -func TestDetectSpec_Bad_ConfigNotFound(t *testing.T) { +func TestDetect_DetectSpecConfigNotFound_Bad(t *testing.T) { tmpDir := t.TempDir() sdk := New(tmpDir, &Config{Spec: "non-existent.yaml"}) _, err := sdk.DetectSpec() @@ -51,7 +51,7 @@ func TestDetectSpec_Bad_ConfigNotFound(t *testing.T) { assert.Contains(t, err.Error(), "configured spec not found") } -func TestContainsScramble(t *testing.T) { +func TestDetect_ContainsScramble_Good(t *testing.T) { tests := []struct { data string expected bool @@ -66,7 +66,7 @@ func TestContainsScramble(t *testing.T) { } } -func TestDetectScramble_Bad(t *testing.T) { +func TestDetect_DetectScramble_Bad(t *testing.T) { t.Run("no composer.json", func(t *testing.T) { sdk := New(t.TempDir(), nil) _, err := sdk.detectScramble() @@ -76,7 +76,7 @@ func TestDetectScramble_Bad(t *testing.T) { t.Run("no scramble in composer.json", func(t *testing.T) { tmpDir := t.TempDir() - err := os.WriteFile(filepath.Join(tmpDir, "composer.json"), []byte(`{}`), 0644) + err := ax.WriteFile(ax.Join(tmpDir, "composer.json"), []byte(`{}`), 0644) require.NoError(t, err) sdk := New(tmpDir, nil) diff --git a/pkg/sdk/diff.go b/pkg/sdk/diff.go index 4aabcfc..5751533 100644 --- a/pkg/sdk/diff.go +++ b/pkg/sdk/diff.go @@ -10,6 +10,7 @@ import ( ) // DiffResult holds the result of comparing two OpenAPI specs. +// Usage example: declare a value of type sdk.DiffResult in integrating code. type DiffResult struct { // Breaking is true if breaking changes were detected. Breaking bool @@ -20,6 +21,7 @@ type DiffResult struct { } // Diff compares two OpenAPI specs and detects breaking changes. +// Usage example: call sdk.Diff(...) from integrating code. func Diff(basePath, revisionPath string) (*DiffResult, error) { loader := openapi3.NewLoader() loader.IsExternalRefsAllowed = true @@ -73,6 +75,7 @@ func Diff(basePath, revisionPath string) (*DiffResult, error) { // DiffExitCode returns the exit code for CI integration. // 0 = no breaking changes, 1 = breaking changes, 2 = error +// Usage example: call sdk.DiffExitCode(...) from integrating code. func DiffExitCode(result *DiffResult, err error) int { if err != nil { return 2 diff --git a/pkg/sdk/diff_test.go b/pkg/sdk/diff_test.go index f1b3a20..2c48fac 100644 --- a/pkg/sdk/diff_test.go +++ b/pkg/sdk/diff_test.go @@ -1,12 +1,12 @@ package sdk import ( - "os" - "path/filepath" "testing" + + "dappco.re/go/core/build/internal/ax" ) -func TestDiff_Good_NoBreaking(t *testing.T) { +func TestDiff_NoBreaking_Good(t *testing.T) { tmpDir := t.TempDir() baseSpec := `openapi: "3.0.0" @@ -39,10 +39,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - _ = os.WriteFile(basePath, []byte(baseSpec), 0644) - _ = os.WriteFile(revPath, []byte(revSpec), 0644) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + _ = ax.WriteFile(basePath, []byte(baseSpec), 0644) + _ = ax.WriteFile(revPath, []byte(revSpec), 0644) result, err := Diff(basePath, revPath) if err != nil { @@ -53,7 +53,7 @@ paths: } } -func TestDiff_Good_Breaking(t *testing.T) { +func TestDiff_Breaking_Good(t *testing.T) { tmpDir := t.TempDir() baseSpec := `openapi: "3.0.0" @@ -86,10 +86,10 @@ paths: "200": description: OK ` - basePath := filepath.Join(tmpDir, "base.yaml") - revPath := filepath.Join(tmpDir, "rev.yaml") - _ = os.WriteFile(basePath, []byte(baseSpec), 0644) - _ = os.WriteFile(revPath, []byte(revSpec), 0644) + basePath := ax.Join(tmpDir, "base.yaml") + revPath := ax.Join(tmpDir, "rev.yaml") + _ = ax.WriteFile(basePath, []byte(baseSpec), 0644) + _ = ax.WriteFile(revPath, []byte(revSpec), 0644) result, err := Diff(basePath, revPath) if err != nil { diff --git a/pkg/sdk/generation_test.go b/pkg/sdk/generation_test.go index 4966317..d32d269 100644 --- a/pkg/sdk/generation_test.go +++ b/pkg/sdk/generation_test.go @@ -2,10 +2,10 @@ package sdk import ( "context" - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "dappco.re/go/core/build/pkg/sdk/generators" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -13,13 +13,13 @@ import ( // --- SDK Generation Orchestration Tests --- -func TestSDK_Generate_Good_AllLanguages(t *testing.T) { +func TestGeneration_SDKGenerateAllLanguages_Good(t *testing.T) { t.Run("Generate iterates all configured languages", func(t *testing.T) { tmpDir := t.TempDir() // Create a minimal OpenAPI spec - specPath := filepath.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(specPath, []byte(minimalSpec), 0644) + specPath := ax.Join(tmpDir, "openapi.yaml") + err := ax.WriteFile(specPath, []byte(minimalSpec), 0644) require.NoError(t, err) cfg := &Config{ @@ -41,12 +41,12 @@ func TestSDK_Generate_Good_AllLanguages(t *testing.T) { }) } -func TestSDK_GenerateLanguage_Good_OutputDir(t *testing.T) { +func TestGeneration_SDKGenerateLanguageOutputDir_Good(t *testing.T) { t.Run("output directory uses language subdirectory", func(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(specPath, []byte(minimalSpec), 0644) + specPath := ax.Join(tmpDir, "openapi.yaml") + err := ax.WriteFile(specPath, []byte(minimalSpec), 0644) require.NoError(t, err) cfg := &Config{ @@ -69,7 +69,7 @@ func TestSDK_GenerateLanguage_Good_OutputDir(t *testing.T) { }) } -func TestSDK_GenerateLanguage_Bad_NoSpec(t *testing.T) { +func TestGeneration_SDKGenerateLanguageNoSpec_Bad(t *testing.T) { t.Run("fails when no OpenAPI spec exists", func(t *testing.T) { tmpDir := t.TempDir() @@ -84,11 +84,11 @@ func TestSDK_GenerateLanguage_Bad_NoSpec(t *testing.T) { }) } -func TestSDK_GenerateLanguage_Bad_UnknownLanguage(t *testing.T) { +func TestGeneration_SDKGenerateLanguageUnknownLanguage_Bad(t *testing.T) { t.Run("fails for unregistered language", func(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(specPath, []byte(minimalSpec), 0644) + specPath := ax.Join(tmpDir, "openapi.yaml") + err := ax.WriteFile(specPath, []byte(minimalSpec), 0644) require.NoError(t, err) s := New(tmpDir, nil) @@ -100,7 +100,7 @@ func TestSDK_GenerateLanguage_Bad_UnknownLanguage(t *testing.T) { // --- Generator Registry Tests --- -func TestRegistry_Good_RegisterAndGet(t *testing.T) { +func TestGeneration_RegistryRegisterAndGet_Good(t *testing.T) { t.Run("register and retrieve all generators", func(t *testing.T) { registry := generators.NewRegistry() registry.Register(generators.NewTypeScriptGenerator()) @@ -132,7 +132,7 @@ func TestRegistry_Good_RegisterAndGet(t *testing.T) { }) } -func TestRegistry_Good_OverwritesDuplicateLanguage(t *testing.T) { +func TestGeneration_RegistryOverwritesDuplicateLanguage_Good(t *testing.T) { registry := generators.NewRegistry() registry.Register(generators.NewTypeScriptGenerator()) registry.Register(generators.NewTypeScriptGenerator()) // register again @@ -149,7 +149,7 @@ func TestRegistry_Good_OverwritesDuplicateLanguage(t *testing.T) { // --- Generator Interface Compliance Tests --- -func TestGenerators_Good_LanguageIdentifiers(t *testing.T) { +func TestGeneration_GeneratorsLanguageIdentifiers_Good(t *testing.T) { tests := []struct { generator generators.Generator expected string @@ -167,7 +167,7 @@ func TestGenerators_Good_LanguageIdentifiers(t *testing.T) { } } -func TestGenerators_Good_InstallInstructions(t *testing.T) { +func TestGeneration_GeneratorsInstallInstructions_Good(t *testing.T) { tests := []struct { language string gen generators.Generator @@ -188,7 +188,7 @@ func TestGenerators_Good_InstallInstructions(t *testing.T) { } } -func TestGenerators_Good_AvailableDoesNotPanic(t *testing.T) { +func TestGeneration_GeneratorsAvailableDoesNotPanic_Good(t *testing.T) { // Available() should never panic regardless of system state gens := []generators.Generator{ generators.NewTypeScriptGenerator(), @@ -207,7 +207,7 @@ func TestGenerators_Good_AvailableDoesNotPanic(t *testing.T) { // --- SDK Config Tests --- -func TestSDKConfig_Good_DefaultConfig(t *testing.T) { +func TestGeneration_SDKConfigDefaultConfig_Good(t *testing.T) { t.Run("default config has all four languages", func(t *testing.T) { cfg := DefaultConfig() assert.Contains(t, cfg.Languages, "typescript") @@ -229,7 +229,7 @@ func TestSDKConfig_Good_DefaultConfig(t *testing.T) { }) } -func TestSDKConfig_Good_SetVersion(t *testing.T) { +func TestGeneration_SDKConfigSetVersion_Good(t *testing.T) { t.Run("SetVersion updates both fields", func(t *testing.T) { s := New("/tmp", &Config{ Package: PackageConfig{ @@ -251,7 +251,7 @@ func TestSDKConfig_Good_SetVersion(t *testing.T) { }) } -func TestSDKConfig_Good_NewWithNilConfig(t *testing.T) { +func TestGeneration_SDKConfigNewWithNilConfig_Good(t *testing.T) { s := New("/project", nil) assert.NotNil(t, s.config) assert.Equal(t, "sdk", s.config.Output) @@ -260,18 +260,18 @@ func TestSDKConfig_Good_NewWithNilConfig(t *testing.T) { // --- Spec Detection Integration Tests --- -func TestSpecDetection_Good_Priority(t *testing.T) { +func TestGeneration_SpecDetectionPriority_Good(t *testing.T) { t.Run("configured spec takes priority over common paths", func(t *testing.T) { tmpDir := t.TempDir() // Create both a common path spec and a configured spec - commonSpec := filepath.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(commonSpec, []byte(minimalSpec), 0644) + commonSpec := ax.Join(tmpDir, "openapi.yaml") + err := ax.WriteFile(commonSpec, []byte(minimalSpec), 0644) require.NoError(t, err) - configuredSpec := filepath.Join(tmpDir, "custom", "api.yaml") - require.NoError(t, os.MkdirAll(filepath.Dir(configuredSpec), 0755)) - err = os.WriteFile(configuredSpec, []byte(minimalSpec), 0644) + configuredSpec := ax.Join(tmpDir, "custom", "api.yaml") + require.NoError(t, ax.MkdirAll(ax.Dir(configuredSpec), 0755)) + err = ax.WriteFile(configuredSpec, []byte(minimalSpec), 0644) require.NoError(t, err) s := New(tmpDir, &Config{Spec: "custom/api.yaml"}) @@ -284,10 +284,10 @@ func TestSpecDetection_Good_Priority(t *testing.T) { tmpDir := t.TempDir() // Create the second common path only (api/openapi.yaml is first) - apiDir := filepath.Join(tmpDir, "api") - require.NoError(t, os.MkdirAll(apiDir, 0755)) - apiSpec := filepath.Join(apiDir, "openapi.json") - err := os.WriteFile(apiSpec, []byte(`{"openapi":"3.0.0"}`), 0644) + apiDir := ax.Join(tmpDir, "api") + require.NoError(t, ax.MkdirAll(apiDir, 0755)) + apiSpec := ax.Join(apiDir, "openapi.json") + err := ax.WriteFile(apiSpec, []byte(`{"openapi":"3.0.0"}`), 0644) require.NoError(t, err) s := New(tmpDir, nil) @@ -297,14 +297,14 @@ func TestSpecDetection_Good_Priority(t *testing.T) { }) } -func TestSpecDetection_Good_AllCommonPaths(t *testing.T) { +func TestGeneration_SpecDetectionAllCommonPaths_Good(t *testing.T) { for _, commonPath := range commonSpecPaths { t.Run(commonPath, func(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, commonPath) - require.NoError(t, os.MkdirAll(filepath.Dir(specPath), 0755)) - err := os.WriteFile(specPath, []byte(minimalSpec), 0644) + specPath := ax.Join(tmpDir, commonPath) + require.NoError(t, ax.MkdirAll(ax.Dir(specPath), 0755)) + err := ax.WriteFile(specPath, []byte(minimalSpec), 0644) require.NoError(t, err) s := New(tmpDir, nil) diff --git a/pkg/sdk/generators/docker_runtime.go b/pkg/sdk/generators/docker_runtime.go index 49869ce..dc41597 100644 --- a/pkg/sdk/generators/docker_runtime.go +++ b/pkg/sdk/generators/docker_runtime.go @@ -1,9 +1,10 @@ package generators import ( - "io" - "os/exec" + "context" "sync" + + "dappco.re/go/core/build/internal/ax" ) var ( @@ -13,10 +14,7 @@ var ( func dockerRuntimeAvailable() bool { dockerRuntimeOnce.Do(func() { - cmd := exec.Command("docker", "info") - cmd.Stdout = io.Discard - cmd.Stderr = io.Discard - dockerRuntimeOK = cmd.Run() == nil + dockerRuntimeOK = ax.Exec(context.Background(), "docker", "info") == nil }) return dockerRuntimeOK } diff --git a/pkg/sdk/generators/generator.go b/pkg/sdk/generators/generator.go index 2eb300b..340cabc 100644 --- a/pkg/sdk/generators/generator.go +++ b/pkg/sdk/generators/generator.go @@ -4,14 +4,15 @@ package generators import ( "context" "iter" - "os" "runtime" "sort" "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" ) // Options holds common generation options. +// Usage example: declare a value of type generators.Options in integrating code. type Options struct { // SpecPath is the path to the OpenAPI spec file. SpecPath string @@ -24,6 +25,7 @@ type Options struct { } // Generator defines the interface for SDK generators. +// Usage example: declare a value of type generators.Generator in integrating code. type Generator interface { // Language returns the generator's target language identifier. Language() string @@ -39,11 +41,13 @@ type Generator interface { } // Registry holds available generators. +// Usage example: declare a value of type generators.Registry in integrating code. type Registry struct { generators map[string]Generator } // NewRegistry creates a registry with all available generators. +// Usage example: call generators.NewRegistry(...) from integrating code. func NewRegistry() *Registry { r := &Registry{ generators: make(map[string]Generator), @@ -53,17 +57,20 @@ func NewRegistry() *Registry { } // Get returns a generator by language. +// Usage example: call value.Get(...) from integrating code. func (r *Registry) Get(lang string) (Generator, bool) { g, ok := r.generators[lang] return g, ok } // Register adds a generator to the registry. +// Usage example: call value.Register(...) from integrating code. func (r *Registry) Register(g Generator) { r.generators[g.Language()] = g } // Languages returns all registered language identifiers. +// Usage example: call value.Languages(...) from integrating code. func (r *Registry) Languages() []string { var languages []string for lang := range r.LanguagesIter() { @@ -73,6 +80,7 @@ func (r *Registry) Languages() []string { } // LanguagesIter returns an iterator for all registered language identifiers. +// Usage example: call value.LanguagesIter(...) from integrating code. func (r *Registry) LanguagesIter() iter.Seq[string] { return func(yield func(string) bool) { // Sort keys for deterministic iteration @@ -95,5 +103,5 @@ func dockerUserArgs() []string { if runtime.GOOS == "windows" { return nil } - return []string{"--user", core.Sprintf("%d:%d", os.Getuid(), os.Getgid())} + return []string{"--user", core.Sprintf("%d:%d", ax.Getuid(), ax.Getgid())} } diff --git a/pkg/sdk/generators/go.go b/pkg/sdk/generators/go.go index 162f4b1..b0d7462 100644 --- a/pkg/sdk/generators/go.go +++ b/pkg/sdk/generators/go.go @@ -2,40 +2,44 @@ package generators import ( "context" - "fmt" - "os" - "os/exec" - "path/filepath" + "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // GoGenerator generates Go SDKs from OpenAPI specs. +// Usage example: declare a value of type generators.GoGenerator in integrating code. type GoGenerator struct{} // NewGoGenerator creates a new Go generator. +// Usage example: call generators.NewGoGenerator(...) from integrating code. func NewGoGenerator() *GoGenerator { return &GoGenerator{} } // Language returns the generator's target language identifier. +// Usage example: call value.Language(...) from integrating code. func (g *GoGenerator) Language() string { return "go" } // Available checks if generator dependencies are installed. +// Usage example: call value.Available(...) from integrating code. func (g *GoGenerator) Available() bool { - _, err := exec.LookPath("oapi-codegen") + _, err := ax.LookPath("oapi-codegen") return err == nil } // Install returns instructions for installing the generator. +// Usage example: call value.Install(...) from integrating code. func (g *GoGenerator) Install() string { return "go install github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@latest" } // Generate creates SDK from OpenAPI spec. +// Usage example: call value.Generate(...) from integrating code. func (g *GoGenerator) Generate(ctx context.Context, opts Options) error { if err := coreio.Local.EnsureDir(opts.OutputDir); err != nil { return coreerr.E("go.Generate", "failed to create output dir", err) @@ -51,28 +55,24 @@ func (g *GoGenerator) Generate(ctx context.Context, opts Options) error { } func (g *GoGenerator) generateNative(ctx context.Context, opts Options) error { - outputFile := filepath.Join(opts.OutputDir, "client.go") + outputFile := ax.Join(opts.OutputDir, "client.go") - cmd := exec.CommandContext(ctx, "oapi-codegen", + if err := ax.Exec(ctx, "oapi-codegen", "-package", opts.PackageName, "-generate", "types,client", "-o", outputFile, opts.SpecPath, - ) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + ); err != nil { return coreerr.E("go.generateNative", "oapi-codegen failed", err) } - goMod := fmt.Sprintf("module %s\n\ngo 1.21\n", opts.PackageName) - return coreio.Local.Write(filepath.Join(opts.OutputDir, "go.mod"), goMod) + goMod := core.Sprintf("module %s\n\ngo 1.21\n", opts.PackageName) + return coreio.Local.Write(ax.Join(opts.OutputDir, "go.mod"), goMod) } func (g *GoGenerator) generateDocker(ctx context.Context, opts Options) error { - specDir := filepath.Dir(opts.SpecPath) - specName := filepath.Base(opts.SpecPath) + specDir := ax.Dir(opts.SpecPath) + specName := ax.Base(opts.SpecPath) args := []string{"run", "--rm"} args = append(args, dockerUserArgs()...) @@ -86,8 +86,5 @@ func (g *GoGenerator) generateDocker(ctx context.Context, opts Options) error { "--additional-properties=packageName="+opts.PackageName, ) - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() + return ax.Exec(ctx, "docker", args...) } diff --git a/pkg/sdk/generators/go_test.go b/pkg/sdk/generators/go_test.go index 708b7dd..b97ea3c 100644 --- a/pkg/sdk/generators/go_test.go +++ b/pkg/sdk/generators/go_test.go @@ -2,13 +2,13 @@ package generators import ( "context" - "os" - "path/filepath" "testing" "time" + + "dappco.re/go/core/build/internal/ax" ) -func TestGoGenerator_Good_Available(t *testing.T) { +func TestGo_GoGeneratorAvailable_Good(t *testing.T) { g := NewGoGenerator() // These should not panic @@ -25,7 +25,7 @@ func TestGoGenerator_Good_Available(t *testing.T) { } } -func TestGoGenerator_Good_Generate(t *testing.T) { +func TestGo_GoGeneratorGenerate_Good(t *testing.T) { g := NewGoGenerator() if !g.Available() && !dockerAvailable() { t.Skip("no Go generator available (neither native nor docker)") @@ -34,7 +34,7 @@ func TestGoGenerator_Good_Generate(t *testing.T) { // Create temp directories tmpDir := t.TempDir() specPath := createTestSpec(t, tmpDir) - outputDir := filepath.Join(tmpDir, "output") + outputDir := ax.Join(tmpDir, "output") opts := Options{ SpecPath: specPath, @@ -52,7 +52,7 @@ func TestGoGenerator_Good_Generate(t *testing.T) { } // Verify output directory was created - if _, err := os.Stat(outputDir); os.IsNotExist(err) { + if !ax.Exists(outputDir) { t.Error("output directory was not created") } } diff --git a/pkg/sdk/generators/php.go b/pkg/sdk/generators/php.go index 73dc893..567aa64 100644 --- a/pkg/sdk/generators/php.go +++ b/pkg/sdk/generators/php.go @@ -2,38 +2,42 @@ package generators import ( "context" - "os" - "os/exec" - "path/filepath" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // PHPGenerator generates PHP SDKs from OpenAPI specs. +// Usage example: declare a value of type generators.PHPGenerator in integrating code. type PHPGenerator struct{} // NewPHPGenerator creates a new PHP generator. +// Usage example: call generators.NewPHPGenerator(...) from integrating code. func NewPHPGenerator() *PHPGenerator { return &PHPGenerator{} } // Language returns the generator's target language identifier. +// Usage example: call value.Language(...) from integrating code. func (g *PHPGenerator) Language() string { return "php" } // Available checks if generator dependencies are installed. +// Usage example: call value.Available(...) from integrating code. func (g *PHPGenerator) Available() bool { return dockerRuntimeAvailable() } // Install returns instructions for installing the generator. +// Usage example: call value.Install(...) from integrating code. func (g *PHPGenerator) Install() string { return "Docker is required for PHP SDK generation" } // Generate creates SDK from OpenAPI spec. +// Usage example: call value.Generate(...) from integrating code. func (g *PHPGenerator) Generate(ctx context.Context, opts Options) error { if !g.Available() { return coreerr.E("php.Generate", "Docker is required but not available", nil) @@ -43,8 +47,8 @@ func (g *PHPGenerator) Generate(ctx context.Context, opts Options) error { return coreerr.E("php.Generate", "failed to create output dir", err) } - specDir := filepath.Dir(opts.SpecPath) - specName := filepath.Base(opts.SpecPath) + specDir := ax.Dir(opts.SpecPath) + specName := ax.Base(opts.SpecPath) args := []string{"run", "--rm"} args = append(args, dockerUserArgs()...) @@ -58,11 +62,7 @@ func (g *PHPGenerator) Generate(ctx context.Context, opts Options) error { "--additional-properties=invokerPackage="+opts.PackageName, ) - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", args...); err != nil { return coreerr.E("php.Generate", "docker run failed", err) } return nil diff --git a/pkg/sdk/generators/php_test.go b/pkg/sdk/generators/php_test.go index a3a6e4a..a980dff 100644 --- a/pkg/sdk/generators/php_test.go +++ b/pkg/sdk/generators/php_test.go @@ -2,13 +2,13 @@ package generators import ( "context" - "os" - "path/filepath" "testing" "time" + + "dappco.re/go/core/build/internal/ax" ) -func TestPHPGenerator_Good_Available(t *testing.T) { +func TestPHP_PHPGeneratorAvailable_Good(t *testing.T) { g := NewPHPGenerator() // These should not panic @@ -25,7 +25,7 @@ func TestPHPGenerator_Good_Available(t *testing.T) { } } -func TestPHPGenerator_Good_Generate(t *testing.T) { +func TestPHP_PHPGeneratorGenerate_Good(t *testing.T) { g := NewPHPGenerator() if !g.Available() { t.Skip("no PHP generator available (docker not installed)") @@ -34,7 +34,7 @@ func TestPHPGenerator_Good_Generate(t *testing.T) { // Create temp directories tmpDir := t.TempDir() specPath := createTestSpec(t, tmpDir) - outputDir := filepath.Join(tmpDir, "output") + outputDir := ax.Join(tmpDir, "output") opts := Options{ SpecPath: specPath, @@ -52,7 +52,7 @@ func TestPHPGenerator_Good_Generate(t *testing.T) { } // Verify output directory was created - if _, err := os.Stat(outputDir); os.IsNotExist(err) { + if !ax.Exists(outputDir) { t.Error("output directory was not created") } } diff --git a/pkg/sdk/generators/python.go b/pkg/sdk/generators/python.go index 6f34222..6f41838 100644 --- a/pkg/sdk/generators/python.go +++ b/pkg/sdk/generators/python.go @@ -2,39 +2,43 @@ package generators import ( "context" - "os" - "os/exec" - "path/filepath" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // PythonGenerator generates Python SDKs from OpenAPI specs. +// Usage example: declare a value of type generators.PythonGenerator in integrating code. type PythonGenerator struct{} // NewPythonGenerator creates a new Python generator. +// Usage example: call generators.NewPythonGenerator(...) from integrating code. func NewPythonGenerator() *PythonGenerator { return &PythonGenerator{} } // Language returns the generator's target language identifier. +// Usage example: call value.Language(...) from integrating code. func (g *PythonGenerator) Language() string { return "python" } // Available checks if generator dependencies are installed. +// Usage example: call value.Available(...) from integrating code. func (g *PythonGenerator) Available() bool { - _, err := exec.LookPath("openapi-python-client") + _, err := ax.LookPath("openapi-python-client") return err == nil } // Install returns instructions for installing the generator. +// Usage example: call value.Install(...) from integrating code. func (g *PythonGenerator) Install() string { return "pip install openapi-python-client" } // Generate creates SDK from OpenAPI spec. +// Usage example: call value.Generate(...) from integrating code. func (g *PythonGenerator) Generate(ctx context.Context, opts Options) error { if err := coreio.Local.EnsureDir(opts.OutputDir); err != nil { return coreerr.E("python.Generate", "failed to create output dir", err) @@ -50,21 +54,17 @@ func (g *PythonGenerator) Generate(ctx context.Context, opts Options) error { } func (g *PythonGenerator) generateNative(ctx context.Context, opts Options) error { - parentDir := filepath.Dir(opts.OutputDir) + parentDir := ax.Dir(opts.OutputDir) - cmd := exec.CommandContext(ctx, "openapi-python-client", "generate", + return ax.ExecDir(ctx, parentDir, "openapi-python-client", "generate", "--path", opts.SpecPath, "--output-path", opts.OutputDir, ) - cmd.Dir = parentDir - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() } func (g *PythonGenerator) generateDocker(ctx context.Context, opts Options) error { - specDir := filepath.Dir(opts.SpecPath) - specName := filepath.Base(opts.SpecPath) + specDir := ax.Dir(opts.SpecPath) + specName := ax.Base(opts.SpecPath) args := []string{"run", "--rm"} args = append(args, dockerUserArgs()...) @@ -78,8 +78,5 @@ func (g *PythonGenerator) generateDocker(ctx context.Context, opts Options) erro "--additional-properties=packageName="+opts.PackageName, ) - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() + return ax.Exec(ctx, "docker", args...) } diff --git a/pkg/sdk/generators/python_test.go b/pkg/sdk/generators/python_test.go index 5b03a76..aa58fcb 100644 --- a/pkg/sdk/generators/python_test.go +++ b/pkg/sdk/generators/python_test.go @@ -2,13 +2,13 @@ package generators import ( "context" - "os" - "path/filepath" "testing" "time" + + "dappco.re/go/core/build/internal/ax" ) -func TestPythonGenerator_Good_Available(t *testing.T) { +func TestPython_PythonGeneratorAvailable_Good(t *testing.T) { g := NewPythonGenerator() // These should not panic @@ -25,7 +25,7 @@ func TestPythonGenerator_Good_Available(t *testing.T) { } } -func TestPythonGenerator_Good_Generate(t *testing.T) { +func TestPython_PythonGeneratorGenerate_Good(t *testing.T) { g := NewPythonGenerator() if !g.Available() && !dockerAvailable() { t.Skip("no Python generator available (neither native nor docker)") @@ -34,7 +34,7 @@ func TestPythonGenerator_Good_Generate(t *testing.T) { // Create temp directories tmpDir := t.TempDir() specPath := createTestSpec(t, tmpDir) - outputDir := filepath.Join(tmpDir, "output") + outputDir := ax.Join(tmpDir, "output") opts := Options{ SpecPath: specPath, @@ -52,7 +52,7 @@ func TestPythonGenerator_Good_Generate(t *testing.T) { } // Verify output directory was created - if _, err := os.Stat(outputDir); os.IsNotExist(err) { + if !ax.Exists(outputDir) { t.Error("output directory was not created") } } diff --git a/pkg/sdk/generators/typescript.go b/pkg/sdk/generators/typescript.go index 94b7971..00d3de1 100644 --- a/pkg/sdk/generators/typescript.go +++ b/pkg/sdk/generators/typescript.go @@ -2,43 +2,47 @@ package generators import ( "context" - "os" - "os/exec" - "path/filepath" + "dappco.re/go/core/build/internal/ax" coreio "dappco.re/go/core/io" coreerr "dappco.re/go/core/log" ) // TypeScriptGenerator generates TypeScript SDKs from OpenAPI specs. +// Usage example: declare a value of type generators.TypeScriptGenerator in integrating code. type TypeScriptGenerator struct{} // NewTypeScriptGenerator creates a new TypeScript generator. +// Usage example: call generators.NewTypeScriptGenerator(...) from integrating code. func NewTypeScriptGenerator() *TypeScriptGenerator { return &TypeScriptGenerator{} } // Language returns the generator's target language identifier. +// Usage example: call value.Language(...) from integrating code. func (g *TypeScriptGenerator) Language() string { return "typescript" } // Available checks if generator dependencies are installed. +// Usage example: call value.Available(...) from integrating code. func (g *TypeScriptGenerator) Available() bool { - _, err := exec.LookPath("openapi-typescript-codegen") + _, err := ax.LookPath("openapi-typescript-codegen") if err == nil { return true } - _, err = exec.LookPath("npx") + _, err = ax.LookPath("npx") return err == nil } // Install returns instructions for installing the generator. +// Usage example: call value.Install(...) from integrating code. func (g *TypeScriptGenerator) Install() string { return "npm install -g openapi-typescript-codegen" } // Generate creates SDK from OpenAPI spec. +// Usage example: call value.Generate(...) from integrating code. func (g *TypeScriptGenerator) Generate(ctx context.Context, opts Options) error { if err := coreio.Local.EnsureDir(opts.OutputDir); err != nil { return coreerr.E("typescript.Generate", "failed to create output dir", err) @@ -57,40 +61,34 @@ func (g *TypeScriptGenerator) Generate(ctx context.Context, opts Options) error } func (g *TypeScriptGenerator) nativeAvailable() bool { - _, err := exec.LookPath("openapi-typescript-codegen") + _, err := ax.LookPath("openapi-typescript-codegen") return err == nil } func (g *TypeScriptGenerator) npxAvailable() bool { - _, err := exec.LookPath("npx") + _, err := ax.LookPath("npx") return err == nil } func (g *TypeScriptGenerator) generateNative(ctx context.Context, opts Options) error { - cmd := exec.CommandContext(ctx, "openapi-typescript-codegen", + return ax.Exec(ctx, "openapi-typescript-codegen", "--input", opts.SpecPath, "--output", opts.OutputDir, "--name", opts.PackageName, ) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() } func (g *TypeScriptGenerator) generateNpx(ctx context.Context, opts Options) error { - cmd := exec.CommandContext(ctx, "npx", "openapi-typescript-codegen", + return ax.Exec(ctx, "npx", "openapi-typescript-codegen", "--input", opts.SpecPath, "--output", opts.OutputDir, "--name", opts.PackageName, ) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() } func (g *TypeScriptGenerator) generateDocker(ctx context.Context, opts Options) error { - specDir := filepath.Dir(opts.SpecPath) - specName := filepath.Base(opts.SpecPath) + specDir := ax.Dir(opts.SpecPath) + specName := ax.Base(opts.SpecPath) args := []string{"run", "--rm"} args = append(args, dockerUserArgs()...) @@ -104,11 +102,7 @@ func (g *TypeScriptGenerator) generateDocker(ctx context.Context, opts Options) "--additional-properties=npmName="+opts.PackageName, ) - cmd := exec.CommandContext(ctx, "docker", args...) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - - if err := cmd.Run(); err != nil { + if err := ax.Exec(ctx, "docker", args...); err != nil { return coreerr.E("typescript.generateDocker", "docker run failed", err) } return nil diff --git a/pkg/sdk/generators/typescript_test.go b/pkg/sdk/generators/typescript_test.go index f5528eb..941a338 100644 --- a/pkg/sdk/generators/typescript_test.go +++ b/pkg/sdk/generators/typescript_test.go @@ -2,20 +2,15 @@ package generators import ( "context" - "io" - "os" - "os/exec" - "path/filepath" "testing" "time" + + "dappco.re/go/core/build/internal/ax" ) // dockerAvailable checks if docker is available for fallback generation. func dockerAvailable() bool { - cmd := exec.Command("docker", "info") - cmd.Stdout = io.Discard - cmd.Stderr = io.Discard - return cmd.Run() == nil + return ax.Exec(context.Background(), "docker", "info") == nil } // createTestSpec creates a minimal OpenAPI spec for testing. @@ -33,14 +28,14 @@ paths: "200": description: OK ` - specPath := filepath.Join(dir, "openapi.yaml") - if err := os.WriteFile(specPath, []byte(spec), 0644); err != nil { + specPath := ax.Join(dir, "openapi.yaml") + if err := ax.WriteFile(specPath, []byte(spec), 0o644); err != nil { t.Fatalf("failed to write test spec: %v", err) } return specPath } -func TestTypeScriptGenerator_Good_Available(t *testing.T) { +func TestTypeScript_TypeScriptGeneratorAvailable_Good(t *testing.T) { g := NewTypeScriptGenerator() // These should not panic @@ -57,7 +52,7 @@ func TestTypeScriptGenerator_Good_Available(t *testing.T) { } } -func TestTypeScriptGenerator_Good_Generate(t *testing.T) { +func TestTypeScript_TypeScriptGeneratorGenerate_Good(t *testing.T) { g := NewTypeScriptGenerator() if !g.Available() && !dockerAvailable() { t.Skip("no TypeScript generator available (neither native nor docker)") @@ -66,7 +61,7 @@ func TestTypeScriptGenerator_Good_Generate(t *testing.T) { // Create temp directories tmpDir := t.TempDir() specPath := createTestSpec(t, tmpDir) - outputDir := filepath.Join(tmpDir, "output") + outputDir := ax.Join(tmpDir, "output") opts := Options{ SpecPath: specPath, @@ -84,7 +79,7 @@ func TestTypeScriptGenerator_Good_Generate(t *testing.T) { } // Verify output directory was created - if _, err := os.Stat(outputDir); os.IsNotExist(err) { + if !ax.Exists(outputDir) { t.Error("output directory was not created") } } diff --git a/pkg/sdk/sdk.go b/pkg/sdk/sdk.go index 00cbfd5..0de8037 100644 --- a/pkg/sdk/sdk.go +++ b/pkg/sdk/sdk.go @@ -3,14 +3,15 @@ package sdk import ( "context" - "path/filepath" "dappco.re/go/core" + "dappco.re/go/core/build/internal/ax" "dappco.re/go/core/build/pkg/sdk/generators" coreerr "dappco.re/go/core/log" ) // Config holds SDK generation configuration from .core/release.yaml. +// Usage example: declare a value of type sdk.Config in integrating code. type Config struct { // Spec is the path to the OpenAPI spec file (auto-detected if empty). Spec string `yaml:"spec,omitempty"` @@ -27,6 +28,7 @@ type Config struct { } // PackageConfig holds package naming configuration. +// Usage example: declare a value of type sdk.PackageConfig in integrating code. type PackageConfig struct { // Name is the base package name. Name string `yaml:"name,omitempty"` @@ -35,6 +37,7 @@ type PackageConfig struct { } // DiffConfig holds breaking change detection configuration. +// Usage example: declare a value of type sdk.DiffConfig in integrating code. type DiffConfig struct { // Enabled determines whether to run diff checks. Enabled bool `yaml:"enabled,omitempty"` @@ -43,6 +46,7 @@ type DiffConfig struct { } // PublishConfig holds monorepo publishing configuration. +// Usage example: declare a value of type sdk.PublishConfig in integrating code. type PublishConfig struct { // Repo is the SDK monorepo (e.g., "myorg/sdks"). Repo string `yaml:"repo,omitempty"` @@ -51,6 +55,7 @@ type PublishConfig struct { } // SDK orchestrates OpenAPI SDK generation. +// Usage example: declare a value of type sdk.SDK in integrating code. type SDK struct { config *Config projectDir string @@ -58,6 +63,7 @@ type SDK struct { } // New creates a new SDK instance. +// Usage example: call sdk.New(...) from integrating code. func New(projectDir string, config *Config) *SDK { if config == nil { config = DefaultConfig() @@ -70,6 +76,7 @@ func New(projectDir string, config *Config) *SDK { // SetVersion sets the SDK version for generation. // This updates both the internal version field and the config's Package.Version. +// Usage example: call value.SetVersion(...) from integrating code. func (s *SDK) SetVersion(version string) { s.version = version if s.config != nil { @@ -78,6 +85,7 @@ func (s *SDK) SetVersion(version string) { } // DefaultConfig returns sensible defaults for SDK configuration. +// Usage example: call sdk.DefaultConfig(...) from integrating code. func DefaultConfig() *Config { return &Config{ Languages: []string{"typescript", "python", "go", "php"}, @@ -90,6 +98,7 @@ func DefaultConfig() *Config { } // Generate generates SDKs for all configured languages. +// Usage example: call value.Generate(...) from integrating code. func (s *SDK) Generate(ctx context.Context) error { // Generate for each language for _, lang := range s.config.Languages { @@ -102,6 +111,7 @@ func (s *SDK) Generate(ctx context.Context) error { } // GenerateLanguage generates SDK for a specific language. +// Usage example: call value.GenerateLanguage(...) from integrating code. func (s *SDK) GenerateLanguage(ctx context.Context, lang string) error { specPath, err := s.DetectSpec() if err != nil { @@ -124,7 +134,7 @@ func (s *SDK) GenerateLanguage(ctx context.Context, lang string) error { core.Print(nil, "Falling back to Docker...") } - outputDir := filepath.Join(s.projectDir, s.config.Output, lang) + outputDir := ax.Join(s.projectDir, s.config.Output, lang) opts := generators.Options{ SpecPath: specPath, OutputDir: outputDir, diff --git a/pkg/sdk/sdk_test.go b/pkg/sdk/sdk_test.go index ced3b91..c3d9d20 100644 --- a/pkg/sdk/sdk_test.go +++ b/pkg/sdk/sdk_test.go @@ -2,22 +2,22 @@ package sdk import ( "context" - "os" - "path/filepath" "testing" + "dappco.re/go/core/build/internal/ax" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestSDK_Good_SetVersion(t *testing.T) { +func TestSDK_SetVersion_Good(t *testing.T) { s := New("/tmp", nil) s.SetVersion("v1.2.3") assert.Equal(t, "v1.2.3", s.version) } -func TestSDK_Good_VersionPassedToGenerator(t *testing.T) { +func TestSDK_VersionPassedToGenerator_Good(t *testing.T) { config := &Config{ Languages: []string{"typescript"}, Output: "sdk", @@ -31,14 +31,14 @@ func TestSDK_Good_VersionPassedToGenerator(t *testing.T) { assert.Equal(t, "v2.0.0", s.config.Package.Version) } -func TestDefaultConfig(t *testing.T) { +func TestSDK_DefaultConfig_Good(t *testing.T) { cfg := DefaultConfig() assert.Contains(t, cfg.Languages, "typescript") assert.Equal(t, "sdk", cfg.Output) assert.True(t, cfg.Diff.Enabled) } -func TestSDK_New(t *testing.T) { +func TestSDK_New_Good(t *testing.T) { t.Run("with nil config", func(t *testing.T) { s := New("/tmp", nil) assert.NotNil(t, s.config) @@ -58,9 +58,9 @@ func TestSDK_GenerateLanguage_Bad(t *testing.T) { tmpDir := t.TempDir() - specPath := filepath.Join(tmpDir, "openapi.yaml") + specPath := ax.Join(tmpDir, "openapi.yaml") - err := os.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) + err := ax.WriteFile(specPath, []byte("openapi: 3.0.0"), 0644) require.NoError(t, err)