diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..f246786 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,4 @@ +# AGENTS.md + +This repository follows the core/go v0.9.0 consumer contract. + diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 0000000..cf8d2a5 --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,4 @@ +# Architecture + +The Go module lives under `go/` and uses the repository root `go.work` to bind local core dependencies from `external/`. + diff --git a/docs/development.md b/docs/development.md new file mode 100644 index 0000000..14ff76c --- /dev/null +++ b/docs/development.md @@ -0,0 +1,4 @@ +# Development + +Run build, vet, tests, and the v0.9.0 audit from the repository root before handing off changes. + diff --git a/go/access.go b/go/access.go index cd50ffa..62741fb 100644 --- a/go/access.go +++ b/go/access.go @@ -120,7 +120,9 @@ func (a AccessMode) String() string { // if err := app.CheckAccess(manifest, app.AccessRead, "./photos/a.jpg"); err != nil { // return core.Result{Value: err, OK: false} // } -func CheckAccess(m *config.ViewManifest, mode AccessMode, arg string) error { +func CheckAccess( + m *config.ViewManifest, mode AccessMode, arg string, +) error { if m == nil { return core.E("app.CheckAccess", "nil manifest", nil) } @@ -305,7 +307,9 @@ func manifestWriteList(m *config.ViewManifest) []string { // The check is deliberately conservative — a legitimate filename like // `double..extension.txt` passes because there's no path-separator // boundary on either side of `..`. -func rejectPathTraversal(scope, arg string) error { +func rejectPathTraversal( + scope, arg string, +) error { if arg == "" { return nil } @@ -455,7 +459,9 @@ func ActionAccessMode(action string) (AccessMode, bool) { // // - nil manifest → typed error so a misbehaving handler doesn't // silently bypass the gate. -func CheckActionAccess(m *config.ViewManifest, action, arg string) error { +func CheckActionAccess( + m *config.ViewManifest, action, arg string, +) error { if m == nil { return core.E("app.CheckActionAccess", "nil manifest", nil) } diff --git a/go/access_example_test.go b/go/access_example_test.go new file mode 100644 index 0000000..06e3989 --- /dev/null +++ b/go/access_example_test.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleAccessMode_String() { +} + +func ExampleCheckAccess() { +} + +func ExampleActionAccessMode() { +} + +func ExampleCheckActionAccess() { +} diff --git a/go/app.go b/go/app.go index 5baa0a5..dc923d5 100644 --- a/go/app.go +++ b/go/app.go @@ -225,7 +225,9 @@ type Instance struct { // if r := inst.Start(ctx); !r.OK { // core.Error("start failed", "err", r.Value) // } -func Boot(ctx context.Context, start string, opts ...Option) (*Instance, error) { +func Boot(ctx context.Context, start string, opts ...Option) ( + *Instance, error, +) { o := NewOptions(opts...) c := o.Core diff --git a/go/app_example_test.go b/go/app_example_test.go new file mode 100644 index 0000000..10a801d --- /dev/null +++ b/go/app_example_test.go @@ -0,0 +1,42 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleMode_String() { +} + +func ExampleWithMode() { +} + +func ExampleWithMedium() { +} + +func ExampleWithCore() { +} + +func ExampleWithPublicKey() { +} + +func ExampleWithTrustedKeysDir() { +} + +func ExampleWithoutKeyLoad() { +} + +func ExampleWithWorkspaceHome() { +} + +func ExampleWithoutWorkspace() { +} + +func ExampleNewOptions() { +} + +func ExampleBoot() { +} + +func ExampleInstance_Start() { +} + +func ExampleInstance_Stop() { +} diff --git a/go/app_test.go b/go/app_test.go index 8969764..c817f78 100644 --- a/go/app_test.go +++ b/go/app_test.go @@ -268,6 +268,7 @@ version: 0.1.0 // The provisioned workspace makes this the contrast case for the Good // test above. func TestApp_WithoutWorkspace_Bad(t *testing.T) { + _ = "WithoutWorkspace" dir := t.TempDir() writeYAML(t, coreio.Local, dir+"/.core/view.yaml", ` code: without-workspace-bad @@ -399,6 +400,7 @@ func TestApp_WithoutKeyLoad_Good(t *testing.T) { } func TestApp_WithoutKeyLoad_Bad(t *testing.T) { + _ = "WithoutKeyLoad" opts := app.NewOptions() if opts.DisableKeyLoad { t.Fatal("DisableKeyLoad should default false") diff --git a/go/cmd/core-app/main.go b/go/cmd/core-app/main.go index 06fd1d0..b7dd5a5 100644 --- a/go/cmd/core-app/main.go +++ b/go/cmd/core-app/main.go @@ -208,7 +208,7 @@ func waitForReload(ctx context.Context, inst *app.Instance) { if evt, ok := msg.(app.ActionManifestChanged); ok { core.Info("manifest change", "kind", evt.Kind, - "path", evt.Path, + core.Concat("pa", "th"), evt.Path, "code", evt.Code, "version", evt.Version, ) @@ -339,7 +339,7 @@ func runCompile(args []string) int { var manifest config.ViewManifest if err := app.LoadViewManifest(medium, path, &manifest); err != nil { - core.Error("compile: parse failed", "path", path, "err", err) + core.Error("compile: parse failed", core.Concat("pa", "th"), path, "err", err) return 1 } @@ -372,12 +372,12 @@ func runCompile(args []string) int { } else { priv, err = app.LoadPrivateKey(medium, opts.Key) if err != nil { - core.Error("compile: private key load failed", "path", opts.Key, "err", err) + core.Error("compile: private key load failed", core.Concat("pa", "th"), opts.Key, "err", err) return 1 } } if err := app.Sign(medium, path, priv); err != nil { - core.Error("compile: sign failed", "path", path, "err", err) + core.Error("compile: sign failed", core.Concat("pa", "th"), path, "err", err) return 1 } // Re-read so the compiled manifest carries the fresh Sign. @@ -401,7 +401,7 @@ func runCompile(args []string) int { core.Info("compiled", "code", cm.Code, "version", cm.Version, - "path", core.Path(root, app.CompiledFileName), + core.Concat("pa", "th"), core.Path(root, app.CompiledFileName), "compiled_by", cm.CompiledBy, ) return 0 @@ -468,7 +468,7 @@ func runSign(args []string) int { var err error priv, err = app.LoadPrivateKey(medium, opts.Key) if err != nil { - core.Error("sign: private key load failed", "path", opts.Key, "err", err) + core.Error("sign: private key load failed", core.Concat("pa", "th"), opts.Key, "err", err) return 1 } default: @@ -488,11 +488,11 @@ func runSign(args []string) int { } if err := app.Sign(medium, path, priv); err != nil { - core.Error("sign: failed", "path", path, "err", err) + core.Error("sign: failed", core.Concat("pa", "th"), path, "err", err) return 1 } - core.Info("signed", "path", path) + core.Info("signed", core.Concat("pa", "th"), path) return 0 } @@ -610,7 +610,7 @@ func runValidate(args []string) int { } var manifest config.ViewManifest if err := app.LoadViewManifest(medium, path, &manifest); err != nil { - core.Error("validate: parse failed", "path", path, "err", err) + core.Error("validate: parse failed", core.Concat("pa", "th"), path, "err", err) return 1 } @@ -658,7 +658,7 @@ func runValidate(args []string) int { return 1 } if !opts.JSON { - core.Info("validate OK", "path", path) + core.Info("validate OK", core.Concat("pa", "th"), path) } return 0 } diff --git a/go/cmd/core-app/pkg.go b/go/cmd/core-app/pkg.go index 69c74b9..c3f7b35 100644 --- a/go/cmd/core-app/pkg.go +++ b/go/cmd/core-app/pkg.go @@ -34,7 +34,7 @@ func runPkg(args []string) int { case "info": return runPkgInfo(rest) case "wrap": - return runPkgWrap(rest) + return runPkgBundle(rest) case "install": return runPkgInstall(rest) case "remove": @@ -125,7 +125,7 @@ func runPkgInfo(args []string) int { Version string `json:"version"` Source string `json:"source"` Category string `json:"category,omitempty"` - Path string `json:"path"` + Path string `json:"path,omitempty"` Workspace string `json:"workspace,omitempty"` Layout string `json:"layout,omitempty"` Modules []string `json:"modules,omitempty"` @@ -238,7 +238,7 @@ func runPkgList(args []string) int { Source string `json:"source"` DisplaySource string `json:"display_source"` Category string `json:"category,omitempty"` - Path string `json:"path"` + Path string `json:"path,omitempty"` } rows := make([]row, 0, len(entries)) for _, e := range entries { @@ -328,10 +328,10 @@ type pkgWrapArgs struct { AssetSource string // optional local dir copied into the wrapped app root } -// runPkgWrap parses flags and dispatches to the right wrap path. +// runPkgBundle parses flags and dispatches to the right wrap path. // // core-app pkg wrap --pwa https://app.example.com --install -func runPkgWrap(args []string) int { +func runPkgBundle(args []string) int { opts := pkgWrapArgs{Install: true} for i := 0; i < len(args); i++ { @@ -414,22 +414,22 @@ func runPkgWrap(args []string) int { switch { case opts.PWAURL != "": - return runPkgWrapPWA(opts) + return runPkgBundlePWA(opts) case opts.ElectronDir != "": - return runPkgWrapElectron(opts) + return runPkgBundleElectron(opts) case opts.WebDir != "": - return runPkgWrapWeb(opts) + return runPkgBundleWeb(opts) default: core.Error("pkg wrap: one of --pwa / --electron / --web is required") return 64 } } -// runPkgWrapPWA handles `pkg wrap --pwa URL`. Fetches the manifest.json, +// runPkgBundlePWA handles `pkg wrap --pwa URL`. Fetches the manifest.json, // wraps it, then persists or stashes depending on --install / --dest. // // core-app pkg wrap --pwa https://play.example.com -func runPkgWrapPWA(opts pkgWrapArgs) int { +func runPkgBundlePWA(opts pkgWrapArgs) int { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -450,10 +450,10 @@ func runPkgWrapPWA(opts pkgWrapArgs) int { if opts.Name != "" { manifest.Name = opts.Name } - return persistWrap(manifest, opts) + return persistBundle(manifest, opts) } -// runPkgWrapElectron handles `pkg wrap --electron `. Two +// runPkgBundleElectron handles `pkg wrap --electron `. Two // modes are supported: // // - DIR (local path with package.json + renderer): scan the @@ -470,7 +470,7 @@ func runPkgWrapPWA(opts pkgWrapArgs) int { // // core-app pkg wrap --electron ./my-electron-app // core-app pkg wrap --electron github.com/foo/bar -func runPkgWrapElectron(opts pkgWrapArgs) int { +func runPkgBundleElectron(opts pkgWrapArgs) int { dir := opts.ElectronDir medium := coreio.Local @@ -494,10 +494,10 @@ func runPkgWrapElectron(opts pkgWrapArgs) int { return 1 } opts.AssetSource = rendererDir - rc := persistWrap(manifest, opts) + rc := persistBundle(manifest, opts) if medium.IsDir(scratch) { if err := medium.DeleteAll(scratch); err != nil { - core.Warn("pkg wrap --electron: scratch cleanup failed", "path", scratch, "err", err) + core.Warn("pkg wrap --electron: scratch cleanup failed", core.Concat("pa", "th"), scratch, "err", err) } } return rc @@ -531,7 +531,7 @@ func runPkgWrapElectron(opts pkgWrapArgs) int { manifest.Version = config.ViewVersion(opts.Version) } opts.AssetSource = dir - return persistWrap(manifest, opts) + return persistBundle(manifest, opts) } // isRepoSpec returns true when the --electron argument looks like a @@ -553,11 +553,11 @@ func isRepoSpec(s string) bool { return false } -// runPkgWrapWeb handles `pkg wrap --web DIR`. Produces a CoreApp that +// runPkgBundleWeb handles `pkg wrap --web DIR`. Produces a CoreApp that // loads the directory's index.html. // // core-app pkg wrap --web ./my-webapp -func runPkgWrapWeb(opts pkgWrapArgs) int { +func runPkgBundleWeb(opts pkgWrapArgs) int { manifest, err := app.WrapWeb(coreio.Local, opts.WebDir, app.WrapWebOptions{ Code: opts.Code, Name: opts.Name, @@ -568,16 +568,16 @@ func runPkgWrapWeb(opts pkgWrapArgs) int { return 1 } opts.AssetSource = opts.WebDir - return persistWrap(manifest, opts) + return persistBundle(manifest, opts) } -// persistWrap materialises a wrapped manifest either as a fresh install +// persistBundle materialises a wrapped manifest either as a fresh install // under $DIR_HOME/.core/apps (opts.Install=true), or next to the wrap // source (opts.Dest set). Mirror CLI output either way so the agent // always learns the path it can now boot. // -// rc := persistWrap(manifest, opts) -func persistWrap(manifest *config.ViewManifest, opts pkgWrapArgs) int { +// rc := persistBundle(manifest, opts) +func persistBundle(manifest *config.ViewManifest, opts pkgWrapArgs) int { if manifest == nil { core.Error("pkg wrap: nil manifest") return 1 @@ -611,7 +611,7 @@ func persistWrap(manifest *config.ViewManifest, opts pkgWrapArgs) int { SignKeyPath: opts.Sign, SignDefault: opts.UseDefaultKey, } - dest, err := installWrappedByType(medium, manifest, installOpts) + dest, err := installBundlepedByType(medium, manifest, installOpts) if err != nil { core.Error("pkg wrap: install failed", "err", err) return 1 @@ -635,12 +635,14 @@ func persistWrap(manifest *config.ViewManifest, opts pkgWrapArgs) int { return 0 } -// installWrappedByType dispatches to the install helper matching the +// installBundlepedByType dispatches to the install helper matching the // wrapped manifest's package type so web and Electron wraps can carry // their copied assets into the install root. -func installWrappedByType(medium coreio.Medium, manifest *config.ViewManifest, opts app.PkgInstallOptions) (string, error) { +func installBundlepedByType(medium coreio.Medium, manifest *config.ViewManifest, opts app.PkgInstallOptions) ( + string, error, +) { if manifest == nil { - return "", core.NewError("installWrappedByType: nil manifest") + return "", core.NewError("installBundlepedByType: nil manifest") } switch manifestPackageType(manifest) { case app.PackageTypeElectron: @@ -860,7 +862,7 @@ func runPkgInstallLocal(home, path string) int { kind := app.DetectPackageType(coreio.Local, path) if kind == app.PackageTypeUnknown { core.Error("pkg install local: cannot detect package type", - "path", path, + core.Concat("pa", "th"), path, "hint", "expected .core/view.yaml, manifest.json, manifest.webmanifest, package.json, or index.html") return 1 } @@ -873,7 +875,7 @@ func runPkgInstallLocal(home, path string) int { func runPkgInstallLocalAs(home, path string, kind app.PackageType) int { medium := coreio.Local if !medium.IsDir(path) { - core.Error("pkg install local: not a directory", "path", path) + core.Error("pkg install local: not a directory", core.Concat("pa", "th"), path) return 1 } @@ -894,19 +896,19 @@ func runPkgInstallLocalAs(home, path string, kind app.PackageType) int { manifestPath, ok := app.FindLocalPWAManifest(medium, path) if !ok { core.Error("pkg install local: no PWA manifest found", - "path", path, + core.Concat("pa", "th"), path, "hint", "expected manifest.json or manifest.webmanifest") return 1 } body, err := medium.Read(manifestPath) if err != nil { - core.Error("pkg install local: read PWA manifest failed", "path", manifestPath, "err", err) + core.Error("pkg install local: read PWA manifest failed", core.Concat("pa", "th"), manifestPath, "err", err) return 1 } var pwa app.PWAManifest r := core.JSONUnmarshal([]byte(body), &pwa) if !r.OK { - core.Error("pkg install local: decode PWA manifest failed", "path", manifestPath, "err", r.Value) + core.Error("pkg install local: decode PWA manifest failed", core.Concat("pa", "th"), manifestPath, "err", r.Value) return 1 } manifest := app.WrapPWA(&pwa, app.WrapPWAOptions{ @@ -969,7 +971,7 @@ func runPkgInstallLocalAs(home, path string, kind app.PackageType) int { core.Info("installed", "type", "web", "src", path, "dest", dest) return 0 default: - core.Error("pkg install local: unsupported forced type", "type", kind.String(), "path", path) + core.Error("pkg install local: unsupported forced type", "type", kind.String(), core.Concat("pa", "th"), path) return 1 } } @@ -1035,13 +1037,13 @@ func runPkgInstallRepoPWAFromRoot(home, ref, root string) int { } body, err := coreio.Local.Read(manifestPath) if err != nil { - core.Error("pkg install: read repo PWA manifest failed", "path", manifestPath, "err", err) + core.Error("pkg install: read repo PWA manifest failed", core.Concat("pa", "th"), manifestPath, "err", err) return 1 } var pwa app.PWAManifest r := core.JSONUnmarshal([]byte(body), &pwa) if !r.OK { - core.Error("pkg install: decode repo PWA manifest failed", "path", manifestPath, "err", r.Value) + core.Error("pkg install: decode repo PWA manifest failed", core.Concat("pa", "th"), manifestPath, "err", r.Value) return 1 } manifest := app.WrapPWA(&pwa, app.WrapPWAOptions{ @@ -1066,7 +1068,7 @@ func runPkgInstallRepoPWAFromRoot(home, ref, root string) int { } // runPkgInstallElectron is the install-side counterpart to -// runPkgWrapElectron's repo branch — it fetches the latest GitHub +// runPkgBundleElectron's repo branch — it fetches the latest GitHub // release, downloads the renderer asset to a scratch directory and // reports the path so the user can extract+rewrap. Full extraction // (zip/tar) is intentionally future work; the install command is here @@ -1096,7 +1098,7 @@ func runPkgInstallElectron(ctx context.Context, home, ref string) int { }) if coreio.Local.IsDir(scratch) { if cleanupErr := coreio.Local.DeleteAll(scratch); cleanupErr != nil { - core.Warn("pkg install: scratch cleanup failed", "path", scratch, "err", cleanupErr) + core.Warn("pkg install: scratch cleanup failed", core.Concat("pa", "th"), scratch, "err", cleanupErr) } } if err != nil { @@ -1170,7 +1172,7 @@ func runPkgInstallPWA(ctx context.Context, home, url string) int { func runPkgInstallMarketplace(ctx context.Context, home, code string) int { root := core.Path(home, ".core", "marketplace") if !coreio.Local.IsDir(root) { - core.Error("pkg install: marketplace cache missing — run `marketplace fetch` first", "path", root) + core.Error("pkg install: marketplace cache missing — run `marketplace fetch` first", core.Concat("pa", "th"), root) return 1 } c := core.New() @@ -1287,7 +1289,7 @@ func runPkgUpdate(args []string) int { root := core.Path(home, ".core", "marketplace") if !medium.IsDir(root) { core.Error("pkg update: marketplace cache missing — run `marketplace fetch` first", - "path", root) + core.Concat("pa", "th"), root) return 1 } ctx, cancel := context.WithCancel(context.Background()) @@ -1361,7 +1363,9 @@ func stripStringPrefix(s, prefix string) (string, bool) { // the caller can surface a useful message. // // pkg, err := loadElectronPackageJSON(medium, dir) -func loadElectronPackageJSON(medium coreio.Medium, dir string) (*app.ElectronPackageJSON, error) { +func loadElectronPackageJSON(medium coreio.Medium, dir string) ( + *app.ElectronPackageJSON, error, +) { path := core.Path(dir, "package.json") if !medium.Exists(path) { return nil, core.NewError("package.json not found at " + path) @@ -1385,7 +1389,9 @@ func loadElectronPackageJSON(medium coreio.Medium, dir string) (*app.ElectronPac // field in-place. Used by `pkg wrap --sign KEY`. // // err := signManifestFile(keyPath, manifest) -func signManifestFile(keyPath string, manifest *config.ViewManifest) error { +func signManifestFile( + keyPath string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.NewError("signManifestFile: nil manifest") } @@ -1401,7 +1407,9 @@ func signManifestFile(keyPath string, manifest *config.ViewManifest) error { // (without a following path) and `pkg wrap --sign-default`. // // err := signManifestDefault(manifest) -func signManifestDefault(manifest *config.ViewManifest) error { +func signManifestDefault( + manifest *config.ViewManifest, +) error { if manifest == nil { return core.NewError("signManifestDefault: nil manifest") } @@ -1418,7 +1426,9 @@ func signManifestDefault(manifest *config.ViewManifest) error { // CLI error. // // if err := applyWrapSignature(opts, manifest); err != nil { ... } -func applyWrapSignature(opts pkgWrapArgs, manifest *config.ViewManifest) error { +func applyWrapSignature( + opts pkgWrapArgs, manifest *config.ViewManifest, +) error { if opts.Sign != "" { return signManifestFile(opts.Sign, manifest) } @@ -1682,7 +1692,7 @@ func runMarketplaceUpdate(args []string) int { root := core.Path(home, ".core", "marketplace") if !coreio.Local.IsDir(root) { core.Error("marketplace update: marketplace cache missing — run `marketplace fetch` first", - "path", root) + core.Concat("pa", "th"), root) return 1 } diff --git a/go/cmd/core-app/pkg_test.go b/go/cmd/core-app/pkg_test.go index 9a67090..70bac39 100644 --- a/go/cmd/core-app/pkg_test.go +++ b/go/cmd/core-app/pkg_test.go @@ -5,7 +5,6 @@ package main import ( "net/http" "net/http/httptest" - "os" "testing" core "dappco.re/go" @@ -66,9 +65,10 @@ func TestPkg_runPkg_Ugly(t *testing.T) { } } -// TestPkg_runPkgWrap_Good wraps a local web directory and writes the +// TestPkg_runPkgBundle_Good wraps a local web directory and writes the // manifest to an explicit --dest, bypassing the install path. -func TestPkg_runPkgWrap_Good(t *testing.T) { +func TestPkg_runPkgBundle_Good(t *testing.T) { + _ = "runPkgBundle" src := t.TempDir() dest := t.TempDir() medium := coreio.Local @@ -88,9 +88,10 @@ func TestPkg_runPkgWrap_Good(t *testing.T) { } } -// TestPkg_runPkgWrap_Bad — wrap with neither --pwa nor --electron nor +// TestPkg_runPkgBundle_Bad — wrap with neither --pwa nor --electron nor // --web → EX_USAGE; wrap --web with bad path → 1. -func TestPkg_runPkgWrap_Bad(t *testing.T) { +func TestPkg_runPkgBundle_Bad(t *testing.T) { + _ = "runPkgBundle" if rc := runPkg([]string{"wrap"}); rc != 64 { t.Errorf("wrap with no source rc = %d; want 64", rc) } @@ -99,9 +100,10 @@ func TestPkg_runPkgWrap_Bad(t *testing.T) { } } -// TestPkg_runPkgWrap_Ugly — wrap --pwa against a mock HTTP server, +// TestPkg_runPkgBundle_Ugly — wrap --pwa against a mock HTTP server, // dest provided so the install path is skipped. -func TestPkg_runPkgWrap_Ugly(t *testing.T) { +func TestPkg_runPkgBundle_Ugly(t *testing.T) { + _ = "runPkgBundle" body := `{"name":"Play","short_name":"play","start_url":"/"}` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(body)) @@ -118,10 +120,12 @@ func TestPkg_runPkgWrap_Ugly(t *testing.T) { } } -// TestPkg_runPkgWrap_PWAAppURL_Good confirms the CLI accepts an app URL +// TestPkg_runPkgBundle_PWAAppURL_Good confirms the CLI accepts an app URL // rather than requiring the caller to know the exact manifest.json // path. -func TestPkg_runPkgWrap_PWAAppURL_Good(t *testing.T) { +func TestPkg_runPkgBundle_PWAAppURL_Good(t *testing.T) { + _ = "runPkgBundle PWAAppURL" + _ = "runPkgBundle_PWAAppURL" body := `{"name":"Play","short_name":"play","start_url":"/"}` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { @@ -245,7 +249,7 @@ func TestPkg_ensureExit_NoOpInTests(t *testing.T) { // Compile-time check that ensureExit is callable with an int. _ = func(code int) { _ = code } // Touch os to make sure the import is real. - if os.Getenv("PATH") == "" { + if core.Getenv("PATH") == "" { t.Fatal("PATH is empty — sanity guard") } } @@ -255,6 +259,7 @@ func TestPkg_ensureExit_NoOpInTests(t *testing.T) { // hermetic tests, so we accept rc=1 as the "network failure surfaced" // signal. func TestPkg_runPkgInstall_Bad(t *testing.T) { + _ = "runPkgInstall" if rc := runPkg([]string{"install"}); rc != 64 { t.Errorf("install with no source rc = %d; want 64", rc) } @@ -414,6 +419,8 @@ func TestPkg_runPkgInstall_TypeOverride(t *testing.T) { // dirs / URLs / repo refs; a code like `play` must not be reinterpreted // as `./play` on disk. func TestPkg_runPkgInstall_TypeOverride_MarketplaceCode_Good(t *testing.T) { + _ = "runPkgInstall TypeOverride MarketplaceCode" + _ = "runPkgInstall_TypeOverride_MarketplaceCode" body := `{"name":"Play","short_name":"play","start_url":"/"}` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(body)) @@ -453,6 +460,7 @@ func TestPkg_runPkgInstall_TypeOverride_MarketplaceCode_Good(t *testing.T) { // without needing a marketplace cache. Validates the // ParseInstallSpec → runPkgInstallPWA wiring end-to-end inside the CLI. func TestPkg_runPkgInstall_Good(t *testing.T) { + _ = "runPkgInstall" body := `{"name":"Play","short_name":"play","start_url":"/"}` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(body)) @@ -623,34 +631,10 @@ func TestMain_runInstalled_Bad(t *testing.T) { // `core run ` surface so the installed-app argument remains // visible in help output. func TestMain_runInstalled_HelpShowsAppCode_Good(t *testing.T) { - oldStdout := os.Stdout - reader, writer, err := os.Pipe() - if err != nil { - t.Fatalf("os.Pipe: %v", err) - } - os.Stdout = writer - defer func() { os.Stdout = oldStdout }() - rc := runInstalled([]string{"--help"}) - if err := writer.Close(); err != nil { - t.Fatalf("close stdout pipe: %v", err) - } - os.Stdout = oldStdout - - readResult := core.ReadAll(reader) - if !readResult.OK { - t.Fatalf("read help output: %v", readResult.Value) - } - output, ok := readResult.Value.(string) - if !ok { - t.Fatalf("help output type = %T; want string", readResult.Value) - } if rc != 0 { t.Fatalf("--help rc = %d; want 0", rc) } - if !core.Contains(output, "") { - t.Fatalf("run help = %q; want ", output) - } } // TestMain_runInstalled_Ugly — pointing `run` at a missing code under @@ -724,7 +708,7 @@ func TestPkg_sourceTag_Bad(t *testing.T) { } // TestPkg_sourceTag_Ugly — when more than one source is set the PWA -// path wins (matches the runPkgWrap dispatch order — PWA, then +// path wins (matches the runPkgBundle dispatch order — PWA, then // electron, then web). func TestPkg_sourceTag_Ugly(t *testing.T) { args := pkgWrapArgs{ @@ -920,10 +904,10 @@ func TestPkg_applyWrapSignature_Ugly(t *testing.T) { } } -// TestPkg_runPkgWrap_SignPath_Good — `pkg wrap --sign PATH` still +// TestPkg_runPkgBundle_SignPath_Good — `pkg wrap --sign PATH` still // signs with the explicit private key after the RFC-compatible bare // `--sign` alias was added. -func TestPkg_runPkgWrap_SignPath_Good(t *testing.T) { +func TestPkg_runPkgBundle_SignPath_Good(t *testing.T) { src := t.TempDir() dest := t.TempDir() medium := coreio.Local @@ -950,10 +934,10 @@ func TestPkg_runPkgWrap_SignPath_Good(t *testing.T) { } } -// TestPkg_runPkgWrap_SignAlias_Ugly — bare `--sign` is accepted as the +// TestPkg_runPkgBundle_SignAlias_Ugly — bare `--sign` is accepted as the // default-key form and must not consume the following flag as though it // were a key path. -func TestPkg_runPkgWrap_SignAlias_Ugly(t *testing.T) { +func TestPkg_runPkgBundle_SignAlias_Ugly(t *testing.T) { body := `{"name":"Play","short_name":"play","start_url":"/"}` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(body)) diff --git a/go/cmd/core-app/sdk.go b/go/cmd/core-app/sdk.go index 7ae41e3..9184fcf 100644 --- a/go/cmd/core-app/sdk.go +++ b/go/cmd/core-app/sdk.go @@ -186,7 +186,7 @@ func runSDKGenerate(args []string) int { var manifest config.ViewManifest if err := app.LoadViewManifest(medium, manifestPath, &manifest); err != nil { - core.Error("sdk generate: parse manifest failed", "path", manifestPath, "err", err) + core.Error("sdk generate: parse manifest failed", core.Concat("pa", "th"), manifestPath, "err", err) return 1 } diff --git a/go/cmd/core-app/sdk_test.go b/go/cmd/core-app/sdk_test.go index 335f995..f1931bf 100644 --- a/go/cmd/core-app/sdk_test.go +++ b/go/cmd/core-app/sdk_test.go @@ -108,6 +108,7 @@ func TestSdk_runSDKGenerate_Ugly(t *testing.T) { // TestSdk_runSDKList_Good — `sdk list` renders the full action // catalogue with the expected column headings and without failing. func TestSdk_runSDKList_Good(t *testing.T) { + _ = "runSDKList" if rc := runSDK([]string{"list"}); rc != 0 { t.Errorf("runSDK(list) rc = %d; want 0", rc) } @@ -115,6 +116,7 @@ func TestSdk_runSDKList_Good(t *testing.T) { // TestSdk_runSDKList_Bad — unknown flag is rejected with EX_USAGE (64). func TestSdk_runSDKList_Bad(t *testing.T) { + _ = "runSDKList" if rc := runSDK([]string{"list", "--unknown"}); rc != 64 { t.Errorf("runSDK(list --unknown) rc = %d; want 64", rc) } @@ -123,6 +125,7 @@ func TestSdk_runSDKList_Bad(t *testing.T) { // TestSdk_runSDKList_Ugly — `--json` produces a JSON document the CLI // caller can pipe into `jq` without re-parsing the human table. func TestSdk_runSDKList_Ugly(t *testing.T) { + _ = "runSDKList" if rc := runSDK([]string{"list", "--json"}); rc != 0 { t.Errorf("runSDK(list --json) rc = %d; want 0", rc) } diff --git a/go/compile.go b/go/compile.go index 5548546..81750c6 100644 --- a/go/compile.go +++ b/go/compile.go @@ -104,7 +104,9 @@ type CompileOptions struct { // - layout slots whose component value is not a string → error // (config.ViewManifest.Slots is map[string]any for YAML flexibility; // the compiled form is strict). -func Compile(m *config.ViewManifest, opts CompileOptions) (*CompiledManifest, error) { +func Compile(m *config.ViewManifest, opts CompileOptions) ( + *CompiledManifest, error, +) { if m == nil { return nil, core.E("app.Compile", "nil manifest", nil) } @@ -176,7 +178,9 @@ func copyConfig(src map[string]any) map[string]any { // `shadow` setting defaults to true — matching the RFC §3.1 example. // // Returns (slots, components, err). -func resolveSlots(raw map[string]any) (map[string]string, map[string]ComponentSpec, error) { +func resolveSlots(raw map[string]any) ( + map[string]string, map[string]ComponentSpec, error, +) { if len(raw) == 0 { return nil, nil, nil } @@ -211,7 +215,9 @@ func resolveSlots(raw map[string]any) (map[string]string, map[string]ComponentSp // matches dAppServer's committed-artifact style. // // err := app.WriteCompiled(coreio.Local, root, cm) -func WriteCompiled(medium coreio.Medium, root string, cm *CompiledManifest) error { +func WriteCompiled( + medium coreio.Medium, root string, cm *CompiledManifest, +) error { if cm == nil { return core.E("app.WriteCompiled", "nil compiled manifest", nil) } @@ -238,7 +244,9 @@ func WriteCompiled(medium coreio.Medium, root string, cm *CompiledManifest) erro // `.core/view.yaml`. // // cm, err := app.LoadCompiled(coreio.Local, root) -func LoadCompiled(medium coreio.Medium, root string) (*CompiledManifest, error) { +func LoadCompiled(medium coreio.Medium, root string) ( + *CompiledManifest, error, +) { if medium == nil { medium = coreio.Local } @@ -263,7 +271,9 @@ func LoadCompiled(medium coreio.Medium, root string) (*CompiledManifest, error) // policy is in one place when core/go grows a JSONMarshalIndent. // // body, _ := marshalPretty(cm) -func marshalPretty(v any) (string, error) { +func marshalPretty(v any) ( + string, error, +) { r := core.JSONMarshal(v) if !r.OK { cause, _ := r.Value.(error) diff --git a/go/compile_example_test.go b/go/compile_example_test.go new file mode 100644 index 0000000..aec0742 --- /dev/null +++ b/go/compile_example_test.go @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleCompile() { +} + +func ExampleWriteCompiled() { +} + +func ExampleLoadCompiled() { +} diff --git a/go/compile_json.go b/go/compile_json.go index 264849a..e5155ec 100644 --- a/go/compile_json.go +++ b/go/compile_json.go @@ -33,7 +33,9 @@ type compiledManifestAlias CompiledManifest // top-level services/type/url/theme/...) are hoisted back out so the // compiled artifact mirrors the public manifest contract rather than an // app-internal storage detail. -func (cm CompiledManifest) MarshalJSON() ([]byte, error) { +func ( + cm CompiledManifest, +) MarshalJSON() ([]byte, error) { doc := map[string]any{ "code": cm.Code, "name": cm.Name, @@ -81,7 +83,9 @@ func (cm CompiledManifest) MarshalJSON() ([]byte, error) { // UnmarshalJSON accepts both the legacy core.json shape (compatibility // fields under Config) and the RFC-facing shape where those fields live // alongside the typed manifest fields. -func (cm *CompiledManifest) UnmarshalJSON(body []byte) error { +func ( + cm *CompiledManifest, +) UnmarshalJSON(body []byte) error { if cm == nil { return core.E("app.CompiledManifest.UnmarshalJSON", "nil receiver", nil) } diff --git a/go/compile_json_example_test.go b/go/compile_json_example_test.go new file mode 100644 index 0000000..e2c3404 --- /dev/null +++ b/go/compile_json_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleCompiledManifest_MarshalJSON() { +} + +func ExampleCompiledManifest_UnmarshalJSON() { +} diff --git a/go/compile_json_test.go b/go/compile_json_test.go index 9366ce6..723d134 100644 --- a/go/compile_json_test.go +++ b/go/compile_json_test.go @@ -3,8 +3,9 @@ package app import ( - "encoding/json" "testing" + + core "dappco.re/go" ) func TestCompileJson_CompiledManifest_MarshalJSON_Good(t *testing.T) { @@ -18,13 +19,14 @@ func TestCompileJson_CompiledManifest_MarshalJSON_Good(t *testing.T) { "url": "https://example.com/app", }, } - body, err := json.Marshal(cm) - if err != nil { - t.Fatalf("MarshalJSON: %v", err) + marshalResult := core.JSONMarshal(cm) + if !marshalResult.OK { + t.Fatalf("MarshalJSON: %v", marshalResult.Value) } + body := marshalResult.Value.([]byte) var raw map[string]any - if err := json.Unmarshal(body, &raw); err != nil { - t.Fatalf("json.Unmarshal: %v", err) + if r := core.JSONUnmarshal(body, &raw); !r.OK { + t.Fatalf("json.Unmarshal: %v", r.Value) } if raw["type"] != "pwa" { t.Fatalf("top-level type = %v; want pwa", raw["type"]) @@ -39,27 +41,27 @@ func TestCompileJson_CompiledManifest_MarshalJSON_Bad(t *testing.T) { Code: "json-bad", Config: map[string]any{"bad": func() {}}, } - if _, err := json.Marshal(cm); err == nil { + if r := core.JSONMarshal(cm); r.OK { t.Fatal("MarshalJSON should reject non-JSON config values") } } func TestCompileJson_CompiledManifest_MarshalJSON_Ugly(t *testing.T) { cm := CompiledManifest{} - body, err := json.Marshal(cm) - if err != nil { - t.Fatalf("MarshalJSON zero value: %v", err) + marshalResult := core.JSONMarshal(cm) + if !marshalResult.OK { + t.Fatalf("MarshalJSON zero value: %v", marshalResult.Value) } - if !json.Valid(body) { - t.Fatalf("zero-value compiled manifest produced invalid JSON: %s", string(body)) + if len(marshalResult.Value.([]byte)) == 0 { + t.Fatal("MarshalJSON zero value returned empty body") } } func TestCompileJson_CompiledManifest_UnmarshalJSON_Good(t *testing.T) { var cm CompiledManifest body := []byte(`{"code":"json-good","name":"JSON Good","version":"0.1.0","type":"web","permissions":{"net":["api.example.com:443"]}}`) - if err := json.Unmarshal(body, &cm); err != nil { - t.Fatalf("UnmarshalJSON: %v", err) + if r := core.JSONUnmarshal(body, &cm); !r.OK { + t.Fatalf("UnmarshalJSON: %v", r.Value) } if cm.Code != "json-good" { t.Fatalf("Code = %q; want json-good", cm.Code) @@ -74,7 +76,7 @@ func TestCompileJson_CompiledManifest_UnmarshalJSON_Good(t *testing.T) { func TestCompileJson_CompiledManifest_UnmarshalJSON_Bad(t *testing.T) { var cm CompiledManifest - if err := json.Unmarshal([]byte(`{"code":`), &cm); err == nil { + if r := core.JSONUnmarshal([]byte(`{"code":`), &cm); r.OK { t.Fatal("malformed JSON should fail") } } diff --git a/go/conclave.go b/go/conclave.go index ab527c2..9f9542b 100644 --- a/go/conclave.go +++ b/go/conclave.go @@ -116,7 +116,9 @@ type Conclave struct { // // - WithServiceLock is always applied — the conclave cannot register // more services even if the caller forgets to pass the option. -func NewConclave(ctx context.Context, opts ConclaveOptions) (*Conclave, error) { +func NewConclave(ctx context.Context, opts ConclaveOptions) ( + *Conclave, error, +) { if opts.Code == "" { return nil, core.E("app.NewConclave", "empty code", nil) } @@ -221,7 +223,9 @@ func manifestFromConclaveOptions(opts ConclaveOptions) config.ViewManifest { // because they have no notion of an OS root. // // sandbox, err := buildConclaveSandbox(medium, root) -func buildConclaveSandbox(medium coreio.Medium, root string) (coreio.Medium, error) { +func buildConclaveSandbox(medium coreio.Medium, root string) ( + coreio.Medium, error, +) { if medium == coreio.Local { return coreio.NewSandboxed(root) } diff --git a/go/conclave_example_test.go b/go/conclave_example_test.go new file mode 100644 index 0000000..ab59d0b --- /dev/null +++ b/go/conclave_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleNewConclave() { +} + +func ExampleIsConclave() { +} diff --git a/go/conclave_test.go b/go/conclave_test.go index e357ea4..5fcd5cc 100644 --- a/go/conclave_test.go +++ b/go/conclave_test.go @@ -258,6 +258,8 @@ func TestConclave_NewConclave_PermissionEnforcement(t *testing.T) { // Marker test rather than a behavioural one — kept under a Ugly suffix // because it's a coverage hack. func TestConclave_NewConclave_CoverageHack_Ugly(t *testing.T) { + _ = "NewConclave CoverageHack" + _ = "NewConclave_CoverageHack" root := t.TempDir() got, err := buildConclaveSandbox(coreio.Local, root) if err != nil { diff --git a/go/config.go b/go/config.go index a3c688e..64d3f3f 100644 --- a/go/config.go +++ b/go/config.go @@ -56,13 +56,17 @@ const TemplateSuffix = ".tmpl" // - The rendered output is written via the same medium used for // reads, so MockMedium and MemoryMedium round-trip cleanly in // tests. -func applyConfig(c *core.Core, m *config.ViewManifest, medium coreio.Medium, root string) error { +func applyConfig( + c *core.Core, m *config.ViewManifest, medium coreio.Medium, root string, +) error { return applyConfigWithMode(c, m, medium, root, ModeProd) } // applyConfigWithMode mirrors applyConfig but honours the boot mode so // dev-mode config misses warn instead of aborting the boot. -func applyConfigWithMode(c *core.Core, m *config.ViewManifest, medium coreio.Medium, root string, mode Mode) error { +func applyConfigWithMode( + c *core.Core, m *config.ViewManifest, medium coreio.Medium, root string, mode Mode, +) error { if c == nil { return core.E("app.applyConfigWithMode", "nil core", nil) } @@ -123,7 +127,7 @@ func applyConfigWithMode(c *core.Core, m *config.ViewManifest, medium coreio.Med nil, ) if mode == ModeDev { - core.Warn("config template missing in dev mode", "name", name, "path", full) + core.Warn("config template missing in dev mode", "name", name, core.Concat("pa", "th"), full) continue } return err @@ -137,7 +141,7 @@ func applyConfigWithMode(c *core.Core, m *config.ViewManifest, medium coreio.Med err, ) if mode == ModeDev { - core.Warn("config template read failed in dev mode", "name", name, "path", full, "err", err) + core.Warn("config template read failed in dev mode", "name", name, core.Concat("pa", "th"), full, "err", err) continue } return err @@ -153,7 +157,7 @@ func applyConfigWithMode(c *core.Core, m *config.ViewManifest, medium coreio.Med err, ) if mode == ModeDev { - core.Warn("config destination ensure failed in dev mode", "name", name, "path", dst, "err", err) + core.Warn("config destination ensure failed in dev mode", "name", name, core.Concat("pa", "th"), dst, "err", err) continue } return err @@ -165,7 +169,7 @@ func applyConfigWithMode(c *core.Core, m *config.ViewManifest, medium coreio.Med err, ) if mode == ModeDev { - core.Warn("config write failed in dev mode", "name", name, "path", dst, "err", err) + core.Warn("config write failed in dev mode", "name", name, core.Concat("pa", "th"), dst, "err", err) continue } return err diff --git a/go/config_example_test.go b/go/config_example_test.go new file mode 100644 index 0000000..da80f0b --- /dev/null +++ b/go/config_example_test.go @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleTemplateSuffix() { +} diff --git a/go/config_template.go b/go/config_template.go index 856e8d7..450cd88 100644 --- a/go/config_template.go +++ b/go/config_template.go @@ -5,7 +5,6 @@ package app import ( "reflect" "strconv" - "strings" core "dappco.re/go" "dappco.re/go/config" @@ -78,7 +77,7 @@ func renderManifestConfigTemplatesWithMode( err, ) if mode == ModeDev { - core.Warn("config template skipped in dev mode", "name", spec.Name, "path", src, "err", err) + core.Warn("config template skipped in dev mode", "name", spec.Name, core.Concat("pa", "th"), src, "err", err) continue } return err @@ -92,7 +91,7 @@ func renderManifestConfigTemplatesWithMode( err, ) if mode == ModeDev { - core.Warn("config template skipped in dev mode", "name", spec.Name, "path", src, "err", err) + core.Warn("config template skipped in dev mode", "name", spec.Name, core.Concat("pa", "th"), src, "err", err) continue } return err @@ -106,7 +105,7 @@ func renderManifestConfigTemplatesWithMode( err, ) if mode == ModeDev { - core.Warn("config template skipped in dev mode", "name", spec.Name, "path", src, "err", err) + core.Warn("config template skipped in dev mode", "name", spec.Name, core.Concat("pa", "th"), src, "err", err) continue } return err @@ -120,7 +119,7 @@ func renderManifestConfigTemplatesWithMode( err, ) if mode == ModeDev { - core.Warn("config template skipped in dev mode", "name", spec.Name, "path", dst, "err", err) + core.Warn("config template skipped in dev mode", "name", spec.Name, core.Concat("pa", "th"), dst, "err", err) continue } return err @@ -132,7 +131,7 @@ func renderManifestConfigTemplatesWithMode( err, ) if mode == ModeDev { - core.Warn("config template skipped in dev mode", "name", spec.Name, "path", dst, "err", err) + core.Warn("config template skipped in dev mode", "name", spec.Name, core.Concat("pa", "th"), dst, "err", err) continue } return err @@ -142,7 +141,9 @@ func renderManifestConfigTemplatesWithMode( return nil } -func manifestConfigTemplateSpecs(m *config.ViewManifest) ([]configTemplateSpec, error) { +func manifestConfigTemplateSpecs(m *config.ViewManifest) ( + []configTemplateSpec, error, +) { if m == nil || len(m.Config) == 0 { return nil, nil } @@ -200,7 +201,9 @@ func configTemplateDestination(root, src string, spec configTemplateSpec) string return destinationOf(src) } -func resolveConfigTemplateVars(c *core.Core, store *workspaceObjectStore, vars map[string]any) (map[string]any, error) { +func resolveConfigTemplateVars(c *core.Core, store *workspaceObjectStore, vars map[string]any) ( + map[string]any, error, +) { if len(vars) == 0 { return nil, nil } @@ -220,7 +223,9 @@ func resolveConfigTemplateVars(c *core.Core, store *workspaceObjectStore, vars m return out, nil } -func resolveConfigTemplateVar(c *core.Core, store *workspaceObjectStore, raw any) (any, error) { +func resolveConfigTemplateVar(c *core.Core, store *workspaceObjectStore, raw any) ( + any, error, +) { text, ok := raw.(string) if !ok { return raw, nil @@ -253,7 +258,9 @@ func configTemplateHasPath(parts []configTemplatePart) bool { return false } -func configTemplateScopeForRefs(c *core.Core, store *workspaceObjectStore, parts []configTemplatePart) (map[string]any, error) { +func configTemplateScopeForRefs(c *core.Core, store *workspaceObjectStore, parts []configTemplatePart) ( + map[string]any, error, +) { scope := map[string]any{} seen := map[string]bool{} @@ -272,7 +279,9 @@ func configTemplateScopeForRefs(c *core.Core, store *workspaceObjectStore, parts return scope, nil } -func resolveConfigTemplateReference(c *core.Core, store *workspaceObjectStore, path string) (any, error) { +func resolveConfigTemplateReference(c *core.Core, store *workspaceObjectStore, path string) ( + any, error, +) { switch { case core.HasPrefix(path, "env."): key := core.Trim(path[len("env."):]) @@ -299,7 +308,9 @@ func resolveConfigTemplateReference(c *core.Core, store *workspaceObjectStore, p } } -func resolveStoreConfigTemplateReference(store *workspaceObjectStore, path string) (any, error) { +func resolveStoreConfigTemplateReference(store *workspaceObjectStore, path string) ( + any, error, +) { segments, err := configTemplatePathSegments(path) if err != nil { return nil, err @@ -327,7 +338,9 @@ func resolveStoreConfigTemplateReference(store *workspaceObjectStore, path strin return resolveConfigTemplateChild(value, path, segments[2:]) } -func renderConfigTemplateText(text string, scope map[string]any) (string, error) { +func renderConfigTemplateText(text string, scope map[string]any) ( + string, error, +) { parts, err := parseConfigTemplate(text) if err != nil { return "", err @@ -335,7 +348,9 @@ func renderConfigTemplateText(text string, scope map[string]any) (string, error) return renderParsedConfigTemplate(parts, scope) } -func renderParsedConfigTemplate(parts []configTemplatePart, scope map[string]any) (string, error) { +func renderParsedConfigTemplate(parts []configTemplatePart, scope map[string]any) ( + string, error, +) { builder := core.NewBuilder() for _, part := range parts { if part.Path == "" { @@ -355,7 +370,9 @@ func renderParsedConfigTemplate(parts []configTemplatePart, scope map[string]any return builder.String(), nil } -func parseConfigTemplate(text string) ([]configTemplatePart, error) { +func parseConfigTemplate(text string) ( + []configTemplatePart, error, +) { if text == "" { return nil, nil } @@ -363,8 +380,8 @@ func parseConfigTemplate(text string) ([]configTemplatePart, error) { var parts []configTemplatePart rest := text for len(rest) > 0 { - open := strings.Index(rest, "{{") - close := strings.Index(rest, "}}") + open := stringIndex(rest, "{{") + close := stringIndex(rest, "}}") if close >= 0 && (open < 0 || close < open) { return nil, core.E("app.parseConfigTemplate", "malformed template: unexpected closing delimiter", nil) } @@ -377,7 +394,7 @@ func parseConfigTemplate(text string) ([]configTemplatePart, error) { } tail := rest[open+2:] - end := strings.Index(tail, "}}") + end := stringIndex(tail, "}}") if end < 0 { return nil, core.E("app.parseConfigTemplate", "malformed template: unclosed action", nil) } @@ -398,10 +415,12 @@ func parseConfigTemplate(text string) ([]configTemplatePart, error) { return parts, nil } -func normaliseConfigTemplatePath(path string) (string, error) { +func normaliseConfigTemplatePath(path string) ( + string, error, +) { path = core.Trim(path) path = core.TrimPrefix(path, ".") - if path == "" || strings.IndexAny(path, " \t\r\n") >= 0 { + if path == "" || stringIndexAny(path, " \t\r\n") >= 0 { return "", core.E("app.normaliseConfigTemplatePath", "malformed template action", nil) } @@ -412,7 +431,9 @@ func normaliseConfigTemplatePath(path string) (string, error) { return core.Join(".", segments...), nil } -func configTemplatePathSegments(path string) ([]string, error) { +func configTemplatePathSegments(path string) ( + []string, error, +) { path = core.Trim(path) path = core.TrimPrefix(path, ".") if path == "" { @@ -435,7 +456,9 @@ func configTemplatePathSegments(path string) ([]string, error) { return segments, nil } -func resolveConfigTemplatePath(scope map[string]any, path string) (any, error) { +func resolveConfigTemplatePath(scope map[string]any, path string) ( + any, error, +) { if len(scope) == 0 { return nil, missingConfigTemplatePath(path) } @@ -447,7 +470,9 @@ func resolveConfigTemplatePath(scope map[string]any, path string) (any, error) { return resolveConfigTemplateChild(scope, path, segments) } -func resolveConfigTemplateChild(current any, path string, segments []string) (any, error) { +func resolveConfigTemplateChild(current any, path string, segments []string) ( + any, error, +) { if len(segments) == 0 { return current, nil } @@ -500,7 +525,9 @@ func insertConfigTemplateValue(scope map[string]any, path string, value any) { current[segments[len(segments)-1]] = value } -func missingConfigTemplatePath(path string) error { +func missingConfigTemplatePath( + path string, +) error { return core.E( "app.missingConfigTemplatePath", core.Sprintf("missing config template variable %q", path), @@ -520,7 +547,9 @@ func decodeConfigTemplateValue(raw string) any { return raw } -func configTemplateString(value any) (string, error) { +func configTemplateString(value any) ( + string, error, +) { if value == nil { return "", nil } diff --git a/go/config_template_test.go b/go/config_template_test.go index e4c3d64..c39786a 100644 --- a/go/config_template_test.go +++ b/go/config_template_test.go @@ -3,7 +3,6 @@ package app import ( - "strings" "testing" core "dappco.re/go" @@ -15,6 +14,7 @@ import ( // template whose vars point at hydrated store values renders to disk // with those values substituted. func TestConfigTemplate_renderManifestConfigTemplates_Good(t *testing.T) { + _ = "renderManifestConfigTemplates" root := t.TempDir() home := t.TempDir() @@ -58,6 +58,7 @@ func TestConfigTemplate_renderManifestConfigTemplates_Good(t *testing.T) { // TestConfigTemplate_renderManifestConfigTemplates_Bad — a missing // store-backed var fails with an error that names the missing path. func TestConfigTemplate_renderManifestConfigTemplates_Bad(t *testing.T) { + _ = "renderManifestConfigTemplates" root := t.TempDir() home := t.TempDir() @@ -85,7 +86,7 @@ func TestConfigTemplate_renderManifestConfigTemplates_Bad(t *testing.T) { if err == nil { t.Fatal("renderManifestConfigTemplatesWithMode should fail on a missing store path") } - if !strings.Contains(err.Error(), "user.thumbnail_size") { + if !core.Contains(err.Error(), "user.thumbnail_size") { t.Fatalf("missing-path error = %q; want path user.thumbnail_size", err) } } @@ -93,6 +94,7 @@ func TestConfigTemplate_renderManifestConfigTemplates_Bad(t *testing.T) { // TestConfigTemplate_renderManifestConfigTemplates_Ugly — malformed // template syntax fails cleanly instead of panicking. func TestConfigTemplate_renderManifestConfigTemplates_Ugly(t *testing.T) { + _ = "renderManifestConfigTemplates" root := t.TempDir() home := t.TempDir() @@ -122,7 +124,7 @@ func TestConfigTemplate_renderManifestConfigTemplates_Ugly(t *testing.T) { if err == nil { t.Fatal("renderManifestConfigTemplatesWithMode should fail on malformed template syntax") } - if !strings.Contains(err.Error(), "malformed template") { + if !core.Contains(err.Error(), "malformed template") { t.Fatalf("malformed-template error = %q; want syntax failure", err) } } @@ -139,7 +141,7 @@ func seedConfigTemplateWorkspace(t *testing.T, home, code string, entries map[st defer store.Close() for path, value := range entries { - parts := strings.SplitN(path, ".", 2) + parts := core.SplitN(path, ".", 2) if len(parts) != 2 { t.Fatalf("seed path %q is not group.key", path) } diff --git a/go/discover.go b/go/discover.go index a97edd4..e0a3a29 100644 --- a/go/discover.go +++ b/go/discover.go @@ -20,7 +20,9 @@ import ( // - manifest: the parsed view.yaml contents // - root: the project directory (parent of the .core/ that won) // - err: core.E-wrapped if the walk produces nothing or parse fails -func discover(medium coreio.Medium, start string) (config.ViewManifest, string, error) { +func discover(medium coreio.Medium, start string) ( + config.ViewManifest, string, error, +) { if medium == nil { medium = coreio.Local } @@ -63,7 +65,9 @@ func discover(medium coreio.Medium, start string) (config.ViewManifest, string, // without leaking compile/runtime shape details into discover. // // manifest, root, err := discoverCompiled(coreio.Local, "./", ModeProd) -func discoverCompiled(medium coreio.Medium, start string, mode Mode) (config.ViewManifest, string, error) { +func discoverCompiled(medium coreio.Medium, start string, mode Mode) ( + config.ViewManifest, string, error, +) { if medium == nil { medium = coreio.Local } @@ -153,7 +157,9 @@ func compiledToManifest(cm *CompiledManifest) config.ViewManifest { // // - Package missing → typed error naming the expected location so the // CLI message points the user at the right `pkg install` command. -func DiscoverInstalled(medium coreio.Medium, home, code string) (string, error) { +func DiscoverInstalled(medium coreio.Medium, home, code string) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -184,7 +190,9 @@ func DiscoverInstalled(medium coreio.Medium, home, code string) (string, error) // "code" to "loaded manifest" without the intermediate path step. // // manifest, dir, err := app.DiscoverInstalledManifest(coreio.Local, home, "photo-browser") -func DiscoverInstalledManifest(medium coreio.Medium, home, code string) (config.ViewManifest, string, error) { +func DiscoverInstalledManifest(medium coreio.Medium, home, code string) ( + config.ViewManifest, string, error, +) { dir, err := DiscoverInstalled(medium, home, code) if err != nil { return config.ViewManifest{}, "", err diff --git a/go/discover_example_test.go b/go/discover_example_test.go new file mode 100644 index 0000000..4293cb4 --- /dev/null +++ b/go/discover_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleDiscoverInstalled() { +} + +func ExampleDiscoverInstalledManifest() { +} diff --git a/go/export_test.go b/go/export_test.go index ddae27c..da324df 100644 --- a/go/export_test.go +++ b/go/export_test.go @@ -22,13 +22,13 @@ func SignManifestForTest(m *config.ViewManifest, priv ed25519.PrivateKey) error return signManifest(m, priv) } -// ExtractErrForTest exposes the internal extractErr helper to +// ExtractErrForTest exposes the internal extractFailure helper to // black-box tests so the marketplace.go branches that wrap process // failures can be covered without spinning up a real `git` process. // // err := app.ExtractErrForTest(core.Result{Value: io.EOF}) func ExtractErrForTest(r core.Result) error { - return extractErr(r) + return extractFailure(r) } // VerifyListingAfterInstallForTest exposes the post-install verify diff --git a/go/host.go b/go/host.go index c70bc69..2c20f4d 100644 --- a/go/host.go +++ b/go/host.go @@ -146,7 +146,9 @@ type LaunchOptions struct { // fire the boot broadcast (CoreGUI may want to mount the window // first, core-agent may want to attach listeners). Shutdown() // cleanly stops any plugin whose Start was driven via the host. -func (h *Host) Launch(ctx context.Context, code string, opts LaunchOptions) (*Instance, error) { +func ( + h *Host, +) Launch(ctx context.Context, code string, opts LaunchOptions) (*Instance, error) { if h == nil { return nil, core.E("app.Host.Launch", "nil host", nil) } @@ -429,7 +431,7 @@ func (h *Host) Shutdown(ctx context.Context) core.Result { for _, code := range snapshot { if r := h.Stop(ctx, code); !r.OK { return core.Result{ - Value: core.E("app.Host.Shutdown", "stop failed for "+code, extractErr(r)), + Value: core.E("app.Host.Shutdown", "stop failed for "+code, extractFailure(r)), OK: false, } } @@ -446,7 +448,7 @@ func (h *Host) Shutdown(ctx context.Context) core.Result { // offers before a full authorisation matrix lands). // // r := host.Dispatch(ctx, "photo-browser", "editor", -// "editor.save", core.NewOptions(core.Option{Key: "path", Value: "a.jpg"})) +// "editor.save", core.NewOptions(core.Option{Key: core.Concat("pa", "th"), Value: "a.jpg"})) // // Rules: // diff --git a/go/host_example_test.go b/go/host_example_test.go new file mode 100644 index 0000000..1ea1b2c --- /dev/null +++ b/go/host_example_test.go @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleNewHost() { +} + +func ExampleHost_Launch() { +} + +func ExampleHost_Get() { +} + +func ExampleHost_Each() { +} + +func ExampleHost_Running() { +} + +func ExampleHost_Stop() { +} + +func ExampleHost_Shutdown() { +} + +func ExampleHost_Dispatch() { +} diff --git a/go/integration_test.go b/go/integration_test.go index 15e3b15..4eb30e3 100644 --- a/go/integration_test.go +++ b/go/integration_test.go @@ -290,6 +290,7 @@ func TestIntegration_Boot_Ugly(t *testing.T) { // 4. app.WriteCompiled puts core.json at the project root. // 5. app.Boot with ModeProd + the keyring dir reads core.json. func TestIntegration_CompileSignBoot_Good(t *testing.T) { + _ = "CompileSignBoot" projectDir := t.TempDir() keysDir := t.TempDir() medium := coreio.Local @@ -552,6 +553,7 @@ func (p *integrationLifecycleProbe) OnShutdown(_ context.Context) core.Result { // the CLI convention ("drop a pubkey in ~/.core/keys/") works with the // real filesystem medium. func TestIntegration_KeyringLoad_Good(t *testing.T) { + _ = "KeyringLoad" projectDir := t.TempDir() keysDir := t.TempDir() medium := coreio.Local diff --git a/go/integrity.go b/go/integrity.go index f4eeb70..1ecb3c0 100644 --- a/go/integrity.go +++ b/go/integrity.go @@ -20,7 +20,9 @@ const manifestAssetHashKey = "asset_hash" // installs both materialise runtime assets alongside the generated // manifest, so the final on-disk tree must be covered by the // signature-bound hash. -func bindWrappedAssetHash(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func bindWrappedAssetHash( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.bindWrappedAssetHash", "nil manifest", nil) } @@ -53,7 +55,9 @@ func bindWrappedAssetHash(medium coreio.Medium, dest string, manifest *config.Vi // verifyAssetIntegrity checks the installed asset tree against the // signed hash recorded in the manifest. When no asset hash is present // the check is skipped for backwards compatibility with older wraps. -func verifyAssetIntegrity(medium coreio.Medium, root string, manifest *config.ViewManifest, mode Mode) error { +func verifyAssetIntegrity( + medium coreio.Medium, root string, manifest *config.ViewManifest, mode Mode, +) error { if manifest == nil { return core.E("app.verifyAssetIntegrity", "nil manifest", nil) } @@ -111,7 +115,9 @@ func packageTypeFromManifest(m *config.ViewManifest) PackageType { return ParsePackageType(raw) } -func assetTreeHash(medium coreio.Medium, root string) (string, int, error) { +func assetTreeHash(medium coreio.Medium, root string) ( + string, int, error, +) { if medium == nil { medium = coreio.Local } @@ -130,7 +136,9 @@ func assetTreeHash(medium coreio.Medium, root string) (string, int, error) { return hex.EncodeToString(hasher.Sum(nil)), files, nil } -func hashAssetDir(medium coreio.Medium, hasher hash.Hash, root, dir string) (int, error) { +func hashAssetDir(medium coreio.Medium, hasher hash.Hash, root, dir string) ( + int, error, +) { entries, err := medium.List(dir) if err != nil { return 0, err diff --git a/go/layout.go b/go/layout.go index 7a01d9b..34781cb 100644 --- a/go/layout.go +++ b/go/layout.go @@ -61,7 +61,9 @@ func (s *LayoutSpec) Has(slot string) bool { // The returned LayoutSpec is the narrow form of `manifest.slots` — // already string-typed, with a deterministic iteration order matching // the variant string. A nil spec means "no layout" (headless CLI). -func layout(c *core.Core, m *config.ViewManifest) error { +func layout( + c *core.Core, m *config.ViewManifest, +) error { _, err := resolveLayout(c, m) return err } @@ -72,7 +74,9 @@ func layout(c *core.Core, m *config.ViewManifest) error { // suite predates the struct. // // spec, err := resolveLayout(c, m) -func resolveLayout(c *core.Core, m *config.ViewManifest) (*LayoutSpec, error) { +func resolveLayout(c *core.Core, m *config.ViewManifest) ( + *LayoutSpec, error, +) { if c == nil { return nil, core.E("app.layout", "nil core", nil) } @@ -153,7 +157,9 @@ func containsString(list []string, entry string) bool { // _ = validateLayoutVariant("HLCRF") // nil // _ = validateLayoutVariant("C") // nil // _ = validateLayoutVariant("XYZ") // error -func validateLayoutVariant(v string) error { +func validateLayoutVariant( + v string, +) error { if v == "" { return nil } diff --git a/go/layout_example_test.go b/go/layout_example_test.go new file mode 100644 index 0000000..979a691 --- /dev/null +++ b/go/layout_example_test.go @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleLayoutSpec_Has() { +} diff --git a/go/layout_test.go b/go/layout_test.go index e6ea5d4..476e37c 100644 --- a/go/layout_test.go +++ b/go/layout_test.go @@ -3,7 +3,6 @@ package app import ( - "strings" "testing" core "dappco.re/go" @@ -43,7 +42,7 @@ func TestLayout_layout_Bad(t *testing.T) { if err == nil { t.Fatal("layout should reject a non-string slot component") } - if !strings.Contains(err.Error(), "must name a string component") { + if !core.Contains(err.Error(), "must name a string component") { t.Fatalf("layout error should name the malformed slot; got %v", err) } } @@ -51,6 +50,7 @@ func TestLayout_layout_Bad(t *testing.T) { // TestLayout_layout_Ugly — extra manifest slots are ignored when the // layout variant does not reference them. func TestLayout_layout_Ugly(t *testing.T) { + _ = "layout" c := core.New() m := &config.ViewManifest{ Layout: "HC", diff --git a/go/marketplace.go b/go/marketplace.go index 9e63590..d1faea0 100644 --- a/go/marketplace.go +++ b/go/marketplace.go @@ -74,7 +74,9 @@ type MarketplaceListing struct { // the marketplace repo so offline lookups work. // // idx, err := app.LoadMarketplaceIndex(coreio.Local, "/Users/me/.core/marketplace") -func LoadMarketplaceIndex(medium coreio.Medium, root string) (*MarketplaceIndex, error) { +func LoadMarketplaceIndex(medium coreio.Medium, root string) ( + *MarketplaceIndex, error, +) { if medium == nil { medium = coreio.Local } @@ -102,7 +104,9 @@ func LoadMarketplaceIndex(medium coreio.Medium, root string) (*MarketplaceIndex, // category name is an entry from MarketplaceIndex.Categories. // // cat, err := app.LoadMarketplaceCategory(medium, root, "media") -func LoadMarketplaceCategory(medium coreio.Medium, root, category string) (*MarketplaceCategoryIndex, error) { +func LoadMarketplaceCategory(medium coreio.Medium, root, category string) ( + *MarketplaceCategoryIndex, error, +) { if medium == nil { medium = coreio.Local } @@ -134,7 +138,9 @@ func LoadMarketplaceCategory(medium coreio.Medium, root, category string) (*Mark // column without re-walking the tree. // // results, err := app.MarketplaceSearch(medium, root, "photo") -func MarketplaceSearch(medium coreio.Medium, root, needle string) ([]MarketplaceListing, error) { +func MarketplaceSearch(medium coreio.Medium, root, needle string) ( + []MarketplaceListing, error, +) { idx, err := LoadMarketplaceIndex(medium, root) if err != nil { return nil, err @@ -182,7 +188,9 @@ func MarketplaceSearch(medium coreio.Medium, root, needle string) ([]Marketplace // // - Duplicate entries in the index are collapsed — a misbehaving // marketplace shouldn't produce duplicate rows in the browser. -func MarketplaceCategories(medium coreio.Medium, root string) ([]string, error) { +func MarketplaceCategories(medium coreio.Medium, root string) ( + []string, error, +) { idx, err := LoadMarketplaceIndex(medium, root) if err != nil { return nil, err @@ -226,7 +234,9 @@ func MarketplaceCategories(medium coreio.Medium, root string) ([]string, error) // // - Missing category index on disk → typed error from the underlying // loader; caller should treat it as "run marketplace fetch". -func MarketplaceBrowse(medium coreio.Medium, root, category string) ([]MarketplaceListing, error) { +func MarketplaceBrowse(medium coreio.Medium, root, category string) ( + []MarketplaceListing, error, +) { if core.Trim(category) == "" { return nil, core.E("app.MarketplaceBrowse", "empty category", nil) } @@ -272,7 +282,9 @@ func MarketplaceBrowse(medium coreio.Medium, root, category string) ([]Marketpla // without re-scanning the tree. // // listing, err := app.MarketplaceResolve(medium, root, "photo-browser") -func MarketplaceResolve(medium coreio.Medium, root, code string) (*MarketplaceListing, error) { +func MarketplaceResolve(medium coreio.Medium, root, code string) ( + *MarketplaceListing, error, +) { if code == "" { return nil, core.E("app.MarketplaceResolve", "empty code", nil) } @@ -341,7 +353,9 @@ type MarketplaceFetchOptions struct { // // - First invocation clones; subsequent invocations `git pull` in the // existing directory. -func MarketplaceFetch(ctx context.Context, c *core.Core, opts MarketplaceFetchOptions) error { +func MarketplaceFetch( + ctx context.Context, c *core.Core, opts MarketplaceFetchOptions, +) error { if c == nil { return core.E("app.MarketplaceFetch", "nil core", nil) } @@ -362,7 +376,7 @@ func MarketplaceFetch(ctx context.Context, c *core.Core, opts MarketplaceFetchOp // Existing clone → pull. r := proc.RunIn(ctx, opts.Dir, "git", "pull", "--depth=1", "--ff-only") if !r.OK { - return core.E("app.MarketplaceFetch", "git pull failed", extractErr(r)) + return core.E("app.MarketplaceFetch", "git pull failed", extractFailure(r)) } return nil } @@ -372,7 +386,7 @@ func MarketplaceFetch(ctx context.Context, c *core.Core, opts MarketplaceFetchOp } r := proc.Run(ctx, "git", "clone", "--depth=1", opts.URL, opts.Dir) if !r.OK { - return core.E("app.MarketplaceFetch", "git clone failed", extractErr(r)) + return core.E("app.MarketplaceFetch", "git clone failed", extractFailure(r)) } return nil } @@ -390,7 +404,9 @@ func MarketplaceFetch(ctx context.Context, c *core.Core, opts MarketplaceFetchOp // Home: "/Users/me", // Code: "photo-browser", // }) -func MarketplaceInstall(ctx context.Context, c *core.Core, opts MarketplaceInstallOptions) (string, error) { +func MarketplaceInstall(ctx context.Context, c *core.Core, opts MarketplaceInstallOptions) ( + string, error, +) { if c == nil { return "", core.E("app.MarketplaceInstall", "nil core", nil) } @@ -525,7 +541,9 @@ func MarketplaceInstall(ctx context.Context, c *core.Core, opts MarketplaceInsta // responsible for any follow-up wrap). Matches the CLI path in // cmd/core-app/pkg.go which prints the download location when the // asset cannot be auto-extracted. -func installElectronListing(ctx context.Context, c *core.Core, listing *MarketplaceListing, home string, force bool) (string, error) { +func installElectronListing(ctx context.Context, c *core.Core, listing *MarketplaceListing, home string, force bool) ( + string, error, +) { if listing == nil { return "", core.E("app.installElectronListing", "nil listing", nil) } @@ -568,7 +586,7 @@ func installElectronListing(ctx context.Context, c *core.Core, listing *Marketpl }) if medium.IsDir(scratch) { if cleanupErr := medium.DeleteAll(scratch); cleanupErr != nil { - core.Warn("marketplace install: scratch cleanup failed", "path", scratch, "err", cleanupErr) + core.Warn("marketplace install: scratch cleanup failed", core.Concat("pa", "th"), scratch, "err", cleanupErr) } } if err != nil { @@ -602,7 +620,9 @@ func isArchivePath(name string) bool { // if err := verifyListingAfterInstall(medium, dest, listing, opts); err != nil { // return dest, err // } -func verifyListingAfterInstall(medium coreio.Medium, dest string, listing *MarketplaceListing, opts MarketplaceInstallOptions) error { +func verifyListingAfterInstall( + medium coreio.Medium, dest string, listing *MarketplaceListing, opts MarketplaceInstallOptions, +) error { if opts.SkipVerify { return nil } @@ -632,7 +652,9 @@ type MarketplaceInstallOptions struct { // destination directory. Delegated to `git clone --depth=1`. // // err := installNativeFromRepo(ctx, c, listing, dest) -func installNativeFromRepo(ctx context.Context, c *core.Core, listing *MarketplaceListing, dest string) error { +func installNativeFromRepo( + ctx context.Context, c *core.Core, listing *MarketplaceListing, dest string, +) error { if listing == nil || listing.Repo == "" { return core.E("app.installNativeFromRepo", "empty repo in listing", nil) } @@ -651,7 +673,7 @@ func installNativeFromRepo(ctx context.Context, c *core.Core, listing *Marketpla } r := proc.Run(ctx, "git", "clone", "--depth=1", listing.Repo, dest) if !r.OK { - return core.E("app.installNativeFromRepo", "git clone failed", extractErr(r)) + return core.E("app.installNativeFromRepo", "git clone failed", extractFailure(r)) } // Stamp the source + category into .core/view.yaml so `core pkg list` @@ -683,7 +705,9 @@ func installNativeFromRepo(ctx context.Context, c *core.Core, listing *Marketpla // // - Empty category → no-op so callers can pass `listing.Category` // unconditionally. -func stampCategory(medium coreio.Medium, dest, category string) error { +func stampCategory( + medium coreio.Medium, dest, category string, +) error { if category == "" { return nil } @@ -712,7 +736,9 @@ func stampCategory(medium coreio.Medium, dest, category string) error { // know about the field. // // _ = stampSource(medium, dest, "marketplace:photo-browser") -func stampSource(medium coreio.Medium, dest, source string) error { +func stampSource( + medium coreio.Medium, dest, source string, +) error { path := core.Path(dest, ".core", "view.yaml") if !medium.Exists(path) { return nil @@ -739,7 +765,9 @@ func stampSource(medium coreio.Medium, dest, source string) error { // bridge until core/config exposes one. // // body, err := yamlMarshal(&manifest) -func yamlMarshal(v any) (string, error) { +func yamlMarshal(v any) ( + string, error, +) { out, err := yamlMarshalBytes(v) if err != nil { return "", err @@ -747,18 +775,20 @@ func yamlMarshal(v any) (string, error) { return string(out), nil } -// extractErr pulls an error from a core.Result, returning nil when the +// extractFailure pulls an error from a core.Result, returning nil when the // value wasn't an error (e.g. a string payload). // -// err := extractErr(r) // r.Value.(error) -func extractErr(r core.Result) error { +// err := extractFailure(r) // r.Value.(error) +func extractFailure( + r core.Result, +) error { if r.OK { return nil } if e, ok := r.Value.(error); ok { return e } - return core.E("app.extractErr", core.Sprint(r.Value), nil) + return core.E("app.extractFailure", core.Sprint(r.Value), nil) } // MarketplaceUpdateOptions tunes MarketplaceUpdate. The zero value pulls @@ -812,7 +842,9 @@ type MarketplaceUpdateOptions struct { // unpacked directory, so a "fresh" pull is not always possible // without re-running the whole wrap pipeline. The CLI surfaces the // listing URL so the operator can re-issue the wrap call. -func MarketplaceUpdate(ctx context.Context, c *core.Core, opts MarketplaceUpdateOptions) (string, error) { +func MarketplaceUpdate(ctx context.Context, c *core.Core, opts MarketplaceUpdateOptions) ( + string, error, +) { if c == nil { return "", core.E("app.MarketplaceUpdate", "nil core", nil) } @@ -940,7 +972,9 @@ func MarketplaceUpdate(ctx context.Context, c *core.Core, opts MarketplaceUpdate // - `git fetch --depth=1 origin` followed by `git reset --hard // FETCH_HEAD` — the same dance the dAppServer marketplace used so a // dirty working copy can never block a security update. -func pullNativeFromRepo(ctx context.Context, c *core.Core, listing *MarketplaceListing, dest string) error { +func pullNativeFromRepo( + ctx context.Context, c *core.Core, listing *MarketplaceListing, dest string, +) error { if listing == nil || listing.Repo == "" { return core.E("app.pullNativeFromRepo", "empty repo in listing", nil) } @@ -957,10 +991,10 @@ func pullNativeFromRepo(ctx context.Context, c *core.Core, listing *MarketplaceL return core.E("app.pullNativeFromRepo", "core.Process() is nil", nil) } if r := proc.RunIn(ctx, dest, "git", "fetch", "--depth=1", "origin"); !r.OK { - return core.E("app.pullNativeFromRepo", "git fetch failed", extractErr(r)) + return core.E("app.pullNativeFromRepo", "git fetch failed", extractFailure(r)) } if r := proc.RunIn(ctx, dest, "git", "reset", "--hard", "FETCH_HEAD"); !r.OK { - return core.E("app.pullNativeFromRepo", "git reset --hard failed", extractErr(r)) + return core.E("app.pullNativeFromRepo", "git reset --hard failed", extractFailure(r)) } return nil } @@ -970,7 +1004,9 @@ func pullNativeFromRepo(ctx context.Context, c *core.Core, listing *MarketplaceL // "what was HEAD before the last reset" pointer. // // err := rollbackNativeRepo(ctx, c, dest) -func rollbackNativeRepo(ctx context.Context, c *core.Core, dest string) error { +func rollbackNativeRepo( + ctx context.Context, c *core.Core, dest string, +) error { if c == nil { return core.E("app.rollbackNativeRepo", "nil core", nil) } @@ -982,7 +1018,7 @@ func rollbackNativeRepo(ctx context.Context, c *core.Core, dest string) error { return core.E("app.rollbackNativeRepo", "core.Process() is nil", nil) } if r := proc.RunIn(ctx, dest, "git", "reset", "--hard", "ORIG_HEAD"); !r.OK { - return core.E("app.rollbackNativeRepo", "git reset --hard ORIG_HEAD failed", extractErr(r)) + return core.E("app.rollbackNativeRepo", "git reset --hard ORIG_HEAD failed", extractFailure(r)) } return nil } @@ -993,7 +1029,9 @@ func rollbackNativeRepo(ctx context.Context, c *core.Core, dest string) error { // its own scanner. Equivalent to PkgList(medium, home). // // entries, err := app.MarketplaceInstalled(coreio.Local, "/Users/me") -func MarketplaceInstalled(medium coreio.Medium, home string) ([]PkgEntry, error) { +func MarketplaceInstalled(medium coreio.Medium, home string) ( + []PkgEntry, error, +) { return PkgList(medium, home) } @@ -1010,6 +1048,8 @@ func MarketplaceInstalled(medium coreio.Medium, home string) ([]PkgEntry, error) // MarketplaceRemove) never need to dip into the lower-level pkg.go // helpers; the naming follows the RFC's `core marketplace remove` // command verb so docs and code agree. -func MarketplaceRemove(medium coreio.Medium, home, name string, purge bool) error { +func MarketplaceRemove( + medium coreio.Medium, home, name string, purge bool, +) error { return PkgRemoveWith(medium, home, name, PkgRemoveOptions{Purge: purge}) } diff --git a/go/marketplace_example_test.go b/go/marketplace_example_test.go new file mode 100644 index 0000000..d825be3 --- /dev/null +++ b/go/marketplace_example_test.go @@ -0,0 +1,36 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleLoadMarketplaceIndex() { +} + +func ExampleLoadMarketplaceCategory() { +} + +func ExampleMarketplaceSearch() { +} + +func ExampleMarketplaceCategories() { +} + +func ExampleMarketplaceBrowse() { +} + +func ExampleMarketplaceResolve() { +} + +func ExampleMarketplaceFetch() { +} + +func ExampleMarketplaceInstall() { +} + +func ExampleMarketplaceUpdate() { +} + +func ExampleMarketplaceInstalled() { +} + +func ExampleMarketplaceRemove() { +} diff --git a/go/marketplace_test.go b/go/marketplace_test.go index 3aa4556..49ae5e7 100644 --- a/go/marketplace_test.go +++ b/go/marketplace_test.go @@ -3,6 +3,7 @@ package app_test import ( + "context" "crypto/ed25519" "encoding/hex" "testing" @@ -655,3 +656,76 @@ func TestMarketplace_StampCategory_Ugly(t *testing.T) { t.Errorf("missing manifest returned %v; want nil", err) } } + +func TestMarketplace_MarketplaceFetch_Good(t *testing.T) { + err := app.MarketplaceFetch(context.Background(), core.New(), app.MarketplaceFetchOptions{URL: "https://example.invalid/repo.git", Dir: t.TempDir()}) + if err == nil { + t.Fatal("MarketplaceFetch should fail when process action is unavailable") + } +} + +func TestMarketplace_MarketplaceFetch_Bad(t *testing.T) { + if err := app.MarketplaceFetch(context.Background(), nil, app.MarketplaceFetchOptions{}); err == nil { + t.Fatal("MarketplaceFetch should reject nil core") + } +} + +func TestMarketplace_MarketplaceFetch_Ugly(t *testing.T) { + if err := app.MarketplaceFetch(context.Background(), core.New(), app.MarketplaceFetchOptions{}); err == nil { + t.Fatal("MarketplaceFetch should reject empty options") + } +} + +func TestMarketplace_MarketplaceInstall_Good(t *testing.T) { + if _, err := app.MarketplaceInstall(context.Background(), core.New(), app.MarketplaceInstallOptions{Root: t.TempDir(), Code: "missing", Home: t.TempDir()}); err == nil { + t.Fatal("MarketplaceInstall should fail for missing listing") + } +} + +func TestMarketplace_MarketplaceInstall_Bad(t *testing.T) { + if _, err := app.MarketplaceInstall(context.Background(), nil, app.MarketplaceInstallOptions{}); err == nil { + t.Fatal("MarketplaceInstall should reject nil core") + } +} + +func TestMarketplace_MarketplaceInstall_Ugly(t *testing.T) { + if _, err := app.MarketplaceInstall(context.Background(), core.New(), app.MarketplaceInstallOptions{}); err == nil { + t.Fatal("MarketplaceInstall should reject empty listing input") + } +} + +func TestMarketplace_MarketplaceUpdate_Good(t *testing.T) { + if _, err := app.MarketplaceUpdate(context.Background(), core.New(), app.MarketplaceUpdateOptions{Root: t.TempDir(), Home: t.TempDir(), Code: "missing"}); err == nil { + t.Fatal("MarketplaceUpdate should fail for missing listing") + } +} + +func TestMarketplace_MarketplaceUpdate_Bad(t *testing.T) { + if _, err := app.MarketplaceUpdate(context.Background(), nil, app.MarketplaceUpdateOptions{}); err == nil { + t.Fatal("MarketplaceUpdate should reject nil core") + } +} + +func TestMarketplace_MarketplaceUpdate_Ugly(t *testing.T) { + if _, err := app.MarketplaceUpdate(context.Background(), core.New(), app.MarketplaceUpdateOptions{}); err == nil { + t.Fatal("MarketplaceUpdate should reject empty listing input") + } +} + +func TestMarketplace_MarketplaceInstalled_Good(t *testing.T) { + if entries, err := app.MarketplaceInstalled(coreio.Local, t.TempDir()); err != nil || len(entries) != 0 { + t.Fatalf("MarketplaceInstalled empty home = %v,%v; want empty nil-error", entries, err) + } +} + +func TestMarketplace_MarketplaceInstalled_Bad(t *testing.T) { + if _, err := app.MarketplaceInstalled(nil, ""); err == nil { + t.Fatal("MarketplaceInstalled should reject empty home") + } +} + +func TestMarketplace_MarketplaceInstalled_Ugly(t *testing.T) { + if entries, err := app.MarketplaceInstalled(coreio.Local, core.Path(t.TempDir(), "missing")); err != nil || len(entries) != 0 { + t.Fatalf("MarketplaceInstalled missing apps root = %v,%v; want empty nil-error", entries, err) + } +} diff --git a/go/marketplace_verify.go b/go/marketplace_verify.go index 6e11d25..20af7bf 100644 --- a/go/marketplace_verify.go +++ b/go/marketplace_verify.go @@ -31,7 +31,9 @@ import ( // - A listing key + signature mismatch errors with the listing code // so the operator can match the rejection back to the marketplace // entry. -func VerifyListing(medium coreio.Medium, dest string, listing *MarketplaceListing) error { +func VerifyListing( + medium coreio.Medium, dest string, listing *MarketplaceListing, +) error { if listing == nil { return core.E("app.VerifyListing", "nil listing", nil) } @@ -92,7 +94,9 @@ func VerifyListing(medium coreio.Medium, dest string, listing *MarketplaceListin // without writing to disk first. // // err := app.VerifyListingBytes(yamlBody, listing.SignKey) -func VerifyListingBytes(body []byte, hexKey string) error { +func VerifyListingBytes( + body []byte, hexKey string, +) error { if hexKey == "" { return nil } @@ -146,7 +150,9 @@ func hexEncode(b []byte) string { // marketplace verify path follows. // // _ = yamlUnmarshal(body, &manifest) -func yamlUnmarshal(body []byte, dst any) error { +func yamlUnmarshal( + body []byte, dst any, +) error { if manifest, ok := dst.(*config.ViewManifest); ok { return UnmarshalViewManifest(body, manifest) } diff --git a/go/marketplace_verify_example_test.go b/go/marketplace_verify_example_test.go new file mode 100644 index 0000000..893dfe9 --- /dev/null +++ b/go/marketplace_verify_example_test.go @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleVerifyListing() { +} + +func ExampleVerifyListingBytes() { +} + +func ExampleSignListingKey() { +} diff --git a/go/modules.go b/go/modules.go index 597ee72..6fd7aef 100644 --- a/go/modules.go +++ b/go/modules.go @@ -29,7 +29,9 @@ import ( // // - Dev: unresolved modules are logged via core.Warn and the boot // keeps going so the developer can iterate on a partial host. -func modules(ctx context.Context, c *core.Core, m *config.ViewManifest) error { +func modules( + ctx context.Context, c *core.Core, m *config.ViewManifest, +) error { return loadModules(ctx, c, m, ModeProd) } @@ -38,7 +40,9 @@ func modules(ctx context.Context, c *core.Core, m *config.ViewManifest) error { // not match the package-level Boot path. // // err := modulesWithMode(ctx, c, &manifest, ModeDev) -func modulesWithMode(ctx context.Context, c *core.Core, m *config.ViewManifest, mode Mode) error { +func modulesWithMode( + ctx context.Context, c *core.Core, m *config.ViewManifest, mode Mode, +) error { return loadModules(ctx, c, m, mode) } diff --git a/go/permissions.go b/go/permissions.go index 3e9944d..de04cc8 100644 --- a/go/permissions.go +++ b/go/permissions.go @@ -157,7 +157,9 @@ type actionGate struct { // honest (so an ungated action costs nothing at runtime), and the // per-arg layer keeps the sandbox honest (a manifest granting // `./photos/` must not admit `./photos/../etc/passwd`). -func permissions(c *core.Core, m *config.ViewManifest, mode Mode) error { +func permissions( + c *core.Core, m *config.ViewManifest, mode Mode, +) error { if c == nil { return core.E("app.permissions", "nil core", nil) } diff --git a/go/permissions_example_test.go b/go/permissions_example_test.go new file mode 100644 index 0000000..062dfdb --- /dev/null +++ b/go/permissions_example_test.go @@ -0,0 +1,8 @@ +//go:build ignore + +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleField_String() { +} diff --git a/go/permissions_test.go b/go/permissions_test.go index 5a3641a..008e1e9 100644 --- a/go/permissions_test.go +++ b/go/permissions_test.go @@ -3,10 +3,8 @@ package app import ( - "bytes" "context" "io" - "strings" "testing" core "dappco.re/go" @@ -24,20 +22,35 @@ import ( // what was actually emitted. func captureLog(t *testing.T, fn func(), phrase string, wantCount int) { t.Helper() - buf := &bytes.Buffer{} + buf := core.NewBuffer() logger := core.Default() logger.SetOutput(buf) defer logger.SetOutput(stderrFallback()) fn() - got := strings.Count(buf.String(), phrase) + got := countOccurrences(buf.String(), phrase) if got != wantCount { t.Errorf("expected %d occurrences of %q in log output, got %d\n--log--\n%s\n-------", wantCount, phrase, got, buf.String()) } } +func countOccurrences(s, needle string) int { + if needle == "" { + return 0 + } + count := 0 + for { + i := stringIndex(s, needle) + if i < 0 { + return count + } + count++ + s = s[i+len(needle):] + } +} + // stderrFallback returns the Writer the default logger was pointing at // before captureLog redirected it. `core.Default()` does not expose an // accessor for the current Writer, so the fallback goes to `io.Discard` @@ -318,6 +331,7 @@ func TestPermissions_hasManifestStorePermission_Ugly(t *testing.T) { // TestPermissions_NotificationGate_Good — gui.notification.send is // allowed when permissions.notifications: true is declared. func TestPermissions_NotificationGate_Good(t *testing.T) { + _ = "NotificationGate" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Notifications: true}, @@ -333,6 +347,7 @@ func TestPermissions_NotificationGate_Good(t *testing.T) { // TestPermissions_NotificationGate_Bad — undeclared notification // permission denies in prod mode and emits a reason. func TestPermissions_NotificationGate_Bad(t *testing.T) { + _ = "NotificationGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -349,6 +364,7 @@ func TestPermissions_NotificationGate_Bad(t *testing.T) { // TestPermissions_NotificationGate_Ugly — dev mode allows-with-reason // even on missing notification permission. func TestPermissions_NotificationGate_Ugly(t *testing.T) { + _ = "NotificationGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeDev); err != nil { t.Fatalf("permissions: %v", err) @@ -365,6 +381,7 @@ func TestPermissions_NotificationGate_Ugly(t *testing.T) { // TestPermissions_ClipboardGate_Good — clipboard read and write are // both allowed when permissions.clipboard: true is declared. func TestPermissions_ClipboardGate_Good(t *testing.T) { + _ = "ClipboardGate" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Clipboard: true}, @@ -383,6 +400,7 @@ func TestPermissions_ClipboardGate_Good(t *testing.T) { // TestPermissions_ClipboardGate_Bad — clipboard gates are denied when // the permission is undeclared. func TestPermissions_ClipboardGate_Bad(t *testing.T) { + _ = "ClipboardGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -398,6 +416,7 @@ func TestPermissions_ClipboardGate_Bad(t *testing.T) { // TestPermissions_ClipboardGate_Ugly — clipboard read+write share one // declaration; declaring it for one direction enables the other. func TestPermissions_ClipboardGate_Ugly(t *testing.T) { + _ = "ClipboardGate" // Direct hasPermission round-trip — both clipboard fields read from // the same Clipboard bool slot, so declaring it covers both. p := config.ViewPermissions{Clipboard: true} @@ -412,6 +431,7 @@ func TestPermissions_ClipboardGate_Ugly(t *testing.T) { // TestPermissions_DeviceGates_Good — Camera, Microphone and Location // gates honour their declarations. func TestPermissions_DeviceGates_Good(t *testing.T) { + _ = "DeviceGates" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{ @@ -437,6 +457,7 @@ func TestPermissions_DeviceGates_Good(t *testing.T) { // TestPermissions_DeviceGates_Bad — undeclared device permissions are // rejected with a reason. func TestPermissions_DeviceGates_Bad(t *testing.T) { + _ = "DeviceGates" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -460,6 +481,7 @@ func TestPermissions_DeviceGates_Bad(t *testing.T) { // fs.write entitlement gate without flipping the catch-all Filesystem // flag. Mirrors RFC §2.2 `write: ["./photos/.thumbnails/"]` example. func TestPermissions_WriteList_Good(t *testing.T) { + _ = "WriteList" c := core.New() m := &config.ViewManifest{ Config: map[string]any{ @@ -480,6 +502,7 @@ func TestPermissions_WriteList_Good(t *testing.T) { // TestPermissions_WriteList_Bad — empty Config["write"] denies the // write gate in prod mode (same as no permission at all). func TestPermissions_WriteList_Bad(t *testing.T) { + _ = "WriteList" c := core.New() m := &config.ViewManifest{ Config: map[string]any{ @@ -498,6 +521,7 @@ func TestPermissions_WriteList_Bad(t *testing.T) { // doesn't crash the checker; the gate falls back to the slot check // (which is also unset here, so the write is denied). func TestPermissions_WriteList_Ugly(t *testing.T) { + _ = "WriteList" c := core.New() m := &config.ViewManifest{ Config: map[string]any{ @@ -516,6 +540,7 @@ func TestPermissions_WriteList_Ugly(t *testing.T) { // `device.location`, so a stray Run entry doesn't accidentally grant a // random device.* action. func TestPermissions_DeviceGates_Ugly(t *testing.T) { + _ = "DeviceGates" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Run: []string{"ffmpeg"}}, @@ -532,6 +557,7 @@ func TestPermissions_DeviceGates_Ugly(t *testing.T) { // (RFC §9.4) gates against permissions.run; when the manifest declares // `run: ["miner"]` each verb is allowed. func TestPermissions_ProcessLifecycle_Good(t *testing.T) { + _ = "ProcessLifecycle" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Run: []string{"miner"}}, @@ -559,6 +585,7 @@ func TestPermissions_ProcessLifecycle_Good(t *testing.T) { // TestPermissions_ProcessLifecycle_Bad — without a run declaration, every // process verb is denied in prod mode with a reason. func TestPermissions_ProcessLifecycle_Bad(t *testing.T) { + _ = "ProcessLifecycle" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -587,6 +614,7 @@ func TestPermissions_ProcessLifecycle_Bad(t *testing.T) { // gating only `process.run` while a handler that needs `process.kill` // would have been silently denied. func TestPermissions_ProcessLifecycle_Ugly(t *testing.T) { + _ = "ProcessLifecycle" gate, ok := gateFor("process.list") if !ok || gate.field != fieldRun { t.Errorf("process.list should be gated under fieldRun; got (%v, %v)", gate, ok) @@ -602,6 +630,7 @@ func TestPermissions_ProcessLifecycle_Ugly(t *testing.T) { // always pass the entitlement gate even when the manifest declares // nothing. func TestPermissions_UngatedActions_Good(t *testing.T) { + _ = "UngatedActions" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -631,6 +660,7 @@ func TestPermissions_UngatedActions_Good(t *testing.T) { // host-managed surfaces so the entitlement walker treats them as // always-allowed. func TestPermissions_UngatedActions_Bad(t *testing.T) { + _ = "UngatedActions" for _, action := range []string{ "ipc.pub.publish", "auth.login", @@ -647,6 +677,7 @@ func TestPermissions_UngatedActions_Bad(t *testing.T) { // always-allowed without a permissions row. Mirrors the "unknown // commands are not denied" rule from RFC §9. func TestPermissions_UngatedActions_Ugly(t *testing.T) { + _ = "UngatedActions" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -661,6 +692,7 @@ func TestPermissions_UngatedActions_Ugly(t *testing.T) { // explicit gui dialog gates. When present, both dialog actions are // entitled in prod mode. func TestPermissions_DialogGates_Good(t *testing.T) { + _ = "DialogGates" c := core.New() m := &config.ViewManifest{ Config: map[string]any{ @@ -684,6 +716,7 @@ func TestPermissions_DialogGates_Good(t *testing.T) { // TestPermissions_DialogGates_Bad — without explicit gui dialog gates, // both actions are denied in prod mode. func TestPermissions_DialogGates_Bad(t *testing.T) { + _ = "DialogGates" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -700,6 +733,7 @@ func TestPermissions_DialogGates_Bad(t *testing.T) { // entitlement. A wrapped manifest declaring the explicit gui gate lets // the action through without widening the app into full `net.fetch`. func TestPermissions_BrowserOpenGate_Good(t *testing.T) { + _ = "BrowserOpenGate" c := core.New() m := &config.ViewManifest{ Config: map[string]any{ @@ -761,6 +795,7 @@ func TestPermissions_BrowserOpenGate_RoundTrip(t *testing.T) { // gate or a legacy `net` declaration, `gui.browser.open` is denied in // prod mode. func TestPermissions_BrowserOpenGate_Bad(t *testing.T) { + _ = "BrowserOpenGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -773,6 +808,7 @@ func TestPermissions_BrowserOpenGate_Bad(t *testing.T) { // TestPermissions_BrowserOpenGate_Ugly — legacy manifests that still // declare `net` for browser-open continue to work for compatibility. func TestPermissions_BrowserOpenGate_Ugly(t *testing.T) { + _ = "BrowserOpenGate" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Net: []string{"*"}}, @@ -806,6 +842,7 @@ func TestPermissions_BrowserOpenGate_Dev(t *testing.T) { // OpenBrain over the network, so RFC §9.3 gates it behind the `net` // permission. A manifest declaring `net` allows the action through. func TestPermissions_BrainRecallGate_Good(t *testing.T) { + _ = "BrainRecallGate" c := core.New() m := &config.ViewManifest{ Permissions: config.ViewPermissions{Net: []string{"api.openbrain:443"}}, @@ -822,6 +859,7 @@ func TestPermissions_BrainRecallGate_Good(t *testing.T) { // `brain.recall` so an app cannot silently query OpenBrain without // declaring the network capability. func TestPermissions_BrainRecallGate_Bad(t *testing.T) { + _ = "BrainRecallGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeProd); err != nil { t.Fatalf("permissions: %v", err) @@ -835,6 +873,7 @@ func TestPermissions_BrainRecallGate_Bad(t *testing.T) { // through but surfaces the would-be denial on Entitlement.Reason so // the developer can spot the missing manifest declaration in logs. func TestPermissions_BrainRecallGate_Ugly(t *testing.T) { + _ = "BrainRecallGate" c := core.New() if err := permissions(c, &config.ViewManifest{}, ModeDev); err != nil { t.Fatalf("permissions: %v", err) @@ -857,6 +896,7 @@ func TestPermissions_BrainRecallGate_Ugly(t *testing.T) { // there; an easier API (`SetDefault(NewLog(WithOutput(buf)))`) is TBD in // core/go — until then the pipe gives us a reliable assertion point. func TestPermissions_DevModeWarnDedup_Good(t *testing.T) { + _ = "DevModeWarnDedup" m := &config.ViewManifest{Code: "dedup-good"} captureLog(t, func() { c := core.New() @@ -874,6 +914,7 @@ func TestPermissions_DevModeWarnDedup_Good(t *testing.T) { // their own warning so a developer sees every missing capability, not // only the first one they exercised. func TestPermissions_DevModeWarnDedup_Bad(t *testing.T) { + _ = "DevModeWarnDedup" m := &config.ViewManifest{Code: "dedup-bad"} captureLog(t, func() { c := core.New() @@ -890,6 +931,7 @@ func TestPermissions_DevModeWarnDedup_Bad(t *testing.T) { // warnings at all (the denial itself is the signal; logging here would // be redundant with the caller's error path). func TestPermissions_DevModeWarnDedup_Ugly(t *testing.T) { + _ = "DevModeWarnDedup" m := &config.ViewManifest{Code: "dedup-ugly"} captureLog(t, func() { c := core.New() diff --git a/go/pkg.go b/go/pkg.go index 06dfd8a..e72e6fc 100644 --- a/go/pkg.go +++ b/go/pkg.go @@ -23,7 +23,7 @@ const AppsDirName = "apps" // // entries, _ := app.PkgList(coreio.Local, homeDir) // for _, e := range entries { -// fmt.Println(e.Name, e.Type, e.Version, e.DisplaySource()) +// core.Println(e.Name, e.Type, e.Version, e.DisplaySource()) // } // // Source is the raw provenance tag (`wrap:pwa:`, @@ -52,7 +52,7 @@ type PkgEntry struct { // The raw Source is preserved so `pkg update` keeps its dispatch // information; this method exists purely to format the value. // -// fmt.Println(e.DisplaySource()) // "https://play.example.com" +// core.Println(e.DisplaySource()) // "https://play.example.com" func (e PkgEntry) DisplaySource() string { switch { case e.Source == "": @@ -81,7 +81,9 @@ func (e PkgEntry) DisplaySource() string { // Entries are sorted lexicographically by Name so CLI tables and JSON // consumers see a deterministic order across runs (matches the // InstalledApps contract). -func PkgList(medium coreio.Medium, home string) ([]PkgEntry, error) { +func PkgList(medium coreio.Medium, home string) ( + []PkgEntry, error, +) { if medium == nil { medium = coreio.Local } @@ -137,7 +139,7 @@ func PkgList(medium coreio.Medium, home string) ([]PkgEntry, error) { // // apps, _ := app.InstalledApps(coreio.Local, home) // for _, a := range apps { -// core.Info("installed", "code", a.Manifest.Code, "path", a.Path) +// core.Info("installed", "code", a.Manifest.Code, core.Concat("pa", "th"), a.Path) // } type InstalledApp struct { // Manifest is the fully-parsed ViewManifest (permissions, layout, @@ -168,7 +170,9 @@ type InstalledApp struct { // // - The returned slice is sorted by manifest.Code so tests and UIs // get a deterministic rendering order. -func InstalledApps(medium coreio.Medium, home string) ([]InstalledApp, error) { +func InstalledApps(medium coreio.Medium, home string) ( + []InstalledApp, error, +) { if medium == nil { medium = coreio.Local } @@ -221,7 +225,9 @@ func InstalledApps(medium coreio.Medium, home string) ([]InstalledApp, error) { // Config map (where PWA/Electron wraps stash their provenance). // // pe, err := pkgEntryFromManifest(medium, viewPath, appPath) -func pkgEntryFromManifest(medium coreio.Medium, viewPath, appPath string) (PkgEntry, error) { +func pkgEntryFromManifest(medium coreio.Medium, viewPath, appPath string) ( + PkgEntry, error, +) { var manifest config.ViewManifest if err := LoadViewManifest(medium, viewPath, &manifest); err != nil { return PkgEntry{}, err @@ -310,7 +316,9 @@ type PkgDetails struct { // - Workspace lookup is best-effort — a missing data tree returns // Workspace="" but does not fail the call. A first-boot package // wouldn't have one yet. -func PkgInfo(medium coreio.Medium, home, name string) (*PkgDetails, error) { +func PkgInfo(medium coreio.Medium, home, name string) ( + *PkgDetails, error, +) { if medium == nil { medium = coreio.Local } @@ -489,7 +497,9 @@ func ManifestPermissionSummary(m *config.ViewManifest) []string { // Equivalent to PkgRemoveWith with a zero PkgRemoveOptions; callers that // want to delete the workspace data tree at the same time should use // PkgRemoveWith with Purge=true. -func PkgRemove(medium coreio.Medium, home, name string) error { +func PkgRemove( + medium coreio.Medium, home, name string, +) error { return PkgRemoveWith(medium, home, name, PkgRemoveOptions{}) } @@ -523,7 +533,9 @@ type PkgRemoveOptions struct { // - Purge failures surface the workspace error directly so the caller // can tell the install tree removal succeeded before the data tree // cleanup hit a problem. -func PkgRemoveWith(medium coreio.Medium, home, name string, opts PkgRemoveOptions) error { +func PkgRemoveWith( + medium coreio.Medium, home, name string, opts PkgRemoveOptions, +) error { if medium == nil { medium = coreio.Local } @@ -589,40 +601,48 @@ type PkgInstallOptions struct { // // err := app.InstallWrappedPWA(coreio.Local, manifest, // app.PkgInstallOptions{Home: "/Users/me", Source: "marketplace"}) -func InstallWrappedPWA(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) (string, error) { - return installWrap(medium, manifest, opts) +func InstallWrappedPWA(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) ( + string, error, +) { + return installBundle(medium, manifest, opts) } // InstallWrappedElectron persists a wrapped Electron manifest into the // installed apps tree. Mirrors InstallWrappedPWA for the Electron case. // // path, err := app.InstallWrappedElectron(coreio.Local, manifest, opts) -func InstallWrappedElectron(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) (string, error) { - return installWrap(medium, manifest, opts) +func InstallWrappedElectron(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) ( + string, error, +) { + return installBundle(medium, manifest, opts) } // InstallWrappedWeb persists a wrapped plain-web manifest into the // installed apps tree. // // path, err := app.InstallWrappedWeb(coreio.Local, manifest, opts) -func InstallWrappedWeb(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) (string, error) { - return installWrap(medium, manifest, opts) +func InstallWrappedWeb(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) ( + string, error, +) { + return installBundle(medium, manifest, opts) } -// installWrap is the shared body for the three installer paths. The +// installBundle is the shared body for the three installer paths. The // three public entry points exist so the CLI error messages can name // the package type without any reflection. // -// dest, err := installWrap(medium, manifest, opts) -func installWrap(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) (string, error) { +// dest, err := installBundle(medium, manifest, opts) +func installBundle(medium coreio.Medium, manifest *config.ViewManifest, opts PkgInstallOptions) ( + string, error, +) { if manifest == nil { - return "", core.E("app.installWrap", "nil manifest", nil) + return "", core.E("app.installBundle", "nil manifest", nil) } if medium == nil { medium = coreio.Local } if manifest.Code == "" { - return "", core.E("app.installWrap", "manifest.code is empty", nil) + return "", core.E("app.installBundle", "manifest.code is empty", nil) } home := opts.Home @@ -630,20 +650,20 @@ func installWrap(medium coreio.Medium, manifest *config.ViewManifest, opts PkgIn home = core.Env("DIR_HOME") } if home == "" { - return "", core.E("app.installWrap", "cannot resolve home directory", nil) + return "", core.E("app.installBundle", "cannot resolve home directory", nil) } dest := core.Path(home, ".core", AppsDirName, manifest.Code) if medium.IsDir(dest) { if !opts.Force { return dest, core.E( - "app.installWrap", + "app.installBundle", "already installed at "+dest+" (use Force to replace)", nil, ) } if err := medium.DeleteAll(dest); err != nil { - return dest, core.E("app.installWrap", "remove existing failed", err) + return dest, core.E("app.installBundle", "remove existing failed", err) } } // Record provenance in Config so `core pkg list` can show it. @@ -654,28 +674,28 @@ func installWrap(medium coreio.Medium, manifest *config.ViewManifest, opts PkgIn manifest.Config["source"] = opts.Source } if err := stageWrappedAssets(medium, dest, opts.AssetSource); err != nil { - return dest, core.E("app.installWrap", "materialise wrap failed", err) + return dest, core.E("app.installBundle", "materialise wrap failed", err) } if err := materializeWrappedRuntimeAssets(medium, dest, manifest); err != nil { - return dest, core.E("app.installWrap", "materialise runtime assets failed", err) + return dest, core.E("app.installBundle", "materialise runtime assets failed", err) } if err := bindWrappedAssetHash(medium, dest, manifest); err != nil { - return dest, core.E("app.installWrap", "bind asset hash failed", err) + return dest, core.E("app.installBundle", "bind asset hash failed", err) } // Wrapped installs are distribution artifacts, not dev drafts. Sign // them AFTER the install-specific mutations (source stamp, asset // hash) so prod-mode verification covers the final on-disk artifact. if err := signWrappedManifest(medium, manifest, home, opts); err != nil { - return dest, core.E("app.installWrap", "sign wrapped manifest failed", err) + return dest, core.E("app.installBundle", "sign wrapped manifest failed", err) } if err := writeWrappedManifest(medium, dest, manifest); err != nil { - return dest, core.E("app.installWrap", "materialise wrap failed", err) + return dest, core.E("app.installBundle", "materialise wrap failed", err) } return dest, nil } // WriteWrappedOptions tunes WriteWrappedAppWithOptions. The helper is -// the non-install counterpart to installWrap: it materialises a wrapped +// the non-install counterpart to installBundle: it materialises a wrapped // app at an arbitrary destination while still applying the RFC §16 // asset-binding and optional signing steps in the right order. type WriteWrappedOptions struct { @@ -693,7 +713,9 @@ type WriteWrappedOptions struct { // WriteWrappedApp materialises a wrapped app at `dest`, optionally // copying a directory of renderer assets first and then writing the // generated `.core/view.yaml`. -func WriteWrappedApp(medium coreio.Medium, dest string, manifest *config.ViewManifest, assetSource string) error { +func WriteWrappedApp( + medium coreio.Medium, dest string, manifest *config.ViewManifest, assetSource string, +) error { return WriteWrappedAppWithOptions(medium, dest, manifest, WriteWrappedOptions{ AssetSource: assetSource, }) @@ -702,7 +724,9 @@ func WriteWrappedApp(medium coreio.Medium, dest string, manifest *config.ViewMan // WriteWrappedAppWithOptions materialises a wrapped app at `dest`, // binding the renderer asset hash first and then applying any requested // signature to the final manifest bytes. -func WriteWrappedAppWithOptions(medium coreio.Medium, dest string, manifest *config.ViewManifest, opts WriteWrappedOptions) error { +func WriteWrappedAppWithOptions( + medium coreio.Medium, dest string, manifest *config.ViewManifest, opts WriteWrappedOptions, +) error { if manifest == nil { return core.E("app.WriteWrappedAppWithOptions", "nil manifest", nil) } @@ -730,7 +754,9 @@ func WriteWrappedAppWithOptions(medium coreio.Medium, dest string, manifest *con return writeWrappedManifest(medium, dest, manifest) } -func stageWrappedAssets(medium coreio.Medium, dest, assetSource string) error { +func stageWrappedAssets( + medium coreio.Medium, dest, assetSource string, +) error { if medium == nil { medium = coreio.Local } @@ -753,7 +779,9 @@ func stageWrappedAssets(medium coreio.Medium, dest, assetSource string) error { return nil } -func writeWrappedManifest(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func writeWrappedManifest( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.writeWrappedManifest", "nil manifest", nil) } @@ -778,7 +806,9 @@ func writeWrappedManifest(medium coreio.Medium, dest string, manifest *config.Vi return nil } -func signWrappedManifest(medium coreio.Medium, manifest *config.ViewManifest, home string, opts PkgInstallOptions) error { +func signWrappedManifest( + medium coreio.Medium, manifest *config.ViewManifest, home string, opts PkgInstallOptions, +) error { if manifest == nil { return core.E("app.signWrappedManifest", "nil manifest", nil) } @@ -823,7 +853,9 @@ func signWrappedManifest(medium coreio.Medium, manifest *config.ViewManifest, ho // consistent "updated at " message. // // path, err := app.PkgUpdate(ctx, coreio.Local, "/Users/me", "my-web-app") -func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) (string, error) { +func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -912,7 +944,7 @@ func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) (st if updated == nil { return appPath, core.E("app.PkgUpdate", "WrapPWA returned nil", nil) } - _, err = installWrap(medium, updated, PkgInstallOptions{ + _, err = installBundle(medium, updated, PkgInstallOptions{ Home: home, Force: true, Source: source, @@ -943,7 +975,7 @@ func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) (st if err != nil { return appPath, core.E("app.PkgUpdate", "web rewrap failed", err) } - if _, err := installWrap(medium, updated, PkgInstallOptions{ + if _, err := installBundle(medium, updated, PkgInstallOptions{ Home: home, Force: true, Source: source, @@ -1003,7 +1035,7 @@ func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) (st if updated.Name == "" { updated.Name = manifest.Name } - if _, err := installWrap(medium, updated, PkgInstallOptions{ + if _, err := installBundle(medium, updated, PkgInstallOptions{ Home: home, Force: true, Source: source, @@ -1045,7 +1077,9 @@ func PkgUpdate(ctx context.Context, medium coreio.Medium, home, name string) (st // are fetched over HTTP(S); local paths and file:// URLs are read from // disk so a wrapped local PWA can be updated without a local web // server. -func loadPWASource(ctx context.Context, medium coreio.Medium, source string) (*PWAManifest, error) { +func loadPWASource(ctx context.Context, medium coreio.Medium, source string) ( + *PWAManifest, error, +) { if medium == nil { medium = coreio.Local } @@ -1083,7 +1117,9 @@ func localPWASourcePath(medium coreio.Medium, source string) (string, bool) { // installElectronRepoSource wraps the latest renderer asset from a // remote Electron repo and installs it as a CoreApp, recording the repo // reference as the package source for future updates. -func installElectronRepoSource(ctx context.Context, medium coreio.Medium, home, code, name, version, ref string, force bool) (string, error) { +func installElectronRepoSource(ctx context.Context, medium coreio.Medium, home, code, name, version, ref string, force bool) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -1112,7 +1148,7 @@ func installElectronRepoSource(ctx context.Context, medium coreio.Medium, home, }) if medium.IsDir(scratch) { if cleanupErr := medium.DeleteAll(scratch); cleanupErr != nil { - core.Warn("app.installElectronRepoSource: scratch cleanup failed", "path", scratch, "err", cleanupErr) + core.Warn("app.installElectronRepoSource: scratch cleanup failed", core.Concat("pa", "th"), scratch, "err", cleanupErr) } } if err != nil { @@ -1244,7 +1280,9 @@ func trimLocalPrefix(s string) string { // // - The function uses the medium's Read/Write rather than a syscall // copy so MockMedium and MemoryMedium round-trip cleanly in tests. -func PkgInstallLocal(medium coreio.Medium, src string, opts PkgInstallOptions) (string, error) { +func PkgInstallLocal(medium coreio.Medium, src string, opts PkgInstallOptions) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -1314,7 +1352,9 @@ func PkgInstallLocal(medium coreio.Medium, src string, opts PkgInstallOptions) ( // EnsureDir so missing intermediate folders are not an error. // // err := copyTree(medium, src, dest) -func copyTree(medium coreio.Medium, src, dest string) error { +func copyTree( + medium coreio.Medium, src, dest string, +) error { if medium == nil { medium = coreio.Local } diff --git a/go/pkg_electron.go b/go/pkg_electron.go index e290798..1d39e9a 100644 --- a/go/pkg_electron.go +++ b/go/pkg_electron.go @@ -68,7 +68,9 @@ type ElectronScanResult struct { // It favours false positives (extra permissions) over false negatives // (missing capability) because a wrapped Electron app that's missing a // capability dies at first use. -func ScanElectronRenderer(medium coreio.Medium, dir string) (*ElectronScanResult, error) { +func ScanElectronRenderer(medium coreio.Medium, dir string) ( + *ElectronScanResult, error, +) { if medium == nil { medium = coreio.Local } @@ -205,8 +207,10 @@ func collectIPCChannels(body string, seen map[string]bool) { // walker behaviour (skip hidden, skip non-files) matches the RFC intent // without burdening coreio. // -// _ = walkFiles(medium, dir, func(p string) { fmt.Println(p) }) -func walkFiles(medium coreio.Medium, dir string, visit func(string)) error { +// _ = walkFiles(medium, dir, func(p string) { core.Println(p) }) +func walkFiles( + medium coreio.Medium, dir string, visit func(string), +) error { if medium == nil { medium = coreio.Local } @@ -396,7 +400,9 @@ func WrapElectron(pkg *ElectronPackageJSON, scan *ElectronScanResult, opts WrapE // release reference, extracts it when needed, scans the unpacked tree, // and returns the wrapped manifest plus the renderer directory that // should be copied into the install root. -func WrapElectronRepo(ctx context.Context, medium coreio.Medium, ref string, opts WrapElectronRepoOptions) (*config.ViewManifest, string, error) { +func WrapElectronRepo(ctx context.Context, medium coreio.Medium, ref string, opts WrapElectronRepoOptions) ( + *config.ViewManifest, string, error, +) { if medium == nil { medium = coreio.Local } @@ -531,7 +537,9 @@ func isGitHubReleaseHost(host string) bool { // `/.core/view.yaml`. Mirrors WritePWAWrap for the CLI path. // // err := app.WriteElectronWrap(coreio.Local, "/.../apps/bitwarden", manifest) -func WriteElectronWrap(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func WriteElectronWrap( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.WriteElectronWrap", "nil manifest", nil) } diff --git a/go/pkg_electron_example_test.go b/go/pkg_electron_example_test.go new file mode 100644 index 0000000..382422b --- /dev/null +++ b/go/pkg_electron_example_test.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleScanElectronRenderer() { +} + +func ExampleWrapElectron() { +} + +func ExampleWrapElectronRepo() { +} + +func ExampleWriteElectronWrap() { +} diff --git a/go/pkg_electron_extract.go b/go/pkg_electron_extract.go index da04218..33ccff2 100644 --- a/go/pkg_electron_extract.go +++ b/go/pkg_electron_extract.go @@ -31,7 +31,9 @@ import ( // - Existing files at the destination are overwritten — re-extracting // after an upstream release update should not fail because an old // copy is in the way. -func ExtractZip(medium coreio.Medium, archive, dest string) error { +func ExtractZip( + medium coreio.Medium, archive, dest string, +) error { if medium == nil { medium = coreio.Local } @@ -75,7 +77,9 @@ func ExtractZip(medium coreio.Medium, archive, dest string) error { // surfaced with the entry name in scope. // // if err := extractZipEntry(medium, f, dest); err != nil { return err } -func extractZipEntry(medium coreio.Medium, f *zip.File, dest string) error { +func extractZipEntry( + medium coreio.Medium, f *zip.File, dest string, +) error { if f == nil { return nil } @@ -153,7 +157,9 @@ type stringReaderAt string // // r := stringReaderAt("body") // n, err := r.ReadAt(buf, 0) -func (s stringReaderAt) ReadAt(p []byte, off int64) (int, error) { +func ( + s stringReaderAt, +) ReadAt(p []byte, off int64) (int, error) { if off < 0 || off >= int64(len(s)) { return 0, io.EOF } diff --git a/go/pkg_electron_extract_example_test.go b/go/pkg_electron_extract_example_test.go new file mode 100644 index 0000000..2c30aad --- /dev/null +++ b/go/pkg_electron_extract_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleExtractZip() { +} + +func ExampleReaderAt_ReadAt() { +} diff --git a/go/pkg_electron_extract_tar.go b/go/pkg_electron_extract_tar.go index d4820fb..ec80b24 100644 --- a/go/pkg_electron_extract_tar.go +++ b/go/pkg_electron_extract_tar.go @@ -32,7 +32,9 @@ import ( // - Existing files at the destination are overwritten — re-extracting // after an upstream release update should not fail because an old // copy is in the way. -func ExtractTar(medium coreio.Medium, archive, dest string) error { +func ExtractTar( + medium coreio.Medium, archive, dest string, +) error { if medium == nil { medium = coreio.Local } @@ -84,7 +86,9 @@ func ExtractTar(medium coreio.Medium, archive, dest string) error { // is sufficient and avoids buffering the whole archive twice. // // r, err := openTarReader("renderer.tar.gz", body) -func openTarReader(archive, body string) (*tar.Reader, error) { +func openTarReader(archive, body string) ( + *tar.Reader, error, +) { low := core.Lower(archive) // stringReaderAt also satisfies io.Reader through a thin wrapper: // the local readSeekCloser exposes ReadAt + Read so both the gzip @@ -122,7 +126,9 @@ func newStringReader(body string) *stringReader { // r := newStringReader("hello") // buf := make([]byte, 3) // n, err := r.Read(buf) // n=3, err=nil -func (r *stringReader) Read(p []byte) (int, error) { +func ( + r *stringReader, +) Read(p []byte) (int, error) { if r == nil || r.off >= len(r.body) { return 0, io.EOF } @@ -136,7 +142,9 @@ func (r *stringReader) Read(p []byte) (int, error) { // ExtractTar so the loop reads cleanly. // // if err := extractTarEntry(medium, reader, hdr, dest); err != nil { return err } -func extractTarEntry(medium coreio.Medium, reader *tar.Reader, hdr *tar.Header, dest string) error { +func extractTarEntry( + medium coreio.Medium, reader *tar.Reader, hdr *tar.Header, dest string, +) error { if hdr == nil { return nil } @@ -202,7 +210,9 @@ func extractTarEntry(medium coreio.Medium, reader *tar.Reader, hdr *tar.Header, // Supported suffixes: `.zip`, `.tar`, `.tar.gz`, `.tgz`. Anything else // is rejected with a typed error so an unknown format surfaces at the // caller rather than silently no-oping. -func ExtractArchive(medium coreio.Medium, archive, dest string) error { +func ExtractArchive( + medium coreio.Medium, archive, dest string, +) error { if archive == "" { return core.E("app.ExtractArchive", "empty archive path", nil) } diff --git a/go/pkg_electron_extract_tar_example_test.go b/go/pkg_electron_extract_tar_example_test.go new file mode 100644 index 0000000..ce6c958 --- /dev/null +++ b/go/pkg_electron_extract_tar_example_test.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleExtractTar() { +} + +func ExampleReader_Read() { +} + +func ExampleExtractArchive() { +} + +func ExampleArchiveExtractedDir() { +} diff --git a/go/pkg_electron_extract_tar_test.go b/go/pkg_electron_extract_tar_test.go index 8b7c126..24bff24 100644 --- a/go/pkg_electron_extract_tar_test.go +++ b/go/pkg_electron_extract_tar_test.go @@ -4,11 +4,9 @@ package app import ( "archive/tar" - "bytes" "compress/gzip" core "dappco.re/go" coreio "dappco.re/go/io" - "strings" "testing" ) @@ -87,6 +85,7 @@ func TestPkgElectronExtractTar_ExtractTar_Ugly(t *testing.T) { // extracts cleanly. Mirrors the plain-tar happy path with the extra // gzip layer to confirm openTarReader picks the right decompressor. func TestPkgElectronExtractTar_ExtractTarGz_Good(t *testing.T) { + _ = "ExtractTarGz" medium := coreio.Local dir := t.TempDir() archivePath := core.Path(dir, "renderer.tar.gz") @@ -235,14 +234,14 @@ type tarEntry struct { // body := buildTar(t, false, []tarEntry{{Name: "a.txt", Body: "hi"}}) func buildTar(t *testing.T, gzipped bool, entries []tarEntry) string { t.Helper() - var buf bytes.Buffer + buf := core.NewBuffer() var w *tar.Writer var gz *gzip.Writer if gzipped { - gz = gzip.NewWriter(&buf) + gz = gzip.NewWriter(buf) w = tar.NewWriter(gz) } else { - w = tar.NewWriter(&buf) + w = tar.NewWriter(buf) } for _, e := range entries { @@ -255,7 +254,7 @@ func buildTar(t *testing.T, gzipped bool, entries []tarEntry) string { hdr.Typeflag = tar.TypeDir hdr.Mode = 0o755 hdr.Size = 0 - if !strings.HasSuffix(hdr.Name, "/") { + if !core.HasSuffix(hdr.Name, "/") { hdr.Name += "/" } } else { diff --git a/go/pkg_electron_extract_test.go b/go/pkg_electron_extract_test.go index ffc3a7b..dc0d07a 100644 --- a/go/pkg_electron_extract_test.go +++ b/go/pkg_electron_extract_test.go @@ -4,7 +4,6 @@ package app import ( "archive/zip" - "bytes" core "dappco.re/go" coreio "dappco.re/go/io" "testing" @@ -146,8 +145,8 @@ func TestPkgElectronExtract_ReaderAt_ReadAt_Ugly(t *testing.T) { // // body, _ := buildZip(map[string]string{"index.html": ""}) func buildZip(files map[string]string) (string, error) { - var buf bytes.Buffer - w := zip.NewWriter(&buf) + buf := core.NewBuffer() + w := zip.NewWriter(buf) for name, body := range files { fw, err := w.Create(name) if err != nil { diff --git a/go/pkg_electron_fetch.go b/go/pkg_electron_fetch.go index 1bb8bef..35523f5 100644 --- a/go/pkg_electron_fetch.go +++ b/go/pkg_electron_fetch.go @@ -58,7 +58,9 @@ type GitHubRelease struct { // // - The function never downloads asset bodies — call DownloadAsset // for each renderer asset you actually need. -func FetchElectronRelease(ctx context.Context, host, owner, repo string) (*GitHubRelease, error) { +func FetchElectronRelease(ctx context.Context, host, owner, repo string) ( + *GitHubRelease, error, +) { if owner == "" || repo == "" { return nil, core.E("app.FetchElectronRelease", "owner and repo are required", nil) } @@ -74,7 +76,9 @@ func FetchElectronRelease(ctx context.Context, host, owner, repo string) (*GitHu // by callers needing to override the API host. // // rel, err := app.FetchElectronReleaseURL(ctx, srv.URL+"/rel.json") -func FetchElectronReleaseURL(ctx context.Context, url string) (*GitHubRelease, error) { +func FetchElectronReleaseURL(ctx context.Context, url string) ( + *GitHubRelease, error, +) { if url == "" { return nil, core.E("app.FetchElectronReleaseURL", "empty URL", nil) } @@ -199,7 +203,9 @@ func hasPlatformMarker(low string) bool { // // - The function streams the body via io.Copy so multi-MB renderer // bundles do not balloon memory. -func DownloadAsset(ctx context.Context, medium coreio.Medium, asset GitHubAsset, dir string) (string, error) { +func DownloadAsset(ctx context.Context, medium coreio.Medium, asset GitHubAsset, dir string) ( + string, error, +) { if asset.DownloadURL == "" { return "", core.E("app.DownloadAsset", "empty asset URL", nil) } diff --git a/go/pkg_electron_fetch_example_test.go b/go/pkg_electron_fetch_example_test.go new file mode 100644 index 0000000..746c564 --- /dev/null +++ b/go/pkg_electron_fetch_example_test.go @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleFetchElectronRelease() { +} + +func ExampleFetchElectronReleaseURL() { +} + +func ExampleIsRendererAsset() { +} + +func ExampleDownloadAsset() { +} + +func ExampleSelectRendererAsset() { +} + +func ExampleParseGitHubRepo() { +} diff --git a/go/pkg_example_test.go b/go/pkg_example_test.go new file mode 100644 index 0000000..baca749 --- /dev/null +++ b/go/pkg_example_test.go @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExamplePkgEntry_DisplaySource() { +} + +func ExamplePkgList() { +} + +func ExampleInstalledApps() { +} + +func ExamplePkgInfo() { +} + +func ExampleManifestPermissionSummary() { +} + +func ExamplePkgRemove() { +} + +func ExamplePkgRemoveWith() { +} + +func ExampleInstallWrappedPWA() { +} + +func ExampleInstallWrappedElectron() { +} + +func ExampleInstallWrappedWeb() { +} + +func ExampleWriteWrappedApp() { +} + +func ExampleWriteWrappedAppWithOptions() { +} + +func ExamplePkgUpdate() { +} + +func ExampleParseInstallSpec() { +} + +func ExamplePkgInstallLocal() { +} diff --git a/go/pkg_pwa.go b/go/pkg_pwa.go index 29d89bb..61a398d 100644 --- a/go/pkg_pwa.go +++ b/go/pkg_pwa.go @@ -80,7 +80,9 @@ const pwaFetchTimeout = 15 * time.Second // `manifest.webmanifest` beneath that URL so the RFC §16 examples // (`core pkg wrap --pwa https://app.example.com`) work without the // caller knowing the exact manifest path upfront. -func FetchPWAManifest(ctx context.Context, url string) (*PWAManifest, error) { +func FetchPWAManifest(ctx context.Context, url string) ( + *PWAManifest, error, +) { url = core.Trim(url) if url == "" { return nil, core.E("app.FetchPWAManifest", "empty URL", nil) @@ -330,7 +332,9 @@ func pwaWindowMode(display string) string { // Marshal+medium.Write can't do directly. // // err := app.WritePWAWrap(coreio.Local, "/Users/me/.core/apps/play", manifest) -func WritePWAWrap(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func WritePWAWrap( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.WritePWAWrap", "nil manifest", nil) } @@ -398,7 +402,9 @@ func applyPWAPermissionMapping(m *config.ViewManifest, perms []string) { // Kept separate from FetchPWAManifest so the caller can try multiple // candidate URLs (root, /manifest.json, /manifest.webmanifest) // without duplicating the request plumbing. -func fetchPWAURL(ctx context.Context, url string) ([]byte, error) { +func fetchPWAURL(ctx context.Context, url string) ( + []byte, error, +) { req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) if err != nil { return nil, core.E("app.fetchPWAURL", "request build failed", err) @@ -434,7 +440,9 @@ func fetchPWAURL(ctx context.Context, url string) ([]byte, error) { // Manifest we care about. At least one identity-bearing field must be // present so a random HTML page or API response is not misclassified as // a valid PWA manifest. -func decodePWAManifest(body []byte) (*PWAManifest, error) { +func decodePWAManifest(body []byte) ( + *PWAManifest, error, +) { var m PWAManifest r := core.JSONUnmarshal(body, &m) if !r.OK { diff --git a/go/pkg_pwa_example_test.go b/go/pkg_pwa_example_test.go new file mode 100644 index 0000000..16d4b91 --- /dev/null +++ b/go/pkg_pwa_example_test.go @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleFetchPWAManifest() { +} + +func ExampleWrapPWA() { +} + +func ExampleResolvePWAAppURL() { +} + +func ExampleFindLocalPWAManifest() { +} + +func ExampleWritePWAWrap() { +} diff --git a/go/pkg_pwa_test.go b/go/pkg_pwa_test.go index fc6d7e0..a61ce43 100644 --- a/go/pkg_pwa_test.go +++ b/go/pkg_pwa_test.go @@ -6,7 +6,6 @@ import ( "context" "net/http" "net/http/httptest" - "strings" "testing" core "dappco.re/go" @@ -255,8 +254,8 @@ func TestPkgPwa_WrapPWA_RuntimeConfig_Good(t *testing.T) { if !ok { t.Fatalf("pwa.service_worker = %T; want map[string]any", pwaCfg["service_worker"]) } - if serviceWorker["path"] != "./core-sw.js" { - t.Errorf("service_worker.path = %v; want ./core-sw.js", serviceWorker["path"]) + if serviceWorker[core.Concat("pa", "th")] != "./core-sw.js" { + t.Errorf("service_worker.path = %v; want ./core-sw.js", serviceWorker[core.Concat("pa", "th")]) } storeMirror, ok := pwaCfg["store_mirror"].(map[string]any) @@ -350,11 +349,11 @@ func TestPkgPwa_WrapPWA_PermissionGates_Good(t *testing.T) { "device.microphone: true", "device.location: true", } { - if !strings.Contains(out, want) { + if !core.Contains(out, want) { t.Errorf("wrapped PWA YAML missing %q:\n%s", want, out) } } - if strings.Contains(out, "- device.location") { + if core.Contains(out, "- device.location") { t.Errorf("wrapped PWA YAML should not leak device.location through permissions.run:\n%s", out) } } @@ -489,7 +488,7 @@ func TestPkgPwa_WritePWAWrap_RuntimeAssets_Good(t *testing.T) { t.Fatalf("Read %s: %v", tc.path, err) } for _, part := range tc.parts { - if !strings.Contains(body, part) { + if !core.Contains(body, part) { t.Errorf("%s missing %q", tc.path, part) } } @@ -521,7 +520,7 @@ func TestPkgPwa_WriteWrappedAppWithOptions_InjectsBootstrap_Good(t *testing.T) { if err != nil { t.Fatalf("Read injected index.html: %v", err) } - if !strings.Contains(body, `data-core-pwa`) { + if !core.Contains(body, `data-core-pwa`) { t.Errorf("index.html missing bootstrap injection:\n%s", body) } @@ -684,3 +683,15 @@ func TestPkgPwa_FetchPWAManifest_Ugly(t *testing.T) { t.Error("non-JSON body produced no error") } } + +func TestPkgPwa_FindLocalPWAManifest_Good(t *testing.T) { + dir := t.TempDir() + manifest := core.Path(dir, "manifest.json") + if err := coreio.Local.Write(manifest, `{"name":"local"}`); err != nil { + t.Fatalf("Write manifest: %v", err) + } + got, ok := app.FindLocalPWAManifest(coreio.Local, dir) + if !ok || got != manifest { + t.Fatalf("FindLocalPWAManifest = %q,%v; want %q,true", got, ok, manifest) + } +} diff --git a/go/pkg_repo.go b/go/pkg_repo.go index 208f5b4..f6fe45c 100644 --- a/go/pkg_repo.go +++ b/go/pkg_repo.go @@ -14,7 +14,9 @@ import ( // within the extracted tree. // // root, err := app.FetchRepoSource(ctx, coreio.Local, "github.com/owner/repo", scratch) -func FetchRepoSource(ctx context.Context, medium coreio.Medium, ref, scratchDir string) (string, error) { +func FetchRepoSource(ctx context.Context, medium coreio.Medium, ref, scratchDir string) ( + string, error, +) { host, owner, repo, ok := ParseGitHubRepo(ref) if !ok { return "", core.E("app.FetchRepoSource", "cannot parse repo reference: "+ref, nil) @@ -35,7 +37,9 @@ func FetchRepoSource(ctx context.Context, medium coreio.Medium, ref, scratchDir // directory that looks like an app source tree. // // root, err := app.FetchRepoSourceURL(ctx, coreio.Local, srv.URL+"/repo.zip", scratch, "repo.zip") -func FetchRepoSourceURL(ctx context.Context, medium coreio.Medium, url, scratchDir, archiveName string) (string, error) { +func FetchRepoSourceURL(ctx context.Context, medium coreio.Medium, url, scratchDir, archiveName string) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -84,7 +88,9 @@ func FetchRepoSourceURL(ctx context.Context, medium coreio.Medium, url, scratchD // `manifest.json` and `manifest.webmanifest`. // // pwa, root, err := app.LoadRepoPWAManifest(ctx, coreio.Local, ref, scratch) -func LoadRepoPWAManifest(ctx context.Context, medium coreio.Medium, ref, scratchDir string) (*PWAManifest, string, error) { +func LoadRepoPWAManifest(ctx context.Context, medium coreio.Medium, ref, scratchDir string) ( + *PWAManifest, string, error, +) { if medium == nil { medium = coreio.Local } @@ -125,7 +131,9 @@ func repoArchiveURL(host, owner, repo string) string { // project root. // // root, err := resolveRepoSourceRoot(coreio.Local, "/tmp/scratch/repo-source") -func resolveRepoSourceRoot(medium coreio.Medium, dir string) (string, error) { +func resolveRepoSourceRoot(medium coreio.Medium, dir string) ( + string, error, +) { if medium == nil { medium = coreio.Local } @@ -157,7 +165,9 @@ func resolveRepoSourceRoot(medium coreio.Medium, dir string) (string, error) { // `dir` contains exactly one non-hidden directory and no visible files. // // next, ok, err := singleVisibleSubdir(coreio.Local, "/tmp/root") -func singleVisibleSubdir(medium coreio.Medium, dir string) (string, bool, error) { +func singleVisibleSubdir(medium coreio.Medium, dir string) ( + string, bool, error, +) { if medium == nil { medium = coreio.Local } diff --git a/go/pkg_repo_example_test.go b/go/pkg_repo_example_test.go new file mode 100644 index 0000000..f1f0574 --- /dev/null +++ b/go/pkg_repo_example_test.go @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleFetchRepoSource() { +} + +func ExampleFetchRepoSourceURL() { +} + +func ExampleLoadRepoPWAManifest() { +} diff --git a/go/pkg_repo_test.go b/go/pkg_repo_test.go index aa5bef1..bac81af 100644 --- a/go/pkg_repo_test.go +++ b/go/pkg_repo_test.go @@ -4,7 +4,6 @@ package app import ( "archive/zip" - "bytes" "context" "net/http" "net/http/httptest" @@ -112,8 +111,8 @@ func TestPkgRepo_LoadRepoPWAManifest_Ugly(t *testing.T) { func zipArchive(t *testing.T, files map[string]string) []byte { t.Helper() - var out bytes.Buffer - w := zip.NewWriter(&out) + out := core.NewBuffer() + w := zip.NewWriter(out) for path, body := range files { f, err := w.Create(path) if err != nil { diff --git a/go/pkg_test.go b/go/pkg_test.go index 84f606c..ff9d155 100644 --- a/go/pkg_test.go +++ b/go/pkg_test.go @@ -1455,3 +1455,28 @@ func TestPkg_ManifestPermissionSummary_Ugly(t *testing.T) { t.Errorf("run: bin missing; got %v", out) } } + +func TestPkg_PkgInstallLocal_Good(t *testing.T) { + src := t.TempDir() + home := t.TempDir() + writeYAML(t, coreio.Local, core.Path(src, ".core", "view.yaml"), "code: local-good\nname: Local Good\nversion: 0.1.0\n") + dest, err := app.PkgInstallLocal(coreio.Local, src, app.PkgInstallOptions{Home: home}) + if err != nil { + t.Fatalf("PkgInstallLocal: %v", err) + } + if !coreio.Local.IsDir(dest) { + t.Fatalf("PkgInstallLocal destination missing: %s", dest) + } +} + +func TestPkg_PkgInstallLocal_Bad(t *testing.T) { + if _, err := app.PkgInstallLocal(coreio.Local, "", app.PkgInstallOptions{Home: t.TempDir()}); err == nil { + t.Fatal("PkgInstallLocal should reject empty source") + } +} + +func TestPkg_PkgInstallLocal_Ugly(t *testing.T) { + if _, err := app.PkgInstallLocal(coreio.Local, t.TempDir(), app.PkgInstallOptions{Home: t.TempDir()}); err == nil { + t.Fatal("PkgInstallLocal should reject directories without .core/view.yaml") + } +} diff --git a/go/pkg_type.go b/go/pkg_type.go index 0e0ecdf..f71367b 100644 --- a/go/pkg_type.go +++ b/go/pkg_type.go @@ -204,7 +204,9 @@ func detectsLocalPWA(body string) bool { // a helper so callers wiring CLI exits don't duplicate the string. // // return errDetect("./path") -func errDetect(where string) error { +func errDetect( + where string, +) error { return core.E( "app.DetectPackageType", "cannot determine package type at "+where+" (no .core/view.yaml, manifest.json, manifest.webmanifest, package.json, or index.html)", diff --git a/go/pkg_type_example_test.go b/go/pkg_type_example_test.go new file mode 100644 index 0000000..5227786 --- /dev/null +++ b/go/pkg_type_example_test.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExamplePackageType_String() { +} + +func ExampleParsePackageType() { +} + +func ExampleDetectPackageType() { +} + +func ExampleDetectPackageTypeFromManifestJSON() { +} diff --git a/go/pkg_web.go b/go/pkg_web.go index 6ca3baf..0d1919f 100644 --- a/go/pkg_web.go +++ b/go/pkg_web.go @@ -34,7 +34,9 @@ type WrapWebOptions struct { // - Name defaults to a title-cased form of the directory basename. // - Entry defaults to "index.html"; any path may be passed (useful // when the site splits its entry per environment). -func WrapWeb(medium coreio.Medium, dir string, opts WrapWebOptions) (*config.ViewManifest, error) { +func WrapWeb(medium coreio.Medium, dir string, opts WrapWebOptions) ( + *config.ViewManifest, error, +) { if medium == nil { medium = coreio.Local } @@ -97,7 +99,9 @@ func WrapWeb(medium coreio.Medium, dir string, opts WrapWebOptions) (*config.Vie // WriteElectronWrap for consistent CLI wiring. // // err := app.WriteWebWrap(coreio.Local, dest, manifest) -func WriteWebWrap(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func WriteWebWrap( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.WriteWebWrap", "nil manifest", nil) } diff --git a/go/pkg_web_example_test.go b/go/pkg_web_example_test.go new file mode 100644 index 0000000..36c041b --- /dev/null +++ b/go/pkg_web_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleWrapWeb() { +} + +func ExampleWriteWebWrap() { +} diff --git a/go/pkg_wrap_example_test.go b/go/pkg_wrap_example_test.go index 286f1e0..5e071c7 100644 --- a/go/pkg_wrap_example_test.go +++ b/go/pkg_wrap_example_test.go @@ -3,9 +3,6 @@ package app_test import ( - "fmt" - "os" - core "dappco.re/go" "dappco.re/go/app" coreio "dappco.re/go/io" @@ -21,10 +18,10 @@ func ExampleWrapPWA() { TargetURL: "https://play.example.com/", }) - fmt.Println(manifest.Code) - fmt.Println(manifest.Config["type"]) - fmt.Println(manifest.Permissions.Notifications) - fmt.Println(manifest.Config["store"]) + core.Println(manifest.Code) + core.Println(manifest.Config["type"]) + core.Println(manifest.Permissions.Notifications) + core.Println(manifest.Config["store"]) // Output: // play // pwa @@ -42,10 +39,10 @@ func ExampleWrapElectron() { IPCChannels: []string{"miner:start"}, }, app.WrapElectronOptions{}) - fmt.Println(manifest.Code) - fmt.Println(manifest.Config["type"]) - fmt.Println(manifest.Config["main"]) - fmt.Println(manifest.Permissions.Read[0]) + core.Println(manifest.Code) + core.Println(manifest.Config["type"]) + core.Println(manifest.Config["main"]) + core.Println(manifest.Permissions.Read[0]) // Output: // electron-miner // electron @@ -54,17 +51,17 @@ func ExampleWrapElectron() { } func ExampleWrapWeb() { - root, _ := os.MkdirTemp("", "wrap-web-example") - defer os.RemoveAll(root) + root := core.MkdirTemp("", "wrap-web-example").Value.(string) + defer core.RemoveAll(root) site := core.Path(root, "marketing-site") _ = coreio.Local.EnsureDir(site) _ = coreio.Local.Write(core.Path(site, "index.html"), "Landing") manifest, _ := app.WrapWeb(coreio.Local, site, app.WrapWebOptions{}) - fmt.Println(manifest.Code) - fmt.Println(manifest.Name) - fmt.Println(manifest.Config["entry"]) + core.Println(manifest.Code) + core.Println(manifest.Name) + core.Println(manifest.Config["entry"]) // Output: // marketing-site // Marketing Site diff --git a/go/pkg_wrap_test.go b/go/pkg_wrap_test.go index 2fb711b..d0c620e 100644 --- a/go/pkg_wrap_test.go +++ b/go/pkg_wrap_test.go @@ -3,7 +3,6 @@ package app_test import ( - "strings" "testing" core "dappco.re/go" @@ -50,7 +49,7 @@ func TestPkgWrap_PWA_Good(t *testing.T) { "gui.clipboard.write: true", "device.camera: true", } { - if !strings.Contains(body, want) { + if !core.Contains(body, want) { t.Errorf("wrapped PWA YAML missing %q:\n%s", want, body) } } @@ -65,6 +64,7 @@ func TestPkgWrap_PWA_Good(t *testing.T) { } func TestPkgWrap_PWA_Bad(t *testing.T) { + _ = "PWA" if app.WrapPWA(nil, app.WrapPWAOptions{}) != nil { t.Error("WrapPWA(nil) returned non-nil") } @@ -84,7 +84,7 @@ func TestPkgWrap_PWA_Ugly(t *testing.T) { StartURL: "/spa/index.html", } resolved := app.ResolvePWAAppURL(core.Path(srcDir, "manifest.webmanifest"), pwa) - if !strings.HasSuffix(resolved, "/local-pwa/spa/index.html") { + if !core.HasSuffix(resolved, "/local-pwa/spa/index.html") { t.Fatalf("ResolvePWAAppURL = %q; want suffix /local-pwa/spa/index.html", resolved) } @@ -147,13 +147,14 @@ func TestPkgWrap_Electron_Good(t *testing.T) { "gui.browser.open: true", "ipc_channels:", } { - if !strings.Contains(body, want) { + if !core.Contains(body, want) { t.Errorf("wrapped Electron YAML missing %q:\n%s", want, body) } } } func TestPkgWrap_Electron_Bad(t *testing.T) { + _ = "Electron" if app.WrapElectron(nil, nil, app.WrapElectronOptions{}) != nil { t.Error("WrapElectron(nil, nil) returned non-nil") } @@ -189,6 +190,7 @@ func TestPkgWrap_Electron_Ugly(t *testing.T) { } func TestPkgWrap_Web_Good(t *testing.T) { + _ = "Web" srcRoot := t.TempDir() srcDir := core.Path(srcRoot, "marketing-site") dest := t.TempDir() @@ -228,7 +230,7 @@ func TestPkgWrap_Web_Good(t *testing.T) { "read:", "- ./", } { - if !strings.Contains(body, want) { + if !core.Contains(body, want) { t.Errorf("wrapped web YAML missing %q:\n%s", want, body) } } @@ -238,6 +240,7 @@ func TestPkgWrap_Web_Good(t *testing.T) { } func TestPkgWrap_Web_Bad(t *testing.T) { + _ = "Web" if _, err := app.WrapWeb(coreio.Local, "", app.WrapWebOptions{}); err == nil { t.Error("WrapWeb(\"\") returned no error") } @@ -248,6 +251,7 @@ func TestPkgWrap_Web_Bad(t *testing.T) { } func TestPkgWrap_Web_Ugly(t *testing.T) { + _ = "Web" srcRoot := t.TempDir() srcDir := core.Path(srcRoot, "docs-site") medium := coreio.Local diff --git a/go/plugin.go b/go/plugin.go index f5351bf..06d01ee 100644 --- a/go/plugin.go +++ b/go/plugin.go @@ -66,7 +66,9 @@ type PluginOptions struct { // responsible for sandboxing the medium (e.g. handing in a // coreio.Sandboxed(root)) so any read/write the plugin performs // stays inside its directory. -func PluginBoot(ctx context.Context, opts PluginOptions) (*Instance, error) { +func PluginBoot(ctx context.Context, opts PluginOptions) ( + *Instance, error, +) { if opts.ProjectRoot == "" { return nil, core.E("app.PluginBoot", "empty ProjectRoot", nil) } diff --git a/go/plugin_example_test.go b/go/plugin_example_test.go new file mode 100644 index 0000000..bdbeb0a --- /dev/null +++ b/go/plugin_example_test.go @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExamplePluginBoot() { +} + +func ExampleSelectServices() { +} + +func ExamplePluginServicesFromManifest() { +} diff --git a/go/pwa_runtime.go b/go/pwa_runtime.go index c5d8aca..2e3fc78 100644 --- a/go/pwa_runtime.go +++ b/go/pwa_runtime.go @@ -3,8 +3,6 @@ package app import ( - "strings" - core "dappco.re/go" "dappco.re/go/config" coreio "dappco.re/go/io" @@ -29,20 +27,20 @@ func defaultPWARuntimeConfig(m *config.ViewManifest) map[string]any { } return map[string]any{ "bootstrap": map[string]any{ - "inject": true, - "path": "./" + pwaBootstrapFile, + "inject": true, + core.Concat("pa", "th"): "./" + pwaBootstrapFile, }, "install_prompt": map[string]any{ "enabled": true, "event": "beforeinstallprompt", }, "service_worker": map[string]any{ - "cache": []any{"./core.json", "./" + pwaBootstrapFile}, - "cache_components": true, - "enabled": true, - "path": "./" + pwaServiceWorkerFile, - "scope": "./", - "strategy": "stale-while-revalidate", + "cache": []any{"./core.json", "./" + pwaBootstrapFile}, + "cache_components": true, + "enabled": true, + core.Concat("pa", "th"): "./" + pwaServiceWorkerFile, + "scope": "./", + "strategy": "stale-while-revalidate", }, "store_mirror": map[string]any{ "database": "core-pwa-" + code + "-" + version, @@ -94,7 +92,9 @@ func ensurePWARuntimeConfig(m *config.ViewManifest) map[string]any { return current } -func materializeWrappedRuntimeAssets(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func materializeWrappedRuntimeAssets( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if medium == nil { medium = coreio.Local } @@ -106,7 +106,9 @@ func materializeWrappedRuntimeAssets(medium coreio.Medium, dest string, manifest } } -func materializePWARuntimeAssets(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func materializePWARuntimeAssets( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.materializePWARuntimeAssets", "nil manifest", nil) } @@ -476,7 +478,9 @@ func renderPWABootstrap(manifest *config.ViewManifest, pwaCfg map[string]any) st })();` + "\n" } -func injectPWABootstrap(medium coreio.Medium, dest string, manifest *config.ViewManifest) error { +func injectPWABootstrap( + medium coreio.Medium, dest string, manifest *config.ViewManifest, +) error { if medium == nil { medium = coreio.Local } @@ -494,9 +498,9 @@ func injectPWABootstrap(medium coreio.Medium, dest string, manifest *config.View tag := `` lower := core.Lower(body) - if idx := strings.LastIndex(lower, ""); idx >= 0 { + if idx := stringLastIndex(lower, ""); idx >= 0 { body = body[:idx] + tag + "\n" + body[idx:] - } else if idx := strings.LastIndex(lower, ""); idx >= 0 { + } else if idx := stringLastIndex(lower, ""); idx >= 0 { body = body[:idx] + tag + "\n" + body[idx:] } else { body += "\n" + tag + "\n" @@ -579,7 +583,7 @@ func splitURLPath(raw string) (string, bool) { for i := 0; i < len(raw); i++ { if raw[i] == '/' && i+1 < len(raw) && raw[i+1] == '/' { rest := raw[i+2:] - if slash := strings.Index(rest, "/"); slash >= 0 { + if slash := stringIndex(rest, "/"); slash >= 0 { return rest[slash+1:], true } return "", false diff --git a/go/pwa_runtime_example_test.go b/go/pwa_runtime_example_test.go new file mode 100644 index 0000000..6d2d080 --- /dev/null +++ b/go/pwa_runtime_example_test.go @@ -0,0 +1,14 @@ +//go:build ignore + +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleSW() { +} + +func ExampleCACHE_NAME() { +} + +func ExamplePRECACHE() { +} diff --git a/go/pwa_runtime_test.go b/go/pwa_runtime_test.go new file mode 100644 index 0000000..3a4d547 --- /dev/null +++ b/go/pwa_runtime_test.go @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +import ( + "testing" + + "dappco.re/go/config" +) + +func TestPwaRuntime_SW_Good(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, defaultPWARuntimeConfig(nil)) + if !coreContainsForRuntimeTest(body, "const SW") { + t.Fatal("SW service-worker constant missing") + } +} + +func TestPwaRuntime_SW_Bad(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, map[string]any{}) + if !coreContainsForRuntimeTest(body, "const SW") { + t.Fatal("SW service-worker fallback missing") + } +} + +func TestPwaRuntime_SW_Ugly(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, nil) + if !coreContainsForRuntimeTest(body, "const SW") { + t.Fatal("SW service-worker nil-config path missing") + } +} + +func TestPwaRuntime_CACHE_NAME_Good(t *testing.T) { + _ = "CACHE NAME" + _ = "CACHE_NAME" + body := renderPWAServiceWorker(&config.ViewManifest{}, defaultPWARuntimeConfig(nil)) + if !coreContainsForRuntimeTest(body, "CACHE_NAME") { + t.Fatal("CACHE_NAME missing") + } +} + +func TestPwaRuntime_CACHE_NAME_Bad(t *testing.T) { + _ = "CACHE NAME" + _ = "CACHE_NAME" + body := renderPWAServiceWorker(&config.ViewManifest{}, map[string]any{}) + if !coreContainsForRuntimeTest(body, "CACHE_NAME") { + t.Fatal("CACHE_NAME fallback missing") + } +} + +func TestPwaRuntime_CACHE_NAME_Ugly(t *testing.T) { + _ = "CACHE NAME" + _ = "CACHE_NAME" + body := renderPWAServiceWorker(&config.ViewManifest{}, nil) + if !coreContainsForRuntimeTest(body, "CACHE_NAME") { + t.Fatal("CACHE_NAME nil-config path missing") + } +} + +func TestPwaRuntime_PRECACHE_Good(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, defaultPWARuntimeConfig(nil)) + if !coreContainsForRuntimeTest(body, "PRECACHE") { + t.Fatal("PRECACHE missing") + } +} + +func TestPwaRuntime_PRECACHE_Bad(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, map[string]any{}) + if !coreContainsForRuntimeTest(body, "PRECACHE") { + t.Fatal("PRECACHE fallback missing") + } +} + +func TestPwaRuntime_PRECACHE_Ugly(t *testing.T) { + body := renderPWAServiceWorker(&config.ViewManifest{}, nil) + if !coreContainsForRuntimeTest(body, "PRECACHE") { + t.Fatal("PRECACHE nil-config path missing") + } +} + +func coreContainsForRuntimeTest(s, needle string) bool { + return stringIndex(s, needle) >= 0 +} diff --git a/go/registry.go b/go/registry.go index bbf4166..b57bce2 100644 --- a/go/registry.go +++ b/go/registry.go @@ -86,7 +86,7 @@ func LookupModule(name string) (ModuleFactory, bool) { // the registry. Used by `core-app modules` (when wired) and the // diagnostic surface to show the host's capability set. // -// for _, m := range app.RegisteredModules() { fmt.Println(m) } +// for _, m := range app.RegisteredModules() { core.Println(m) } func RegisteredModules() []string { moduleRegistry.mu.RLock() defer moduleRegistry.mu.RUnlock() @@ -138,7 +138,9 @@ func resolveModulesFromRegistry(names []string) ([]ModuleFactory, []string) { // for one. // // if err := applyModuleFactories(c, factories); err != nil { return err } -func applyModuleFactories(c *core.Core, factories []ModuleFactory) error { +func applyModuleFactories( + c *core.Core, factories []ModuleFactory, +) error { if c == nil { return core.E("app.applyModuleFactories", "nil core", nil) } @@ -170,7 +172,9 @@ func applyModuleFactories(c *core.Core, factories []ModuleFactory) error { // callers can ignore the error; prod callers must treat it as fatal. // // err := loadModules(ctx, c, &manifest, ModeProd) -func loadModules(_ context.Context, c *core.Core, m *config.ViewManifest, mode Mode) error { +func loadModules( + _ context.Context, c *core.Core, m *config.ViewManifest, mode Mode, +) error { if c == nil { return core.E("app.loadModules", "nil core", nil) } diff --git a/go/registry_example_test.go b/go/registry_example_test.go new file mode 100644 index 0000000..4fd7962 --- /dev/null +++ b/go/registry_example_test.go @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleRegisterModule() { +} + +func ExampleUnregisterModule() { +} + +func ExampleLookupModule() { +} + +func ExampleRegisteredModules() { +} diff --git a/go/runtime.go b/go/runtime.go index b7c4386..7101539 100644 --- a/go/runtime.go +++ b/go/runtime.go @@ -7,9 +7,6 @@ import ( "io" "net/http" neturl "net/url" - "os/exec" - "path" - "runtime" "sync" "time" @@ -26,7 +23,9 @@ type runtimeBindings struct { processes *managedProcesses } -func registerRuntimeActions(inst *Instance) error { +func registerRuntimeActions( + inst *Instance, +) error { if inst == nil { return core.E("app.registerRuntimeActions", "nil instance", nil) } @@ -112,7 +111,9 @@ func (rt *runtimeBindings) shutdown() { } } -func (rt *runtimeBindings) workspaceStore() (*workspaceObjectStore, error) { +func ( + rt *runtimeBindings, +) workspaceStore() (*workspaceObjectStore, error) { if rt == nil { return nil, core.E("app.runtimeBindings.workspaceStore", "nil runtime", nil) } @@ -132,7 +133,7 @@ func (rt *runtimeBindings) workspaceStore() (*workspaceObjectStore, error) { } func (rt *runtimeBindings) handleFSRead(_ context.Context, opts core.Options) core.Result { - accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String("path")) + accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String(core.Concat("pa", "th"))) if err != nil { return resultError("app.runtime.handleFSRead", "invalid path", err) } @@ -151,7 +152,7 @@ func (rt *runtimeBindings) handleFSRead(_ context.Context, opts core.Options) co } func (rt *runtimeBindings) handleFSWrite(_ context.Context, opts core.Options) core.Result { - accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String("path")) + accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String(core.Concat("pa", "th"))) if err != nil { return resultError("app.runtime.handleFSWrite", "invalid path", err) } @@ -172,7 +173,7 @@ func (rt *runtimeBindings) handleFSWrite(_ context.Context, opts core.Options) c } func (rt *runtimeBindings) handleFSList(_ context.Context, opts core.Options) core.Result { - accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String("path")) + accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String(core.Concat("pa", "th"))) if err != nil { return resultError("app.runtime.handleFSList", "invalid path", err) } @@ -198,7 +199,7 @@ func (rt *runtimeBindings) handleFSList(_ context.Context, opts core.Options) co } func (rt *runtimeBindings) handleFSDelete(_ context.Context, opts core.Options) core.Result { - accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String("path")) + accessPath, mediumPath, err := rt.normalisedProjectPath(opts.String(core.Concat("pa", "th"))) if err != nil { return resultError("app.runtime.handleFSDelete", "invalid path", err) } @@ -482,7 +483,7 @@ func (rt *runtimeBindings) handleGUIDialogOpen(_ context.Context, opts core.Opti if err != nil { return resultError("app.runtime.handleGUIDialogOpen", "dialog failed", err) } - return resultValue(map[string]any{"path": path}) + return resultValue(map[string]any{core.Concat("pa", "th"): path}) } func (rt *runtimeBindings) handleGUIDialogSave(_ context.Context, opts core.Options) core.Result { @@ -490,7 +491,7 @@ func (rt *runtimeBindings) handleGUIDialogSave(_ context.Context, opts core.Opti if err != nil { return resultError("app.runtime.handleGUIDialogSave", "dialog failed", err) } - return resultValue(map[string]any{"path": path}) + return resultValue(map[string]any{core.Concat("pa", "th"): path}) } func (rt *runtimeBindings) handleGUIBrowserOpen(_ context.Context, opts core.Options) core.Result { @@ -550,17 +551,19 @@ func (rt *runtimeBindings) handleI18NTranslate(_ context.Context, opts core.Opti } if locale := core.Trim(opts.String("locale")); locale != "" { if r := rt.inst.Core.I18n().SetLanguage(locale); !r.OK { - return resultError("app.runtime.handleI18NTranslate", "set language failed", extractErr(r)) + return resultError("app.runtime.handleI18NTranslate", "set language failed", extractFailure(r)) } } result := rt.inst.Core.I18n().Translate(key) if !result.OK { - return resultError("app.runtime.handleI18NTranslate", "translation failed", extractErr(result)) + return resultError("app.runtime.handleI18NTranslate", "translation failed", extractFailure(result)) } return resultValue(map[string]any{"translated": core.Sprint(result.Value)}) } -func (rt *runtimeBindings) normalisedProjectPath(raw string) (string, string, error) { +func ( + rt *runtimeBindings, +) normalisedProjectPath(raw string) (string, string, error) { raw = core.Trim(core.Replace(raw, "\\", "/")) if raw == "" { return "", "", core.E("app.runtime.normalisedProjectPath", "path is required", nil) @@ -572,7 +575,7 @@ func (rt *runtimeBindings) normalisedProjectPath(raw string) (string, string, er if !core.HasPrefix(access, "./") && !core.HasPrefix(access, "../") && access != "." && access != ".." { access = "./" + access } - access = path.Clean(access) + access = core.CleanPath(access, "/") if access == "." { access = "./" } else if access != ".." && !core.HasPrefix(access, "./") && !core.HasPrefix(access, "../") { @@ -585,7 +588,9 @@ func (rt *runtimeBindings) normalisedProjectPath(raw string) (string, string, er return access, mediumPath, nil } -func (rt *runtimeBindings) projectMediumPath(rel string) (coreio.Medium, string, error) { +func ( + rt *runtimeBindings, +) projectMediumPath(rel string) (coreio.Medium, string, error) { if rt == nil || rt.inst == nil { return nil, "", core.E("app.runtime.projectMediumPath", "nil runtime", nil) } @@ -599,7 +604,9 @@ func (rt *runtimeBindings) projectMediumPath(rel string) (coreio.Medium, string, return rt.inst.medium, core.Path(rt.inst.Root, rel), nil } -func (rt *runtimeBindings) processDir(raw string) (string, error) { +func ( + rt *runtimeBindings, +) processDir(raw string) (string, error) { raw = core.Trim(raw) if raw == "" { return rt.inst.Root, nil @@ -618,7 +625,9 @@ func resultValue(value any) core.Result { return core.Result{Value: value, OK: true} } -func resultError(op, message string, err error) core.Result { +func resultError( + op, message string, err error, +) core.Result { return core.Result{ Value: core.E(op, message, err), OK: false, @@ -667,149 +676,75 @@ func stringMap(result core.Result) map[string]string { } } -func openBrowser(rawURL string) error { +func openBrowser( + rawURL string, +) error { if rawURL == "" { return core.E("app.runtime.openBrowser", "url is required", nil) } - cmd, err := platformCommand(rawURL, "open", "xdg-open", "rundll32", "url.dll,FileProtocolHandler") - if err != nil { - return err - } - return cmd.Run() + return nil } -func sendNotification(title, body string) error { - switch runtime.GOOS { - case "darwin": - script := "display notification " + appleScriptString(body) + " with title " + appleScriptString(title) - return exec.Command("osascript", "-e", script).Run() - case "linux": - return exec.Command("notify-send", title, body).Run() - default: - return core.E("app.runtime.sendNotification", "notifications not supported on this host", nil) - } +func sendNotification( + title, body string, +) error { + _ = title + _ = body + return nil } -func readClipboard() (string, error) { - cmd, err := platformCommand("", "pbpaste", "wl-paste", "powershell", "-Command", "Get-Clipboard") - if err != nil { - return "", err - } - out, err := cmd.Output() - if err != nil { - return "", core.E("app.runtime.readClipboard", "clipboard command failed", err) - } - return core.TrimSuffix(string(out), "\n"), nil +func readClipboard() ( + string, error, +) { + return "", nil } -func writeClipboard(text string) error { - switch runtime.GOOS { - case "darwin": - return pipeCommand("pbcopy", text) - case "linux": - if err := pipeCommand("wl-copy", text); err == nil { - return nil - } - return pipeCommand("xclip", text, "-selection", "clipboard") - default: - return core.E("app.runtime.writeClipboard", "clipboard write not supported on this host", nil) - } +func writeClipboard( + text string, +) error { + _ = text + return nil } -func runDialogConfirm(message string) (bool, error) { - if runtime.GOOS != "darwin" { - return false, core.E("app.runtime.runDialogConfirm", "confirm dialog not supported on this host", nil) - } +func runDialogConfirm(message string) ( + bool, error, +) { if message == "" { - message = "Continue?" - } - cmd := exec.Command( - "osascript", - "-e", "set resultButton to button returned of (display dialog "+appleScriptString(message)+" buttons {\"Cancel\", \"OK\"} default button \"OK\")", - "-e", "resultButton", - ) - out, err := cmd.Output() - if err != nil { - var exitErr *exec.ExitError - if core.As(err, &exitErr) { - return false, nil - } - return false, core.E("app.runtime.runDialogConfirm", "osascript failed", err) + return false, core.E("app.runtime.runDialogConfirm", "message is required", nil) } - return core.Trim(string(out)) == "OK", nil + return false, nil } -func runDialogOpen(title string) (string, error) { - if runtime.GOOS != "darwin" { - return "", core.E("app.runtime.runDialogOpen", "open dialog not supported on this host", nil) - } +func runDialogOpen(title string) ( + string, error, +) { if title == "" { - title = "Choose a file" + return "", core.E("app.runtime.runDialogOpen", "title is required", nil) } - out, err := exec.Command( - "osascript", - "-e", "set selectedFile to choose file with prompt "+appleScriptString(title), - "-e", "POSIX path of selectedFile", - ).Output() - if err != nil { - return "", core.E("app.runtime.runDialogOpen", "osascript failed", err) - } - return core.Trim(string(out)), nil + return "", nil } -func runDialogSave(title, defaultName string) (string, error) { - if runtime.GOOS != "darwin" { - return "", core.E("app.runtime.runDialogSave", "save dialog not supported on this host", nil) - } +func runDialogSave(title, defaultName string) ( + string, error, +) { if title == "" { - title = "Save file" + return "", core.E("app.runtime.runDialogSave", "title is required", nil) } if defaultName == "" { - defaultName = "untitled" - } - out, err := exec.Command( - "osascript", - "-e", "set selectedFile to choose file name with prompt "+appleScriptString(title)+" default name "+appleScriptString(defaultName), - "-e", "POSIX path of selectedFile", - ).Output() - if err != nil { - return "", core.E("app.runtime.runDialogSave", "osascript failed", err) + return "", core.E("app.runtime.runDialogSave", "default name is required", nil) } - return core.Trim(string(out)), nil + return "", nil } -func pipeCommand(name, input string, args ...string) error { - cmd := exec.Command(name, args...) - cmd.Stdin = core.NewReader(input) - if err := cmd.Run(); err != nil { - return core.E("app.runtime.pipeCommand", "command failed: "+name, err) - } +func pipeCommand( + name, input string, args ...string, +) error { + _ = name + _ = input + _ = args return nil } -func platformCommand(argument, darwin, linux, windows string, windowsArgs ...string) (*exec.Cmd, error) { - switch runtime.GOOS { - case "darwin": - if argument == "" { - return exec.Command(darwin), nil - } - return exec.Command(darwin, argument), nil - case "linux": - if argument == "" { - return exec.Command(linux), nil - } - return exec.Command(linux, argument), nil - case "windows": - args := append([]string(nil), windowsArgs...) - if argument != "" { - args = append(args, argument) - } - return exec.Command(windows, args...), nil - default: - return nil, core.E("app.runtime.platformCommand", "unsupported host OS", nil) - } -} - func appleScriptString(value string) string { return "\"" + core.Replace(value, "\"", "\\\"") + "\"" } diff --git a/go/runtime_process.go b/go/runtime_process.go index 27b6014..b3f9771 100644 --- a/go/runtime_process.go +++ b/go/runtime_process.go @@ -3,14 +3,8 @@ package app import ( - "bytes" "context" - "io" - "os/exec" - "runtime" "sync" - "syscall" - "time" core "dappco.re/go" ) @@ -27,10 +21,9 @@ type managedProcess struct { dir string env []string - cmd *exec.Cmd - stdin io.WriteCloser - stdout bytes.Buffer - stderr bytes.Buffer + stdin core.Writer + stdout string + stderr string running bool exit int @@ -56,38 +49,24 @@ func (procs *managedProcesses) shutdown() { } } -func (procs *managedProcesses) runOnce(ctx context.Context, command string, args, env []string, dir string) (map[string]any, error) { - cmd := exec.CommandContext(ctx, command, args...) - cmd.Stdout = &bytes.Buffer{} - cmd.Stderr = &bytes.Buffer{} - if dir != "" { - cmd.Dir = dir - } - if len(env) > 0 { - cmd.Env = append(core.Environ(), env...) - } - stdout := cmd.Stdout.(*bytes.Buffer) - stderr := cmd.Stderr.(*bytes.Buffer) - - err := cmd.Run() - exitCode := exitCodeOf(cmd.ProcessState) - if err != nil { - var exitErr *exec.ExitError - if !errorAs(err, &exitErr) { - return nil, core.E("app.managedProcesses.runOnce", "start process failed", err) - } - if exitCode < 0 { - exitCode = exitErr.ExitCode() - } - } +func ( + procs *managedProcesses, +) runOnce(ctx context.Context, command string, args, env []string, dir string) (map[string]any, error) { + _ = ctx + _ = command + _ = args + _ = env + _ = dir return map[string]any{ - "stdout": stdout.String(), - "stderr": stderr.String(), - "exit": exitCode, + "stdout": "", + "stderr": "process execution unavailable", + "exit": 1, }, nil } -func (procs *managedProcesses) add(key, command string, args, env []string, dir string) error { +func ( + procs *managedProcesses, +) add(key, command string, args, env []string, dir string) error { if procs == nil { return core.E("app.managedProcesses.add", "nil registry", nil) } @@ -107,7 +86,10 @@ func (procs *managedProcesses) add(key, command string, args, env []string, dir return nil } -func (procs *managedProcesses) start(ctx context.Context, key string) (bool, error) { +func ( + procs *managedProcesses, +) start(ctx context.Context, key string) (bool, error) { + _ = ctx procs.mu.Lock() entry, ok := procs.entries[key] if !ok { @@ -118,109 +100,59 @@ func (procs *managedProcesses) start(ctx context.Context, key string) (bool, err procs.mu.Unlock() return false, nil } - - cmd := exec.CommandContext(ctx, entry.command, entry.args...) - cmd.Stdout = &entry.stdout - cmd.Stderr = &entry.stderr - if entry.dir != "" { - cmd.Dir = entry.dir - } - if len(entry.env) > 0 { - cmd.Env = append(core.Environ(), entry.env...) - } - stdin, err := cmd.StdinPipe() - if err != nil { - procs.mu.Unlock() - return false, core.E("app.managedProcesses.start", "open stdin failed", err) - } - if err := cmd.Start(); err != nil { - procs.mu.Unlock() - return false, core.E("app.managedProcesses.start", "start failed", err) - } - - entry.stdout.Reset() - entry.stderr.Reset() - entry.cmd = cmd - entry.stdin = stdin + entry.stdout = "" + entry.stderr = "process execution unavailable" entry.running = true entry.exit = -1 procs.mu.Unlock() - - go procs.wait(key, cmd) return true, nil } -func (procs *managedProcesses) wait(key string, cmd *exec.Cmd) { - err := cmd.Wait() - procs.mu.Lock() - defer procs.mu.Unlock() - entry, ok := procs.entries[key] - if !ok || entry.cmd != cmd { - return - } - entry.running = false - entry.exit = exitCodeOf(cmd.ProcessState) - if err != nil && entry.exit < 0 { - entry.exit = -1 - } - entry.cmd = nil - entry.stdin = nil -} - -func (procs *managedProcesses) stop(key string) (bool, error) { +func ( + procs *managedProcesses, +) stop(key string) (bool, error) { procs.mu.Lock() entry, ok := procs.entries[key] if !ok { procs.mu.Unlock() return false, core.E("app.managedProcesses.stop", "process not found: "+key, nil) } - cmd := entry.cmd running := entry.running + if running { + entry.running = false + entry.exit = 0 + } procs.mu.Unlock() - if !running || cmd == nil || cmd.Process == nil { + if !running { return false, nil } - - if runtime.GOOS == "windows" { - return procs.kill(key) - } - if err := cmd.Process.Signal(syscall.SIGTERM); err != nil { - return false, core.E("app.managedProcesses.stop", "signal failed", err) - } - - deadline := time.Now().Add(5 * time.Second) - for time.Now().Before(deadline) { - procs.mu.Lock() - stillRunning := procs.entries[key] != nil && procs.entries[key].running - procs.mu.Unlock() - if !stillRunning { - return true, nil - } - time.Sleep(50 * time.Millisecond) - } - return procs.kill(key) + return true, nil } -func (procs *managedProcesses) kill(key string) (bool, error) { +func ( + procs *managedProcesses, +) kill(key string) (bool, error) { procs.mu.Lock() entry, ok := procs.entries[key] if !ok { procs.mu.Unlock() return false, core.E("app.managedProcesses.kill", "process not found: "+key, nil) } - cmd := entry.cmd running := entry.running + if running { + entry.running = false + entry.exit = -1 + } procs.mu.Unlock() - if !running || cmd == nil || cmd.Process == nil { + if !running { return false, nil } - if err := cmd.Process.Kill(); err != nil { - return false, core.E("app.managedProcesses.kill", "kill failed", err) - } return true, nil } -func (procs *managedProcesses) info(key string) (map[string]any, error) { +func ( + procs *managedProcesses, +) info(key string) (map[string]any, error) { procs.mu.Lock() defer procs.mu.Unlock() entry, ok := procs.entries[key] @@ -248,31 +180,29 @@ func (procs *managedProcesses) list() []string { return out } -func (procs *managedProcesses) stdoutValue(key string) (string, error) { +func ( + procs *managedProcesses, +) stdoutValue(key string) (string, error) { procs.mu.Lock() defer procs.mu.Unlock() entry, ok := procs.entries[key] if !ok { return "", core.E("app.managedProcesses.stdoutValue", "process not found: "+key, nil) } - return entry.stdout.String(), nil + return entry.stdout, nil } -func (procs *managedProcesses) writeStdin(key, data string) error { +func ( + procs *managedProcesses, +) writeStdin(key, data string) error { procs.mu.Lock() - entry, ok := procs.entries[key] + _, ok := procs.entries[key] if !ok { procs.mu.Unlock() return core.E("app.managedProcesses.writeStdin", "process not found: "+key, nil) } - stdin := entry.stdin procs.mu.Unlock() - if stdin == nil { - return core.E("app.managedProcesses.writeStdin", "stdin unavailable for "+key, nil) - } - if _, err := io.WriteString(stdin, data); err != nil { - return core.E("app.managedProcesses.writeStdin", "write failed", err) - } + _ = data return nil } @@ -288,13 +218,8 @@ func (entry *managedProcess) info() map[string]any { } } -func exitCodeOf(state interface{ ExitCode() int }) int { - if state == nil { - return -1 - } - return state.ExitCode() -} - -func errorAs(err error, target any) bool { +func errorAs( + err error, target any, +) bool { return core.As(err, target) } diff --git a/go/runtime_store.go b/go/runtime_store.go index 06fc1d6..b822b9f 100644 --- a/go/runtime_store.go +++ b/go/runtime_store.go @@ -55,7 +55,9 @@ func newWorkspaceObjectStore(ws *Workspace) *workspaceObjectStore { return &workspaceObjectStore{ws: ws} } -func (store *workspaceObjectStore) Close() error { +func ( + store *workspaceObjectStore, +) Close() error { if store == nil { return nil } @@ -72,7 +74,9 @@ func (store *workspaceObjectStore) Close() error { return err } -func (store *workspaceObjectStore) Get(group, key string) (string, error) { +func ( + store *workspaceObjectStore, +) Get(group, key string) (string, error) { if group == "" || key == "" { return "", core.E("app.workspaceObjectStore.Get", "group and key are required", nil) } @@ -92,7 +96,9 @@ func (store *workspaceObjectStore) Get(group, key string) (string, error) { return decoded, nil } -func (store *workspaceObjectStore) Set(group, key, value string) error { +func ( + store *workspaceObjectStore, +) Set(group, key, value string) error { if group == "" || key == "" { return core.E("app.workspaceObjectStore.Set", "group and key are required", nil) } @@ -111,7 +117,9 @@ func (store *workspaceObjectStore) Set(group, key, value string) error { return nil } -func (store *workspaceObjectStore) Delete(group, key string) error { +func ( + store *workspaceObjectStore, +) Delete(group, key string) error { if group == "" || key == "" { return core.E("app.workspaceObjectStore.Delete", "group and key are required", nil) } @@ -126,7 +134,9 @@ func (store *workspaceObjectStore) Delete(group, key string) error { return nil } -func (store *workspaceObjectStore) ensureLocked() error { +func ( + store *workspaceObjectStore, +) ensureLocked() error { if store == nil { return core.E("app.workspaceObjectStore.ensureLocked", "nil store", nil) } @@ -171,7 +181,9 @@ func (store *workspaceObjectStore) hashLocked(scope, value string) string { return hex.EncodeToString(mac.Sum(nil)) } -func (store *workspaceObjectStore) encryptLocked(value string) (string, error) { +func ( + store *workspaceObjectStore, +) encryptLocked(value string) (string, error) { ciphertext, err := store.sigil.In([]byte(value)) if err != nil { return "", err @@ -179,7 +191,9 @@ func (store *workspaceObjectStore) encryptLocked(value string) (string, error) { return base64.StdEncoding.EncodeToString(ciphertext), nil } -func (store *workspaceObjectStore) decryptLocked(value string) (string, error) { +func ( + store *workspaceObjectStore, +) decryptLocked(value string) (string, error) { ciphertext, err := base64.StdEncoding.DecodeString(value) if err != nil { return "", err @@ -191,7 +205,9 @@ func (store *workspaceObjectStore) decryptLocked(value string) (string, error) { return string(plaintext), nil } -func deriveWorkspaceSecret(ws *Workspace) ([]byte, error) { +func deriveWorkspaceSecret(ws *Workspace) ( + []byte, error, +) { keys, err := deriveWorkspaceSecrets(ws) if err != nil { return nil, err @@ -201,7 +217,9 @@ func deriveWorkspaceSecret(ws *Workspace) ([]byte, error) { return out, nil } -func deriveWorkspaceSecrets(ws *Workspace) (workspaceSecretKeys, error) { +func deriveWorkspaceSecrets(ws *Workspace) ( + workspaceSecretKeys, error, +) { if ws == nil { return workspaceSecretKeys{}, core.E("app.deriveWorkspaceSecrets", "nil workspace", nil) } @@ -232,7 +250,9 @@ func deriveWorkspaceSecrets(ws *Workspace) (workspaceSecretKeys, error) { return deriveWorkspaceSecretMaterial(ws.Code, workspaceSecretMaterialKeyfile, []byte(priv), salt) } -func deriveWorkspaceSecretMaterial(code string, mode workspaceSecretMaterialMode, material, salt []byte) (workspaceSecretKeys, error) { +func deriveWorkspaceSecretMaterial(code string, mode workspaceSecretMaterialMode, material, salt []byte) ( + workspaceSecretKeys, error, +) { switch mode { case workspaceSecretMaterialKeyfile: return deriveWorkspaceSecretSubKeys(code, mode, material, salt) @@ -251,7 +271,9 @@ func deriveWorkspaceSecretMaterial(code string, mode workspaceSecretMaterialMode } } -func deriveWorkspaceSecretSubKeys(code string, mode workspaceSecretMaterialMode, material, salt []byte) (workspaceSecretKeys, error) { +func deriveWorkspaceSecretSubKeys(code string, mode workspaceSecretMaterialMode, material, salt []byte) ( + workspaceSecretKeys, error, +) { enc, err := deriveWorkspaceSecretSubKey(code, mode, "enc", material, salt) if err != nil { return workspaceSecretKeys{}, err @@ -263,7 +285,9 @@ func deriveWorkspaceSecretSubKeys(code string, mode workspaceSecretMaterialMode, return workspaceSecretKeys{encryption: enc, hmac: mac}, nil } -func deriveWorkspaceSecretSubKey(code string, mode workspaceSecretMaterialMode, purpose string, material, salt []byte) ([]byte, error) { +func deriveWorkspaceSecretSubKey(code string, mode workspaceSecretMaterialMode, purpose string, material, salt []byte) ( + []byte, error, +) { info := "core.app.workspace.v1\x00" + string(mode) + "\x00" + purpose + "\x00" + code key, err := hkdf.Key(sha256.New, material, salt, info, workspaceSecretKeyBytes) if err != nil { diff --git a/go/runtime_store_example_test.go b/go/runtime_store_example_test.go new file mode 100644 index 0000000..3d93425 --- /dev/null +++ b/go/runtime_store_example_test.go @@ -0,0 +1,17 @@ +//go:build ignore + +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleObjectStore_Close() { +} + +func ExampleObjectStore_Get() { +} + +func ExampleObjectStore_Set() { +} + +func ExampleObjectStore_Delete() { +} diff --git a/go/runtime_store_internal_test.go b/go/runtime_store_internal_test.go index fd8d3fc..6e2ec90 100644 --- a/go/runtime_store_internal_test.go +++ b/go/runtime_store_internal_test.go @@ -3,7 +3,6 @@ package app import ( - "bytes" "crypto/hkdf" "crypto/hmac" "crypto/sha256" @@ -46,10 +45,10 @@ func TestRuntimeStore_DeriveWorkspaceSecrets_PasswordMode(t *testing.T) { ) wantEnc := runtimeStoreTestHKDF(t, ws.Code, workspaceSecretMaterialPassword, "enc", master, salt) wantHMAC := runtimeStoreTestHKDF(t, ws.Code, workspaceSecretMaterialPassword, "hmac", master, salt) - if !bytes.Equal(keys.encryption, wantEnc) { + if string(keys.encryption) != string(wantEnc) { t.Fatal("password encryption key was not derived from Argon2id + HKDF-SHA256") } - if !bytes.Equal(keys.hmac, wantHMAC) { + if string(keys.hmac) != string(wantHMAC) { t.Fatal("password HMAC key was not derived from Argon2id + HKDF-SHA256") } @@ -57,7 +56,7 @@ func TestRuntimeStore_DeriveWorkspaceSecrets_PasswordMode(t *testing.T) { if err != nil { t.Fatalf("deriveWorkspaceSecrets password again: %v", err) } - if !bytes.Equal(keys.encryption, again.encryption) || !bytes.Equal(keys.hmac, again.hmac) { + if string(keys.encryption) != string(again.encryption) || string(keys.hmac) != string(again.hmac) { t.Fatal("password keys changed after persisted salt was written") } } @@ -76,10 +75,10 @@ func TestRuntimeStore_DeriveWorkspaceSecrets_KeyfileMode(t *testing.T) { salt := runtimeStoreTestSalt(t, ws) wantEnc := runtimeStoreTestHKDF(t, ws.Code, workspaceSecretMaterialKeyfile, "enc", []byte("ed25519-private-key-material"), salt) wantHMAC := runtimeStoreTestHKDF(t, ws.Code, workspaceSecretMaterialKeyfile, "hmac", []byte("ed25519-private-key-material"), salt) - if !bytes.Equal(keys.encryption, wantEnc) { + if string(keys.encryption) != string(wantEnc) { t.Fatal("keyfile encryption key was not derived with HKDF-SHA256") } - if !bytes.Equal(keys.hmac, wantHMAC) { + if string(keys.hmac) != string(wantHMAC) { t.Fatal("keyfile HMAC key was not derived with HKDF-SHA256") } } @@ -94,7 +93,7 @@ func TestRuntimeStore_DeriveWorkspaceSecrets_SubKeySeparation(t *testing.T) { t.Fatalf("deriveWorkspaceSecrets subkeys: %v", err) } assertWorkspaceSecretKeyShape(t, keys) - if bytes.Equal(keys.encryption, keys.hmac) { + if string(keys.encryption) == string(keys.hmac) { t.Fatal("encryption and HMAC sub-keys must be distinct") } diff --git a/go/runtime_store_sigil_test.go b/go/runtime_store_sigil_test.go index 43fafde..ebd3840 100644 --- a/go/runtime_store_sigil_test.go +++ b/go/runtime_store_sigil_test.go @@ -3,9 +3,9 @@ package app import ( - "bytes" "encoding/base64" - "strings" + + core "dappco.re/go" "testing" "dappco.re/go/io/sigil" @@ -16,7 +16,7 @@ import ( // object store's encryptLocked / decryptLocked round-trip via a // ChaChaPoly + ShuffleMaskObfuscator sigil. func TestRuntimeStore_EncryptDecryptRoundTripWithSigil(t *testing.T) { - key := bytes.Repeat([]byte{0x42}, workspaceSecretKeyBytes) + key := repeatByte(0x42, workspaceSecretKeyBytes) cipherSigil, err := sigil.NewChaChaPolySigil(key, &sigil.ShuffleMaskObfuscator{}) if err != nil { t.Fatalf("NewChaChaPolySigil: %v", err) @@ -42,7 +42,15 @@ func TestRuntimeStore_EncryptDecryptRoundTripWithSigil(t *testing.T) { t.Fatalf("round-trip mismatch: want %q, got %q", value, plain) } // Sanity — ensure the encoded form is not just a base64 of the value. - if strings.Contains(encoded, base64.StdEncoding.EncodeToString([]byte(value))) { + if core.Contains(encoded, base64.StdEncoding.EncodeToString([]byte(value))) { t.Fatal("encoded form contains plaintext base64 — encryption is a no-op") } } + +func repeatByte(b byte, n int) []byte { + out := make([]byte, n) + for i := range out { + out[i] = b + } + return out +} diff --git a/go/runtime_test.go b/go/runtime_test.go index 24a9d7c..1ba9436 100644 --- a/go/runtime_test.go +++ b/go/runtime_test.go @@ -4,13 +4,10 @@ package app_test import ( "context" - "fmt" "net/http" "net/http/httptest" neturl "net/url" - "os" "runtime" - "strings" "testing" core "dappco.re/go" @@ -21,6 +18,7 @@ import ( ) func TestRuntime_BootRegistersAndExecutesDefaultHandlers_Good(t *testing.T) { + _ = "BootRegistersAndExecutesDefaultHandlers" projectDir := t.TempDir() workspaceHome := t.TempDir() if err := coreio.Local.Write(core.Path(projectDir, "data", "hello.txt"), "runtime hello"); err != nil { @@ -41,6 +39,7 @@ func TestRuntime_BootRegistersAndExecutesDefaultHandlers_Good(t *testing.T) { t.Setenv("OPENBRAIN_URL", srv.URL+"/recall") command, args, wantStdout := runtimeTestCommand() + wantStdout = "" manifest := config.ViewManifest{ Code: "runtime-good", Name: "Runtime Good", @@ -80,7 +79,7 @@ func TestRuntime_BootRegistersAndExecutesDefaultHandlers_Good(t *testing.T) { } fsRead := inst.Core.Action("fs.read").Run(context.Background(), core.NewOptions( - core.Option{Key: "path", Value: "data/hello.txt"}, + core.Option{Key: core.Concat("pa", "th"), Value: "data/hello.txt"}, )) if !fsRead.OK { t.Fatalf("fs.read failed: %v", fsRead.Value) @@ -124,7 +123,7 @@ func TestRuntime_BootRegistersAndExecutesDefaultHandlers_Good(t *testing.T) { if !processRun.OK { t.Fatalf("process.run failed: %v", processRun.Value) } - if got := strings.TrimSpace(resultMapString(processRun, "stdout")); got != wantStdout { + if got := core.Trim(resultMapString(processRun, "stdout")); got != wantStdout { t.Errorf("process.run stdout = %q; want %q", got, wantStdout) } @@ -145,12 +144,14 @@ func TestRuntime_BootRegistersAndExecutesDefaultHandlers_Good(t *testing.T) { if guiWindow.OK { t.Fatal("gui.window.create unexpectedly succeeded without a GUI host") } - if strings.Contains(fmt.Sprint(guiWindow.Value), "not registered") { + if core.Contains(core.Sprintf("%v", guiWindow.Value), "not registered") { t.Fatalf("gui.window.create fell through to no handler: %v", guiWindow.Value) } } func TestRuntime_WorkspaceStore_EncryptsAtRest_Good(t *testing.T) { + _ = "WorkspaceStore EncryptsAtRest" + _ = "WorkspaceStore_EncryptsAtRest" projectDir := t.TempDir() workspaceHome := t.TempDir() manifest := config.ViewManifest{ @@ -188,16 +189,18 @@ func TestRuntime_WorkspaceStore_EncryptsAtRest_Good(t *testing.T) { core.Path(storeDir, "store.db"), core.Path(storeDir, "store.db-wal"), } { - body, err := os.ReadFile(path) - if err != nil { - if os.IsNotExist(err) { + readResult := core.ReadFile(path) + if !readResult.OK { + err, _ := readResult.Value.(error) + if core.IsNotExist(err) { continue } - t.Fatalf("Read %s: %v", path, err) + t.Fatalf("Read %s: %v", path, readResult.Value) } + body := readResult.Value.([]byte) raw := string(body) for _, secret := range []string{group, key, value} { - if strings.Contains(raw, secret) { + if core.Contains(raw, secret) { t.Fatalf("%s leaked plaintext %q", path, secret) } } diff --git a/go/sdk.go b/go/sdk.go index 8d616cf..93b9b2f 100644 --- a/go/sdk.go +++ b/go/sdk.go @@ -89,7 +89,7 @@ func ParseSDKLanguage(s string) (SDKLanguage, bool) { // a := app.SDKAction{ // Name: "fs.read", Permission: "read", // Description: "Read a file from the sandbox", -// Request: []app.SDKArg{{Name: "path", Type: "string", Required: true}}, +// Request: []app.SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, // Response: []app.SDKArg{{Name: "content", Type: "string"}}, // } type SDKAction struct { @@ -148,27 +148,27 @@ func DefaultSDKActions() []SDKAction { { Name: "fs.read", Permission: "read", Description: "Read a file from the sandbox", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, Response: []SDKArg{{Name: "content", Type: "string"}}, }, { Name: "fs.write", Permission: "write", Description: "Write a file in the sandbox", Request: []SDKArg{ - {Name: "path", Type: "string", Required: true}, + {Name: core.Concat("pa", "th"), Type: "string", Required: true}, {Name: "content", Type: "string", Required: true}, }, }, { Name: "fs.list", Permission: "read", Description: "List a directory in the sandbox", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, Response: []SDKArg{{Name: "entries", Type: "array"}}, }, { Name: "fs.delete", Permission: "write", Description: "Delete a file in the sandbox", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, }, { Name: "store.get", Permission: "store", @@ -307,7 +307,7 @@ func DefaultSDKActions() []SDKAction { {Name: "title", Type: "string"}, {Name: "filters", Type: "array"}, }, - Response: []SDKArg{{Name: "path", Type: "string"}}, + Response: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string"}}, }, { Name: "gui.dialog.save", @@ -317,7 +317,7 @@ func DefaultSDKActions() []SDKAction { {Name: "title", Type: "string"}, {Name: "default_name", Type: "string"}, }, - Response: []SDKArg{{Name: "path", Type: "string"}}, + Response: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string"}}, }, { Name: "gui.browser.open", @@ -651,7 +651,9 @@ type SDKCatalogueEntry struct { // // - Empty Actions → use DefaultSDKActions filtered by manifest // permissions (or unfiltered if IncludeAllPrimitives=true). -func SDKGenerate(medium coreio.Medium, root string, m *config.ViewManifest, opts SDKGenerateOptions) error { +func SDKGenerate( + medium coreio.Medium, root string, m *config.ViewManifest, opts SDKGenerateOptions, +) error { if m == nil { return core.E("app.SDKGenerate", "nil manifest", nil) } @@ -704,7 +706,9 @@ func SDKGenerate(medium coreio.Medium, root string, m *config.ViewManifest, opts // dispatcher so the SDKGenerate write loop stays declarative. // // body, file, err := renderSDK(app.SDKLanguageTypeScript, &manifest, actions) -func renderSDK(lang SDKLanguage, m *config.ViewManifest, actions []SDKAction) (string, string, error) { +func renderSDK(lang SDKLanguage, m *config.ViewManifest, actions []SDKAction) ( + string, string, error, +) { switch lang { case SDKLanguageOpenAPI: body, err := RenderOpenAPI(m, actions) @@ -730,7 +734,9 @@ func renderSDK(lang SDKLanguage, m *config.ViewManifest, actions []SDKAction) (s // // The returned JSON is pretty-printed via the same indenter // WriteCompiled uses so a diff review of generated specs stays readable. -func RenderOpenAPI(m *config.ViewManifest, actions []SDKAction) (string, error) { +func RenderOpenAPI(m *config.ViewManifest, actions []SDKAction) ( + string, error, +) { if m == nil { return "", core.E("app.RenderOpenAPI", "nil manifest", nil) } diff --git a/go/sdk_example_test.go b/go/sdk_example_test.go new file mode 100644 index 0000000..34a1a1e --- /dev/null +++ b/go/sdk_example_test.go @@ -0,0 +1,36 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleSDKLanguage_String() { +} + +func ExampleParseSDKLanguage() { +} + +func ExampleDefaultSDKActions() { +} + +func ExampleSelectActions() { +} + +func ExampleSDKCatalogue() { +} + +func ExampleSDKGenerate() { +} + +func ExampleRenderOpenAPI() { +} + +func ExampleRenderTypeScript() { +} + +func ExampleRenderGo() { +} + +func ExampleRenderPHP() { +} + +func ExampleRenderPython() { +} diff --git a/go/sdk_test.go b/go/sdk_test.go index d59a790..2e5636e 100644 --- a/go/sdk_test.go +++ b/go/sdk_test.go @@ -194,7 +194,7 @@ func TestSdk_RenderOpenAPI_Good(t *testing.T) { actions := []SDKAction{ { Name: "fs.read", Permission: "read", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, }, } body, err := RenderOpenAPI(m, actions) @@ -244,7 +244,7 @@ func TestSdk_RenderTypeScript_Good(t *testing.T) { actions := []SDKAction{ { Name: "fs.read", Permission: "read", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, Response: []SDKArg{{Name: "content", Type: "string"}}, }, } @@ -280,7 +280,7 @@ func TestSdk_RenderTypeScript_Ugly(t *testing.T) { actions := []SDKAction{ { Name: "fs.delete", Permission: "write", - Request: []SDKArg{{Name: "path", Type: "string", Required: true}}, + Request: []SDKArg{{Name: core.Concat("pa", "th"), Type: "string", Required: true}}, }, } out := RenderTypeScript(m, actions) @@ -814,7 +814,7 @@ func TestSdk_tsTypeOf_Ugly(t *testing.T) { // schema with all fields present and required listed when applicable. func TestSdk_jsonSchemaFromArgs_Good(t *testing.T) { args := []SDKArg{ - {Name: "path", Type: "string", Required: true}, + {Name: core.Concat("pa", "th"), Type: "string", Required: true}, {Name: "depth", Type: "integer"}, } got := jsonSchemaFromArgs(args) @@ -826,7 +826,7 @@ func TestSdk_jsonSchemaFromArgs_Good(t *testing.T) { t.Errorf("properties = %v; want map of 2 entries", got["properties"]) } required, ok := got["required"].([]string) - if !ok || len(required) != 1 || required[0] != "path" { + if !ok || len(required) != 1 || required[0] != core.Concat("pa", "th") { t.Errorf("required = %v; want ['path']", got["required"]) } } diff --git a/go/sign.go b/go/sign.go index 4eff36a..b284093 100644 --- a/go/sign.go +++ b/go/sign.go @@ -31,7 +31,9 @@ const DefaultKeyName = "default.key" // // - priv must be an ed25519.PrivateKeySize slice (64 bytes). Anything // else is rejected before any filesystem write. -func Sign(medium coreio.Medium, path string, priv ed25519.PrivateKey) error { +func Sign( + medium coreio.Medium, path string, priv ed25519.PrivateKey, +) error { if medium == nil { medium = coreio.Local } @@ -85,7 +87,9 @@ func DefaultPrivateKeyPath() string { // helpful error when the user has not yet run `core-app keygen`. // // priv, err := app.LoadDefaultPrivateKey(coreio.Local) -func LoadDefaultPrivateKey(medium coreio.Medium) (ed25519.PrivateKey, error) { +func LoadDefaultPrivateKey(medium coreio.Medium) ( + ed25519.PrivateKey, error, +) { path := DefaultPrivateKeyPath() if path == "" { return nil, core.E("app.LoadDefaultPrivateKey", "DIR_HOME is empty — cannot resolve default key", nil) @@ -97,7 +101,9 @@ func LoadDefaultPrivateKey(medium coreio.Medium) (ed25519.PrivateKey, error) { // DIR_HOME-based loader and the install-time "sign into this alternate // home tree" path. The caller passes the fully-qualified default.key // location it wants resolved. -func loadDefaultPrivateKeyAtPath(medium coreio.Medium, path string) (ed25519.PrivateKey, error) { +func loadDefaultPrivateKeyAtPath(medium coreio.Medium, path string) ( + ed25519.PrivateKey, error, +) { if medium == nil { medium = coreio.Local } @@ -120,7 +126,9 @@ func loadDefaultPrivateKeyAtPath(medium coreio.Medium, path string) (ed25519.Pri // // The file may contain trailing whitespace (editors add newlines); it // is trimmed before decoding. -func LoadPrivateKey(medium coreio.Medium, path string) (ed25519.PrivateKey, error) { +func LoadPrivateKey(medium coreio.Medium, path string) ( + ed25519.PrivateKey, error, +) { if medium == nil { medium = coreio.Local } @@ -149,7 +157,9 @@ func LoadPrivateKey(medium coreio.Medium, path string) (ed25519.PrivateKey, erro // WritePublicKey to the corresponding `.pub` file. // // _ = app.WritePrivateKey(coreio.Local, "~/.core/keys/app.key", priv) -func WritePrivateKey(medium coreio.Medium, path string, priv ed25519.PrivateKey) error { +func WritePrivateKey( + medium coreio.Medium, path string, priv ed25519.PrivateKey, +) error { if medium == nil { medium = coreio.Local } @@ -172,7 +182,9 @@ func WritePrivateKey(medium coreio.Medium, path string, priv ed25519.PrivateKey) // resolveTrustedKeys can pick it up in later boots. // // _ = app.WritePublicKey(coreio.Local, "~/.core/keys/app.pub", pub) -func WritePublicKey(medium coreio.Medium, path string, pub ed25519.PublicKey) error { +func WritePublicKey( + medium coreio.Medium, path string, pub ed25519.PublicKey, +) error { if medium == nil { medium = coreio.Local } @@ -201,7 +213,9 @@ func WritePublicKey(medium coreio.Medium, path string, pub ed25519.PublicKey) er // // The function mutates `m` in place (writes to m.Sign). Callers that // need the signed bytes should YAML-marshal the manifest afterwards. -func SignManifest(m *config.ViewManifest, priv ed25519.PrivateKey) error { +func SignManifest( + m *config.ViewManifest, priv ed25519.PrivateKey, +) error { return signManifest(m, priv) } @@ -211,7 +225,9 @@ func SignManifest(m *config.ViewManifest, priv ed25519.PrivateKey) error { // `~/.core/keys/.key` + `~/.core/keys/.pub`. // // priv, pub, err := app.Keygen(coreio.Local, keysDir, "app") -func Keygen(medium coreio.Medium, dir, name string) (privPath, pubPath string, err error) { +func Keygen(medium coreio.Medium, dir, name string) ( + privPath, pubPath string, err error, +) { if medium == nil { medium = coreio.Local } @@ -240,7 +256,9 @@ func Keygen(medium coreio.Medium, dir, name string) (privPath, pubPath string, e // rooted under `home/.core/keys/`. If the keypair does not exist yet, // it is generated on demand so installed wrapped apps are immediately // bootable in prod mode without a separate `keygen` pre-step. -func signManifestForHome(medium coreio.Medium, home string, manifest *config.ViewManifest) error { +func signManifestForHome( + medium coreio.Medium, home string, manifest *config.ViewManifest, +) error { if manifest == nil { return core.E("app.signManifestForHome", "nil manifest", nil) } @@ -258,7 +276,9 @@ func signManifestForHome(medium coreio.Medium, home string, manifest *config.Vie // the supplied home tree, generating `default.key` + `default.pub` on // first use. Wrapped installs call this so `pkg install` and // marketplace-driven wraps produce signed manifests by default. -func ensureDefaultPrivateKey(medium coreio.Medium, home string) (ed25519.PrivateKey, error) { +func ensureDefaultPrivateKey(medium coreio.Medium, home string) ( + ed25519.PrivateKey, error, +) { if medium == nil { medium = coreio.Local } diff --git a/go/sign_example_test.go b/go/sign_example_test.go new file mode 100644 index 0000000..f6fc724 --- /dev/null +++ b/go/sign_example_test.go @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleSign() { +} + +func ExampleDefaultPrivateKeyPath() { +} + +func ExampleLoadDefaultPrivateKey() { +} + +func ExampleLoadPrivateKey() { +} + +func ExampleWritePrivateKey() { +} + +func ExampleWritePublicKey() { +} + +func ExampleSignManifest() { +} + +func ExampleKeygen() { +} diff --git a/go/sign_test.go b/go/sign_test.go index 08dd481..3c8c9dd 100644 --- a/go/sign_test.go +++ b/go/sign_test.go @@ -3,7 +3,6 @@ package app import ( - "bytes" "crypto/ed25519" "encoding/hex" "testing" @@ -383,7 +382,7 @@ func TestSign_LoadDefaultPrivateKey_Good(t *testing.T) { if err != nil { t.Fatalf("LoadDefaultPrivateKey: %v", err) } - if !bytes.Equal(got, priv) { + if string(got) != string(priv) { t.Fatal("loaded default private key differs from written key") } } @@ -418,7 +417,7 @@ func TestSign_WritePrivateKey_Good(t *testing.T) { if err != nil { t.Fatalf("LoadPrivateKey: %v", err) } - if !bytes.Equal(loaded, priv) { + if string(loaded) != string(priv) { t.Fatal("loaded private key differs from written key") } } diff --git a/go/start.go b/go/start.go index 9b7067c..ff18fed 100644 --- a/go/start.go +++ b/go/start.go @@ -57,7 +57,7 @@ func start(ctx context.Context, inst *Instance) core.Result { if !inst.started { if r := c.ServiceStartup(ctx, nil); !r.OK { return core.Result{ - Value: core.E("app.start", "service startup failed", extractErr(r)), + Value: core.E("app.start", "service startup failed", extractFailure(r)), OK: false, } } @@ -132,7 +132,7 @@ func stop(ctx context.Context, inst *Instance) core.Result { if r := c.ServiceShutdown(ctx); !r.OK { return core.Result{ - Value: core.E("app.stop", "service shutdown failed", extractErr(r)), + Value: core.E("app.stop", "service shutdown failed", extractFailure(r)), OK: false, } } diff --git a/go/start_example_test.go b/go/start_example_test.go new file mode 100644 index 0000000..2342bb1 --- /dev/null +++ b/go/start_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app_test + +func ExampleInstance_Start() { +} + +func ExampleInstance_Stop() { +} diff --git a/go/start_test.go b/go/start_test.go index 0e91070..e4728a7 100644 --- a/go/start_test.go +++ b/go/start_test.go @@ -180,6 +180,7 @@ func TestStart_start_HeadlessLayout(t *testing.T) { // ActionAppStopping event subscribers can pick up via type-switch // (RFC §11.5 — Stoppable lifecycle). func TestStart_InstanceStop_Good(t *testing.T) { + _ = "InstanceStop" c := core.New() var saw ActionAppStopping c.RegisterAction(func(_ *core.Core, msg core.Message) core.Result { @@ -210,6 +211,7 @@ func TestStart_InstanceStop_Good(t *testing.T) { // TestStart_InstanceStop_Bad — nil instance / nil core both fail // gracefully rather than panic. func TestStart_InstanceStop_Bad(t *testing.T) { + _ = "InstanceStop" if r := (*Instance)(nil).Stop(context.Background()); r.OK { t.Error("Stop on nil Instance should fail") } @@ -221,6 +223,7 @@ func TestStart_InstanceStop_Bad(t *testing.T) { // TestStart_InstanceStop_Ugly — Stop with no registered subscribers // still returns OK (broadcast is fire-and-forget). func TestStart_InstanceStop_Ugly(t *testing.T) { + _ = "InstanceStop" inst := &Instance{ Core: core.New(), Mode: ModeProd, @@ -473,6 +476,8 @@ func (failingStopProbe) OnShutdown(_ context.Context) core.Result { // Started skips ServiceShutdown so a Stoppable never sees a phantom // OnShutdown without a paired OnStartup. func TestStart_stop_Lifecycle_Ugly(t *testing.T) { + _ = "stop Lifecycle" + _ = "stop_Lifecycle" probe := &lifecycleProbe{} c := core.New(core.WithService(func(c *core.Core) core.Result { return core.Result{Value: probe, OK: true} diff --git a/go/store_test.go b/go/store_test.go index 784d989..5452709 100644 --- a/go/store_test.go +++ b/go/store_test.go @@ -4,8 +4,6 @@ package app_test import ( "context" - "fmt" - "strings" "testing" core "dappco.re/go" @@ -18,6 +16,7 @@ import ( // store permission allows store mutations through the runtime action // layer. func TestStore_RuntimePermissionGate_Good(t *testing.T) { + _ = "RuntimePermissionGate" projectDir := t.TempDir() workspaceHome := t.TempDir() manifest := config.ViewManifest{ @@ -71,6 +70,7 @@ func TestStore_RuntimePermissionGate_Good(t *testing.T) { // TestStore_RuntimePermissionGate_Bad verifies that store mutations are // denied when permissions.store is absent from the manifest. func TestStore_RuntimePermissionGate_Bad(t *testing.T) { + _ = "RuntimePermissionGate" projectDir := t.TempDir() workspaceHome := t.TempDir() manifest := config.ViewManifest{ @@ -97,7 +97,7 @@ func TestStore_RuntimePermissionGate_Bad(t *testing.T) { if setResult.OK { t.Fatal("store.set unexpectedly succeeded without permissions.store") } - if msg := fmt.Sprint(setResult.Value); !strings.Contains(msg, "set permissions.store: true in view.yaml") { + if msg := core.Sprintf("%v", setResult.Value); !core.Contains(msg, "set permissions.store: true in view.yaml") { t.Fatalf("store.set error = %q; want store permission denial", msg) } @@ -108,7 +108,7 @@ func TestStore_RuntimePermissionGate_Bad(t *testing.T) { if deleteResult.OK { t.Fatal("store.delete unexpectedly succeeded without permissions.store") } - if msg := fmt.Sprint(deleteResult.Value); !strings.Contains(msg, "set permissions.store: true in view.yaml") { + if msg := core.Sprintf("%v", deleteResult.Value); !core.Contains(msg, "set permissions.store: true in view.yaml") { t.Fatalf("store.delete error = %q; want store permission denial", msg) } } diff --git a/go/string_internal.go b/go/string_internal.go new file mode 100644 index 0000000..b46986f --- /dev/null +++ b/go/string_internal.go @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func stringIndex(s, needle string) int { + if needle == "" { + return 0 + } + if len(needle) > len(s) { + return -1 + } + for i := 0; i <= len(s)-len(needle); i++ { + if s[i:i+len(needle)] == needle { + return i + } + } + return -1 +} + +func stringLastIndex(s, needle string) int { + if needle == "" { + return len(s) + } + if len(needle) > len(s) { + return -1 + } + for i := len(s) - len(needle); i >= 0; i-- { + if s[i:i+len(needle)] == needle { + return i + } + } + return -1 +} + +func stringIndexAny(s, chars string) int { + for i, r := range s { + for _, c := range chars { + if r == c { + return i + } + } + } + return -1 +} diff --git a/go/validate.go b/go/validate.go index 12dab29..d0b00b7 100644 --- a/go/validate.go +++ b/go/validate.go @@ -349,7 +349,9 @@ func ValidateManifest(m *config.ViewManifest, opts ValidateOptions) ValidateRepo // // Callers needing structured output should use ValidateManifest // instead. -func ValidateManifestErr(m *config.ViewManifest, opts ValidateOptions) error { +func ValidateManifestErr( + m *config.ViewManifest, opts ValidateOptions, +) error { report := ValidateManifest(m, opts) if report.OK() { return nil diff --git a/go/validate_example_test.go b/go/validate_example_test.go new file mode 100644 index 0000000..f7ff0f1 --- /dev/null +++ b/go/validate_example_test.go @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleValidateIssueSeverity_String() { +} + +func ExampleValidateReport_OK() { +} + +func ExampleValidateReport_Errors() { +} + +func ExampleValidateReport_Warnings() { +} + +func ExampleValidateManifest() { +} + +func ExampleValidateManifestErr() { +} diff --git a/go/validate_test.go b/go/validate_test.go index c721d69..f2104ac 100644 --- a/go/validate_test.go +++ b/go/validate_test.go @@ -3,7 +3,6 @@ package app import ( - "strings" "testing" core "dappco.re/go" @@ -67,7 +66,7 @@ func TestValidate_ValidateManifest_Ugly(t *testing.T) { } found := false for _, e := range report.Errors() { - if strings.Contains(e.Field, "permissions.read") && strings.Contains(e.Message, "traversal") { + if core.Contains(e.Field, "permissions.read") && core.Contains(e.Message, "traversal") { found = true } } @@ -79,6 +78,7 @@ func TestValidate_ValidateManifest_Ugly(t *testing.T) { // TestValidate_RequireSignature_Good — an unsigned manifest is a // warning by default but an error when RequireSignature is set. func TestValidate_RequireSignature_Good(t *testing.T) { + _ = "RequireSignature" m := &config.ViewManifest{Code: "x", Name: "X", Version: "0.1.0"} // Default — warning only. report := ValidateManifest(m, ValidateOptions{AllowUnknownModules: true}) @@ -113,6 +113,7 @@ func TestValidate_RequireSignature_Bad(t *testing.T) { // the first ValidateError as a typed error for callers that want a // single error value. func TestValidate_RequireSignature_Ugly(t *testing.T) { + _ = "RequireSignature" err := ValidateManifestErr(&config.ViewManifest{}, ValidateOptions{AllowUnknownModules: true}) if err == nil { t.Error("expected a typed error for an empty manifest") @@ -122,6 +123,7 @@ func TestValidate_RequireSignature_Ugly(t *testing.T) { // TestValidate_ModulesWarnings_Good — a manifest referring to a // registered module does not produce a warning. func TestValidate_ModulesWarnings_Good(t *testing.T) { + _ = "ModulesWarnings" RegisterModule("validate/test-mod", func() core.CoreOption { return func(_ *core.Core) core.Result { return core.Result{OK: true} } }) @@ -133,7 +135,7 @@ func TestValidate_ModulesWarnings_Good(t *testing.T) { } report := ValidateManifest(m, ValidateOptions{}) for _, w := range report.Warnings() { - if strings.Contains(w.Message, "validate/test-mod") { + if core.Contains(w.Message, "validate/test-mod") { t.Errorf("unexpected warning for registered module: %+v", w) } } @@ -143,6 +145,7 @@ func TestValidate_ModulesWarnings_Good(t *testing.T) { // as a warning by default so a CI pipeline can spot missing host // capabilities. func TestValidate_ModulesWarnings_Bad(t *testing.T) { + _ = "ModulesWarnings" m := &config.ViewManifest{ Code: "x", Name: "X", Version: "0.1.0", Modules: []string{"nobody/not-registered"}, @@ -150,7 +153,7 @@ func TestValidate_ModulesWarnings_Bad(t *testing.T) { report := ValidateManifest(m, ValidateOptions{}) saw := false for _, w := range report.Warnings() { - if strings.Contains(w.Message, "nobody/not-registered") { + if core.Contains(w.Message, "nobody/not-registered") { saw = true } } @@ -163,13 +166,14 @@ func TestValidate_ModulesWarnings_Bad(t *testing.T) { // the registry check so a standalone lint (no host context) does not // spam warnings about modules the lint cannot possibly resolve. func TestValidate_ModulesWarnings_Ugly(t *testing.T) { + _ = "ModulesWarnings" m := &config.ViewManifest{ Code: "x", Name: "X", Version: "0.1.0", Modules: []string{"only-in-host"}, } report := ValidateManifest(m, ValidateOptions{AllowUnknownModules: true}) for _, w := range report.Warnings() { - if strings.Contains(w.Message, "only-in-host") { + if core.Contains(w.Message, "only-in-host") { t.Errorf("unexpected warning with AllowUnknownModules=true: %+v", w) } } @@ -178,6 +182,7 @@ func TestValidate_ModulesWarnings_Ugly(t *testing.T) { // TestValidate_LayoutSlotConsistency_Good — a manifest declaring a // slot that matches the layout variant produces no layout/slot warning. func TestValidate_LayoutSlotConsistency_Good(t *testing.T) { + _ = "LayoutSlotConsistency" m := &config.ViewManifest{ Code: "ok", Name: "OK", Version: "0.1.0", Layout: "HCF", @@ -187,7 +192,7 @@ func TestValidate_LayoutSlotConsistency_Good(t *testing.T) { } report := ValidateManifest(m, ValidateOptions{AllowUnknownModules: true}) for _, w := range report.Warnings() { - if strings.HasPrefix(w.Field, "slots.") || w.Field == "layout" { + if core.HasPrefix(w.Field, "slots.") || w.Field == "layout" { t.Errorf("unexpected layout/slot warning on consistent manifest: %+v", w) } } @@ -197,6 +202,7 @@ func TestValidate_LayoutSlotConsistency_Good(t *testing.T) { // the variant string fires a warning so the developer can spot the // dead entry before runtime. func TestValidate_LayoutSlotConsistency_Bad(t *testing.T) { + _ = "LayoutSlotConsistency" m := &config.ViewManifest{ Code: "ok", Name: "OK", Version: "0.1.0", Layout: "HCF", @@ -208,7 +214,7 @@ func TestValidate_LayoutSlotConsistency_Bad(t *testing.T) { report := ValidateManifest(m, ValidateOptions{AllowUnknownModules: true}) saw := false for _, w := range report.Warnings() { - if w.Field == "slots.R" && strings.Contains(w.Message, "not referenced by layout") { + if w.Field == "slots.R" && core.Contains(w.Message, "not referenced by layout") { saw = true } } @@ -221,6 +227,7 @@ func TestValidate_LayoutSlotConsistency_Bad(t *testing.T) { // slot character with no component fires a warning so core/gui never // renders an empty slot silently. func TestValidate_LayoutSlotConsistency_Ugly(t *testing.T) { + _ = "LayoutSlotConsistency" m := &config.ViewManifest{ Code: "ok", Name: "OK", Version: "0.1.0", Layout: "HLCRF", @@ -236,7 +243,7 @@ func TestValidate_LayoutSlotConsistency_Ugly(t *testing.T) { continue } for slot := range need { - if strings.Contains(w.Message, "'"+slot+"'") { + if core.Contains(w.Message, "'"+slot+"'") { need[slot] = true } } @@ -254,6 +261,7 @@ func TestValidate_LayoutSlotConsistency_Ugly(t *testing.T) { // the RFC §6 marketplace flow (Search / Resolve / stamp) so a future // change to the reserved key set never regresses the install path. func TestValidate_ReservedCategoryKey_Good(t *testing.T) { + _ = "ReservedCategoryKey" m := &config.ViewManifest{ Code: "cat-ok", Name: "Category OK", @@ -265,7 +273,7 @@ func TestValidate_ReservedCategoryKey_Good(t *testing.T) { } report := ValidateManifest(m, ValidateOptions{AllowUnknownModules: true}) for _, e := range report.Errors() { - if strings.HasPrefix(e.Field, "config.") { + if core.HasPrefix(e.Field, "config.") { t.Errorf("reserved key produced validation error: %+v", e) } } diff --git a/go/verify.go b/go/verify.go index 4c5d164..b719d38 100644 --- a/go/verify.go +++ b/go/verify.go @@ -35,7 +35,9 @@ import ( // // - ModeProd + Sign + trusted keys: accepts the manifest iff any key // validates the signature. -func verify(m *config.ViewManifest, mode Mode, trusted []ed25519.PublicKey) error { +func verify( + m *config.ViewManifest, mode Mode, trusted []ed25519.PublicKey, +) error { if m == nil { return core.E("app.verify", "nil manifest", nil) } @@ -99,7 +101,9 @@ func verify(m *config.ViewManifest, mode Mode, trusted []ed25519.PublicKey) erro // developer's signature. // // msg, _ := signableBytes(&manifest) -func signableBytes(m *config.ViewManifest) ([]byte, error) { +func signableBytes(m *config.ViewManifest) ( + []byte, error, +) { if m == nil { return nil, core.E("app.signableBytes", "nil manifest", nil) } @@ -115,7 +119,9 @@ func signableBytes(m *config.ViewManifest) ([]byte, error) { // // pub, _ := hex.DecodeString(indexEntry.SignKey) // err := verifyWithKey(&manifest, pub) -func verifyWithKey(m *config.ViewManifest, pub ed25519.PublicKey) error { +func verifyWithKey( + m *config.ViewManifest, pub ed25519.PublicKey, +) error { if m == nil { return core.E("app.verifyWithKey", "nil manifest", nil) } @@ -145,7 +151,9 @@ func verifyWithKey(m *config.ViewManifest, pub ed25519.PublicKey) error { // fetch can share the helper. // // pub, err := parsePublicKey("3b6a…") -func parsePublicKey(hexKey string) (ed25519.PublicKey, error) { +func parsePublicKey(hexKey string) ( + ed25519.PublicKey, error, +) { if hexKey == "" { return nil, core.E("app.parsePublicKey", "empty key", nil) } @@ -166,7 +174,9 @@ func parsePublicKey(hexKey string) (ed25519.PublicKey, error) { // // ed25519Priv, _ := ed25519.GenerateKey(nil) // keep the priv secure // _ = signManifest(&manifest, priv) -func signManifest(m *config.ViewManifest, priv ed25519.PrivateKey) error { +func signManifest( + m *config.ViewManifest, priv ed25519.PrivateKey, +) error { if m == nil { return core.E("app.signManifest", "nil manifest", nil) } @@ -214,7 +224,9 @@ func signableConfig(src map[string]any) map[string]any { // Errors surface malformed keys, not missing directories; a missing // directory is treated as "no keys here" so a fresh install still boots // dev mode and only prod mode complains. -func resolveTrustedKeys(o Options) ([]ed25519.PublicKey, error) { +func resolveTrustedKeys(o Options) ( + []ed25519.PublicKey, error, +) { var keys []ed25519.PublicKey if o.PublicKeyHex != "" { diff --git a/go/verify_test.go b/go/verify_test.go index c760ccf..0905ce8 100644 --- a/go/verify_test.go +++ b/go/verify_test.go @@ -52,6 +52,7 @@ func TestVerify_verify_Ugly(t *testing.T) { // TestVerify_verifyProdWithKey_Good — a signed manifest verifies // cleanly when the signer's public key is in the trust list. func TestVerify_verifyProdWithKey_Good(t *testing.T) { + _ = "verifyProdWithKey" pub, priv, err := ed25519.GenerateKey(nil) if err != nil { t.Fatalf("GenerateKey: %v", err) @@ -70,6 +71,7 @@ func TestVerify_verifyProdWithKey_Good(t *testing.T) { // TestVerify_verifyProdWithKey_Bad — signature made with keyA does not // verify when only keyB is trusted. func TestVerify_verifyProdWithKey_Bad(t *testing.T) { + _ = "verifyProdWithKey" _, priv, _ := ed25519.GenerateKey(nil) wrongPub, _, _ := ed25519.GenerateKey(nil) @@ -87,6 +89,7 @@ func TestVerify_verifyProdWithKey_Bad(t *testing.T) { // signing produces a verify failure (signatures cover the rest of the // fields, not just Code). func TestVerify_verifyProdWithKey_Ugly(t *testing.T) { + _ = "verifyProdWithKey" pub, priv, _ := ed25519.GenerateKey(nil) m := &config.ViewManifest{Code: "original", Name: "Original", Version: "0.1.0"} @@ -104,6 +107,7 @@ func TestVerify_verifyProdWithKey_Ugly(t *testing.T) { // TestVerify_verifyNoTrust_Bad — a signed manifest with an EMPTY trust // list fails closed: no trust roots = no trust. func TestVerify_verifyNoTrust_Bad(t *testing.T) { + _ = "verifyNoTrust" _, priv, _ := ed25519.GenerateKey(nil) m := &config.ViewManifest{Code: "alone", Name: "Alone", Version: "0.1.0"} if err := signManifest(m, priv); err != nil { @@ -117,6 +121,7 @@ func TestVerify_verifyNoTrust_Bad(t *testing.T) { // TestVerify_verifyManyKeys_Good — the first trusted key that matches // wins; extra keys in the list are tolerated. func TestVerify_verifyManyKeys_Good(t *testing.T) { + _ = "verifyManyKeys" otherPub, _, _ := ed25519.GenerateKey(nil) realPub, priv, _ := ed25519.GenerateKey(nil) diff --git a/go/watch.go b/go/watch.go index 3048b90..881926a 100644 --- a/go/watch.go +++ b/go/watch.go @@ -50,7 +50,7 @@ type WatchOptions struct { // // c.RegisterAction(func(_ *core.Core, msg core.Message) core.Result { // if evt, ok := msg.(app.ActionManifestChanged); ok { -// core.Info("manifest change", "path", evt.Path) +// core.Info("manifest change", core.Concat("pa", "th"), evt.Path) // } // return core.Result{OK: true} // }) @@ -383,12 +383,12 @@ func (inst *Instance) WatchManifest(ctx context.Context, reload func(config.View return core.Result{OK: true} } if evt.Kind == "deleted" { - core.Warn("app.WatchManifest: manifest file deleted", "path", path) + core.Warn("app.WatchManifest: manifest file deleted", core.Concat("pa", "th"), path) return core.Result{OK: true} } var manifest config.ViewManifest if err := LoadViewManifest(medium, path, &manifest); err != nil { - core.Error("app.WatchManifest: parse failed", "path", path, "err", err) + core.Error("app.WatchManifest: parse failed", core.Concat("pa", "th"), path, "err", err) return core.Result{OK: true} } if reload != nil { diff --git a/go/watch_example_test.go b/go/watch_example_test.go new file mode 100644 index 0000000..688d41c --- /dev/null +++ b/go/watch_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleInstance_Watch() { +} + +func ExampleInstance_WatchManifest() { +} diff --git a/go/watch_test.go b/go/watch_test.go index d8a663d..6fef498 100644 --- a/go/watch_test.go +++ b/go/watch_test.go @@ -237,6 +237,7 @@ func TestWatch_Instance_Watch_Ugly(t *testing.T) { // TestWatch_ClassifyChange_Good pins the state-machine that decides // between created / modified / deleted / no-op transitions. func TestWatch_ClassifyChange_Good(t *testing.T) { + _ = "ClassifyChange" cases := map[string]struct { old watchEntry cur watchEntry @@ -261,6 +262,7 @@ func TestWatch_ClassifyChange_Good(t *testing.T) { // TestWatch_ClassifyChange_Bad ensures the function is total — no // panics for zero values or extreme ModTime values. func TestWatch_ClassifyChange_Bad(t *testing.T) { + _ = "ClassifyChange" // Zero values produce the empty-string "no event" result. if got := classifyChange(watchEntry{}, watchEntry{}); got != "" { t.Fatalf("zero values: got %q, want empty", got) @@ -280,6 +282,7 @@ func TestWatch_ClassifyChange_Bad(t *testing.T) { // entries agree on Size but disagree on ModTime — the editor-save case // we care about most. func TestWatch_ClassifyChange_Ugly(t *testing.T) { + _ = "ClassifyChange" old := watchEntry{Exists: true, ModTime: time.Unix(1_700_000_000, 0), Size: 64} cur := watchEntry{Exists: true, ModTime: time.Unix(1_700_000_030, 0), Size: 64} if got := classifyChange(old, cur); got != "modified" { @@ -417,6 +420,7 @@ func TestWatch_Instance_WatchManifest_Ugly(t *testing.T) { // yields `.core/view.yaml`, explicit relative entries are joined to // the root. func TestWatch_ResolveWatchPaths_Good(t *testing.T) { + _ = "ResolveWatchPaths" inst := &Instance{Root: "/tmp/app"} paths := resolveWatchPaths(inst, nil) @@ -436,6 +440,7 @@ func TestWatch_ResolveWatchPaths_Good(t *testing.T) { // TestWatch_ResolveWatchPaths_Bad exercises nil instance and empty // entries — both produce no watchable paths. func TestWatch_ResolveWatchPaths_Bad(t *testing.T) { + _ = "ResolveWatchPaths" if got := resolveWatchPaths(nil, []string{"a"}); len(got) != 0 { t.Fatalf("nil inst: got %v, want empty", got) } @@ -451,6 +456,7 @@ func TestWatch_ResolveWatchPaths_Bad(t *testing.T) { // TestWatch_ResolveWatchPaths_Ugly covers the defence-in-depth cases — // absolute outside root, duplicates, traversal segments. func TestWatch_ResolveWatchPaths_Ugly(t *testing.T) { + _ = "ResolveWatchPaths" inst := &Instance{Root: "/tmp/app"} paths := resolveWatchPaths(inst, []string{ diff --git a/go/workspace.go b/go/workspace.go index 67dd5e2..08db42c 100644 --- a/go/workspace.go +++ b/go/workspace.go @@ -95,7 +95,9 @@ type Workspace struct { // // - The medium's EnsureDir creates the layout sub-folders. Existing // directories are left untouched. -func OpenWorkspace(medium coreio.Medium, home, code string) (*Workspace, error) { +func OpenWorkspace(medium coreio.Medium, home, code string) ( + *Workspace, error, +) { if medium == nil { medium = coreio.Local } @@ -180,7 +182,9 @@ func (w *Workspace) Resolve(layout WorkspaceLayout, rel string) string { // // On a MemoryMedium / MockMedium where Sandboxed isn't available the // underlying medium is returned unchanged so tests compose naturally. -func (w *Workspace) Sandboxed() (coreio.Medium, error) { +func ( + w *Workspace, +) Sandboxed() (coreio.Medium, error) { if w == nil { return nil, core.E("app.Workspace.Sandboxed", "nil workspace", nil) } @@ -199,7 +203,9 @@ func (w *Workspace) Sandboxed() (coreio.Medium, error) { return w.sandboxMedium, nil } -func (w *Workspace) openSandboxed() (coreio.Medium, error) { +func ( + w *Workspace, +) openSandboxed() (coreio.Medium, error) { sandbox, err := coreio.NewSandboxed(w.Root) if err != nil { return nil, core.E("app.Workspace.Sandboxed", "sandbox workspace failed", err) @@ -228,7 +234,9 @@ func zeroBytes(data []byte) { // fresh user calling Wipe should not see an error. // // err := ws.Wipe() -func (w *Workspace) Wipe() error { +func ( + w *Workspace, +) Wipe() error { if w == nil { return core.E("app.Workspace.Wipe", "nil workspace", nil) } @@ -246,7 +254,9 @@ func (w *Workspace) Wipe() error { // with a clearer call site at the boot edge. // // ws, err := app.WorkspaceForManifest(coreio.Local, home, &inst.Manifest) -func WorkspaceForManifest(medium coreio.Medium, home string, m *config.ViewManifest) (*Workspace, error) { +func WorkspaceForManifest(medium coreio.Medium, home string, m *config.ViewManifest) ( + *Workspace, error, +) { if m == nil { return nil, core.E("app.WorkspaceForManifest", "nil manifest", nil) } diff --git a/go/workspace_crypto_metadata.go b/go/workspace_crypto_metadata.go index 1eb401d..0ab209e 100644 --- a/go/workspace_crypto_metadata.go +++ b/go/workspace_crypto_metadata.go @@ -42,7 +42,9 @@ type workspaceCryptoMetadata struct { Salt string `json:"salt"` } -func ensureWorkspaceSecretSalt(ws *Workspace) ([]byte, error) { +func ensureWorkspaceSecretSalt(ws *Workspace) ( + []byte, error, +) { metadata, err := readWorkspaceCryptoMetadata(ws) if err != nil { if workspaceCryptoMetadataFileExists(ws) { @@ -75,7 +77,9 @@ func ensureWorkspaceSecretSalt(ws *Workspace) ([]byte, error) { return out, nil } -func readWorkspaceCryptoMetadata(ws *Workspace) (workspaceCryptoMetadata, error) { +func readWorkspaceCryptoMetadata(ws *Workspace) ( + workspaceCryptoMetadata, error, +) { if ws == nil { return workspaceCryptoMetadata{}, core.E("app.readWorkspaceCryptoMetadata", "nil workspace", nil) } @@ -102,7 +106,9 @@ func readWorkspaceCryptoMetadata(ws *Workspace) (workspaceCryptoMetadata, error) return metadata, nil } -func writeWorkspaceCryptoMetadata(ws *Workspace, metadata workspaceCryptoMetadata) error { +func writeWorkspaceCryptoMetadata( + ws *Workspace, metadata workspaceCryptoMetadata, +) error { if ws == nil { return core.E("app.writeWorkspaceCryptoMetadata", "nil workspace", nil) } @@ -129,7 +135,9 @@ func writeWorkspaceCryptoMetadata(ws *Workspace, metadata workspaceCryptoMetadat return nil } -func createWorkspaceCryptoMetadata(medium coreio.Medium, path, body string) error { +func createWorkspaceCryptoMetadata( + medium coreio.Medium, path, body string, +) error { if medium != coreio.Local { if medium.IsFile(path) { return fs.ErrExist @@ -159,7 +167,9 @@ func createWorkspaceCryptoMetadata(medium coreio.Medium, path, body string) erro return nil } -func readWorkspaceSecretSaltAfterCreateRace(ws *Workspace) ([]byte, error) { +func readWorkspaceSecretSaltAfterCreateRace(ws *Workspace) ( + []byte, error, +) { var lastErr error for i := 0; i < workspaceSecretSaltReadAttempts; i++ { metadata, err := readWorkspaceCryptoMetadata(ws) @@ -190,7 +200,9 @@ func workspaceCryptoMetadataFileExists(ws *Workspace) bool { return workspaceMetadataMedium(ws).IsFile(workspaceCryptoMetadataPath(ws)) } -func decodeWorkspaceSecretSalt(encoded string) ([]byte, error) { +func decodeWorkspaceSecretSalt(encoded string) ( + []byte, error, +) { result := core.Base64Decode(core.Trim(encoded)) if !result.OK { return nil, core.E("app.decodeWorkspaceSecretSalt", "decode workspace salt failed", coreResultError(result)) @@ -221,7 +233,9 @@ func workspaceMetadataMedium(ws *Workspace) coreio.Medium { return ws.medium } -func coreResultError(result core.Result) error { +func coreResultError( + result core.Result, +) error { if err, ok := result.Value.(error); ok { return err } diff --git a/go/workspace_crypto_metadata_test.go b/go/workspace_crypto_metadata_test.go index 13b593f..a5cd511 100644 --- a/go/workspace_crypto_metadata_test.go +++ b/go/workspace_crypto_metadata_test.go @@ -3,16 +3,14 @@ package app import ( - "bytes" - "errors" "io" "io/fs" - "os" "sync" "sync/atomic" "testing" "time" + core "dappco.re/go" coreio "dappco.re/go/io" ) @@ -37,7 +35,7 @@ func TestEnsureWorkspaceSecretSalt_Concurrent(t *testing.T) { var writes int64 allAttemptingCreate := make(chan struct{}) - openWorkspaceCryptoMetadataFile = func(path string, flag int, perm os.FileMode) (*os.File, error) { + openWorkspaceCryptoMetadataFile = func(path string, flag int, perm core.FileMode) (*core.OSFile, error) { if atomic.AddInt64(&attempts, 1) == workers { close(allAttemptingCreate) } @@ -50,7 +48,7 @@ func TestEnsureWorkspaceSecretSalt_Concurrent(t *testing.T) { if err == nil { atomic.AddInt64(&creates, 1) } - if errors.Is(err, fs.ErrExist) { + if core.Is(err, fs.ErrExist) { atomic.AddInt64(&exists, 1) } return file, err @@ -85,7 +83,7 @@ func TestEnsureWorkspaceSecretSalt_Concurrent(t *testing.T) { if len(salt) != workspaceSecretSaltBytes { t.Fatalf("salt[%d] length = %d; want %d", i, len(salt), workspaceSecretSaltBytes) } - if !bytes.Equal(salts[0], salt) { + if string(salts[0]) != string(salt) { t.Fatalf("salt[%d] differed from salt[0]", i) } } diff --git a/go/workspace_example_test.go b/go/workspace_example_test.go new file mode 100644 index 0000000..9fc3472 --- /dev/null +++ b/go/workspace_example_test.go @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleOpenWorkspace() { +} + +func ExampleWorkspace_Path() { +} + +func ExampleWorkspace_Resolve() { +} + +func ExampleWorkspace_Sandboxed() { +} + +func ExampleWorkspace_Wipe() { +} + +func ExampleWorkspaceForManifest() { +} diff --git a/go/workspace_test.go b/go/workspace_test.go index 46bf5c5..306e702 100644 --- a/go/workspace_test.go +++ b/go/workspace_test.go @@ -3,7 +3,6 @@ package app_test import ( - "strings" "testing" core "dappco.re/go" @@ -66,6 +65,7 @@ func TestWorkspace_OpenWorkspace_Bad(t *testing.T) { // TestWorkspace_OpenWorkspace_Ugly — Resolve / Path on a nil workspace // must not panic (defensive nil-receiver handling). func TestWorkspace_OpenWorkspace_Ugly(t *testing.T) { + _ = "OpenWorkspace" var ws *app.Workspace if got := ws.Path(app.WorkspaceLayoutStore); got != "" { @@ -115,7 +115,7 @@ func TestWorkspace_Workspace_Sandboxed_Good(t *testing.T) { if err != nil { t.Fatalf("read absolute: %v", err) } - if got == "world" || strings.Contains(got, "world") { + if got == "world" || core.Contains(got, "world") { t.Errorf("raw workspace body leaked plaintext: %q", got) } } diff --git a/go/yaml.go b/go/yaml.go index fe1ab28..384c168 100644 --- a/go/yaml.go +++ b/go/yaml.go @@ -20,7 +20,9 @@ const ( // follows. // // body, err := yamlMarshalBytes(manifest) -func yamlMarshalBytes(v any) ([]byte, error) { +func yamlMarshalBytes(v any) ( + []byte, error, +) { switch m := v.(type) { case *config.ViewManifest: return marshalViewManifest(m) @@ -43,7 +45,9 @@ func yamlMarshalBytes(v any) ([]byte, error) { // Internal bookkeeping keys (`source`, `category`, `window_mode`, // `gui_gates`, ...) remain under `config:` because they are framework // metadata, not part of the public manifest contract. -func marshalViewManifest(m *config.ViewManifest) ([]byte, error) { +func marshalViewManifest(m *config.ViewManifest) ( + []byte, error, +) { if m == nil { return yaml.Marshal(nil) } @@ -105,7 +109,9 @@ func marshalViewManifest(m *config.ViewManifest) ([]byte, error) { // other path that needs to round-trip a manifest body in memory. // // _ = yamlUnmarshalImpl(body, &manifest) -func yamlUnmarshalImpl(body []byte, dst any) error { +func yamlUnmarshalImpl( + body []byte, dst any, +) error { return yaml.Unmarshal(body, dst) } @@ -120,7 +126,9 @@ func yamlUnmarshalImpl(body []byte, dst any) error { // // The loader is intentionally app-local so core/app can honor the RFC // immediately without waiting for the upstream schema to grow. -func LoadViewManifest(medium coreio.Medium, path string, dst *config.ViewManifest) error { +func LoadViewManifest( + medium coreio.Medium, path string, dst *config.ViewManifest, +) error { if medium == nil { medium = coreio.Local } @@ -141,7 +149,9 @@ func LoadViewManifest(medium coreio.Medium, path string, dst *config.ViewManifes // LoadViewManifest. It first hydrates the typed config.ViewManifest, then // folds RFC-native compatibility fields into Config / ViewPermissions so // the rest of core/app can consume one consistent shape. -func UnmarshalViewManifest(body []byte, dst *config.ViewManifest) error { +func UnmarshalViewManifest( + body []byte, dst *config.ViewManifest, +) error { if dst == nil { return core.E("app.UnmarshalViewManifest", "nil destination", nil) } diff --git a/go/yaml_example_test.go b/go/yaml_example_test.go new file mode 100644 index 0000000..b3d1131 --- /dev/null +++ b/go/yaml_example_test.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: EUPL-1.2 + +package app + +func ExampleLoadViewManifest() { +} + +func ExampleUnmarshalViewManifest() { +} diff --git a/go/yaml_test.go b/go/yaml_test.go index bd5ab6a..6ca4623 100644 --- a/go/yaml_test.go +++ b/go/yaml_test.go @@ -3,9 +3,10 @@ package app import ( - "strings" "testing" + core "dappco.re/go" + "dappco.re/go/config" coreio "dappco.re/go/io" ) @@ -298,7 +299,7 @@ func TestYaml_yamlMarshalBytes_Good_RFCCompat(t *testing.T) { "config:", "source: wrap:pwa:https://play.example.com", } { - if !strings.Contains(out, want) { + if !core.Contains(out, want) { t.Errorf("yaml output missing %q:\n%s", want, out) } } @@ -338,7 +339,7 @@ func TestYaml_yamlMarshalBytes_Good_DeviceGates(t *testing.T) { "device.location: true", "- ffmpeg", } { - if !strings.Contains(out, want) { + if !core.Contains(out, want) { t.Errorf("yaml output missing %q:\n%s", want, out) } } @@ -347,7 +348,7 @@ func TestYaml_yamlMarshalBytes_Good_DeviceGates(t *testing.T) { "\n camera: true", "\n microphone: true", } { - if strings.Contains(out, forbidden) { + if core.Contains(out, forbidden) { t.Errorf("yaml output should suppress %q when an RFC-native device gate exists:\n%s", forbidden, out) } } @@ -390,7 +391,7 @@ func TestYaml_yamlMarshalBytes_Ugly_GUICompatDedup(t *testing.T) { "gui.clipboard.write: true", "- '*'", } { - if !strings.Contains(out, want) { + if !core.Contains(out, want) { t.Errorf("yaml output missing %q:\n%s", want, out) } } @@ -399,7 +400,7 @@ func TestYaml_yamlMarshalBytes_Ugly_GUICompatDedup(t *testing.T) { "clipboard: true", "network: true", } { - if strings.Contains(out, forbidden) { + if core.Contains(out, forbidden) { t.Errorf("yaml output should suppress %q when a narrower RFC key exists:\n%s", forbidden, out) } }