goscript 0.0.84 → 0.1.1

package/cmd/goscript/cmd-test.go

@@ -0,0 +1,193 @@
+package main
+
+import (
+	"context"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/aperturerobotics/cli"
+	"github.com/aperturerobotics/goscript/compiler/gotest"
+	"github.com/pkg/errors"
+)
+
+func testCommands() []*cli.Command {
+	return []*cli.Command{newTestCommand()}
+}
+
+func newTestCommand() *cli.Command {
+	var tags cli.StringSlice
+	var run string
+	var count int
+	var short bool
+	var timeout time.Duration
+	var verbose bool
+	var outputRoot string
+	var workDir string
+	var dir string
+
+	return &cli.Command{
+		Name:     "test",
+		Category: "test",
+		Usage:    "compile and run Go package tests through GoScript",
+		Action: func(c *cli.Context) error {
+			req := &gotest.Request{
+				Dir:        dir,
+				Patterns:   c.Args().Slice(),
+				BuildTags:  tags.Value(),
+				Run:        run,
+				Count:      count,
+				Short:      short,
+				Timeout:    timeout,
+				Verbose:    verbose,
+				WorkDir:    workDir,
+				OutputRoot: outputRoot,
+			}
+			result, err := gotest.NewRunner().Run(c.Context, req)
+			if err != nil {
+				return err
+			}
+			if err := printTestResult(c.Context, c.App.Writer, result); err != nil {
+				return err
+			}
+			if !result.Passed() {
+				return errors.New("goscript test failed")
+			}
+			return nil
+		},
+		Flags: []cli.Flag{
+			&cli.StringSliceFlag{
+				Name:        "tags",
+				Usage:       "comma-separated Go build tags",
+				Destination: &tags,
+			},
+			&cli.StringFlag{
+				Name:        "run",
+				Usage:       "run only tests matching the regexp",
+				Destination: &run,
+			},
+			&cli.IntFlag{
+				Name:        "count",
+				Usage:       "run each selected test this many times",
+				Destination: &count,
+				Value:       1,
+			},
+			&cli.BoolFlag{
+				Name:        "short",
+				Usage:       "report true from testing.Short",
+				Destination: &short,
+			},
+			&cli.DurationFlag{
+				Name:        "timeout",
+				Usage:       "maximum time for the package-test run",
+				Destination: &timeout,
+				Value:       30 * time.Second,
+			},
+			&cli.BoolFlag{
+				Name:        "v",
+				Aliases:     []string{"verbose"},
+				Usage:       "emit verbose test output",
+				Destination: &verbose,
+			},
+			&cli.StringFlag{
+				Name:        "output",
+				Usage:       "generated TypeScript output root",
+				Destination: &outputRoot,
+			},
+			&cli.StringFlag{
+				Name:        "workdir",
+				Usage:       "generated test workspace directory",
+				Destination: &workDir,
+			},
+			&cli.StringFlag{
+				Name:        "dir",
+				Usage:       "Go module working directory",
+				Destination: &dir,
+			},
+		},
+	}
+}
+
+func printTestResult(ctx context.Context, w io.Writer, result *gotest.Result) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if result == nil {
+		return errors.New("goscript test result is nil")
+	}
+	for _, pkg := range result.Packages {
+		if strings.TrimSpace(pkg.Output) != "" {
+			if _, err := io.WriteString(w, strings.TrimSpace(pkg.Output)+"\n"); err != nil {
+				return err
+			}
+		}
+		switch pkg.Action {
+		case gotest.ActionPass:
+			if _, err := io.WriteString(w, "ok  \t"+pkg.PackagePath+"\t"+formatElapsed(pkg.Elapsed)+"\n"); err != nil {
+				return err
+			}
+		case gotest.ActionSkip:
+			if _, err := io.WriteString(w, "?   \t"+pkg.PackagePath+"\t[no test files]\n"); err != nil {
+				return err
+			}
+		case gotest.ActionFail:
+			line := "FAIL\t" + pkg.PackagePath
+			if pkg.Owner != "" {
+				line += "\towner=" + string(pkg.Owner)
+			}
+			if phase := failedPhase(pkg.Phases); phase != "" {
+				line += "\tphase=" + phase
+			}
+			if _, err := io.WriteString(w, line+"\n"); err != nil {
+				return err
+			}
+			if strings.TrimSpace(pkg.Error) != "" {
+				if _, err := io.WriteString(w, strings.TrimSpace(pkg.Error)+"\n"); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	if result.WorkDir != "" {
+		if _, err := io.WriteString(w, "goscript test workdir: "+result.WorkDir+"\n"); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func failedPhase(phases gotest.PackagePhases) string {
+	switch {
+	case phases.Workspace == gotest.PhaseStatusFail:
+		return "workspace"
+	case phases.Compile == gotest.PhaseStatusFail:
+		return "compile"
+	case phases.Emit == gotest.PhaseStatusFail:
+		return "emit"
+	case phases.TypeCheck == gotest.PhaseStatusFail:
+		return "typecheck"
+	case phases.Runtime == gotest.PhaseStatusFail:
+		return "runtime"
+	default:
+		return ""
+	}
+}
+
+func formatElapsed(elapsed time.Duration) string {
+	if elapsed <= 0 {
+		return "0.000s"
+	}
+	millis := elapsed.Milliseconds()
+	seconds := millis / 1000
+	remainder := millis % 1000
+	return strconv.FormatInt(seconds, 10) + "." + leftPadMillis(remainder) + "s"
+}
+
+func leftPadMillis(value int64) string {
+	raw := strconv.FormatInt(value, 10)
+	for len(raw) < 3 {
+		raw = "0" + raw
+	}
+	return raw
+}

package/cmd/goscript/cmd-test_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"bytes"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestTestCommandHelp(t *testing.T) {
+	var out bytes.Buffer
+	app := newApp()
+	app.Writer = &out
+
+	err := app.Run([]string{"goscript", "test", "--help"})
+	if err != nil {
+		t.Fatalf("test help failed: %v", err)
+	}
+	help := out.String()
+	for _, expected := range []string{"compile and run Go package tests through GoScript", "--tags", "--run", "--count", "--short", "--timeout"} {
+		if !strings.Contains(help, expected) {
+			t.Fatalf("help output missing %q:\n%s", expected, help)
+		}
+	}
+}
+
+func TestTestCommandRunsPackageTest(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cmdtest\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "value.go"), strings.Join([]string{
+		"package cmdtest",
+		"func Value() int { return 7 }",
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "value_test.go"), strings.Join([]string{
+		"package cmdtest",
+		"import \"testing\"",
+		"func TestValue(t *testing.T) {",
+		"\tif Value() != 7 {",
+		"\t\tt.Fatal(\"bad value\")",
+		"\t}",
+		"}",
+		"",
+	}, "\n"))
+
+	var out bytes.Buffer
+	app := newApp()
+	app.Writer = &out
+	err := app.Run([]string{
+		"goscript",
+		"test",
+		"--dir",
+		dir,
+		"--workdir",
+		filepath.Join(dir, ".tmp", "cmd-test"),
+		"-v",
+		".",
+	})
+	if err != nil {
+		t.Fatalf("test command failed: %v\n%s", err, out.String())
+	}
+	if !strings.Contains(out.String(), "ok  \texample.test/cmdtest") {
+		t.Fatalf("expected ok package output, got:\n%s", out.String())
+	}
+}
+
+func TestTestCommandRejectsUnsupportedFlags(t *testing.T) {
+	app := newApp()
+	err := app.Run([]string{"goscript", "test", "--cover", "."})
+	if err == nil {
+		t.Fatalf("expected unsupported flag to fail")
+	}
+	if !strings.Contains(err.Error(), "flag provided but not defined") {
+		t.Fatalf("unexpected unsupported flag error: %v", err)
+	}
+}

package/cmd/goscript/cmd_compile.go

@@ -10,83 +10,84 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-var (
-	cliCompiler           *compiler.Compiler
-	cliCompilerConfig     compiler.Config
-	cliCompilerPkg        cli.StringSlice
-	cliCompilerBuildFlags cli.StringSlice
-)
+func compileCommands() []*cli.Command {
+	return []*cli.Command{newCompileCommand()}
+}
 
-// CompileCommands are commands related to compiling code.
-var CompileCommands = []*cli.Command{{
-	Name:     "compile",
-	Category: "compile",
-	Usage:    "compile a Go package to TypeScript",
-	Action:   compilePackage,
-	Before: func(c *cli.Context) (err error) {
-		logger := logrus.New()
-		logger.SetLevel(logrus.DebugLevel)
-		le := logrus.NewEntry(logger)
-		cliCompiler, err = compiler.NewCompiler(&cliCompilerConfig, le, nil)
-		return
-	},
-	Flags: []cli.Flag{
-		&cli.StringSliceFlag{
-			Name:        "package",
-			Usage:       "the package(s) to compile",
-			Aliases:     []string{"p", "packages"},
-			EnvVars:     []string{"GOSCRIPT_PACKAGES"},
-			Destination: &cliCompilerPkg,
-		},
-		&cli.StringFlag{
-			Name:        "output",
-			Usage:       "the output typescript path to use",
-			Destination: &cliCompilerConfig.OutputPath,
-			Value:       "./output",
-			EnvVars:     []string{"GOSCRIPT_OUTPUT"},
-		},
-		&cli.StringFlag{
-			Name:        "dir",
-			Usage:       "the working directory to use for the compiler (default: current directory)",
-			Destination: &cliCompilerConfig.Dir,
-			Value:       "",
-			EnvVars:     []string{"GOSCRIPT_DIR"},
-		},
-		&cli.StringSliceFlag{
-			Name:        "build-flags",
-			Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
-			Usage:       "Go build flags (tags) to use during analysis",
-			Destination: &cliCompilerBuildFlags,
-			EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
-		},
-		&cli.BoolFlag{
-			Name:        "disable-emit-builtin",
-			Usage:       "disable emitting built-in packages that have handwritten equivalents",
-			Destination: &cliCompilerConfig.DisableEmitBuiltin,
-			Value:       false,
-			EnvVars:     []string{"GOSCRIPT_DISABLE_EMIT_BUILTIN"},
+func newCompileCommand() *cli.Command {
+	var config compiler.Config
+	var packages cli.StringSlice
+	var buildFlags cli.StringSlice
+
+	return &cli.Command{
+		Name:     "compile",
+		Category: "compile",
+		Usage:    "compile a Go package to TypeScript",
+		Action: func(c *cli.Context) error {
+			config.BuildFlags = slices.Clone(buildFlags.Value())
+			return compilePackage(c.Context, &config, packages.Value())
 		},
-		&cli.BoolFlag{
-			Name:        "all-dependencies",
-			Usage:       "compile all dependencies of the requested packages",
-			Aliases:     []string{"all-deps", "deps"},
-			Destination: &cliCompilerConfig.AllDependencies,
-			Value:       false,
-			EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
+		Flags: []cli.Flag{
+			&cli.StringSliceFlag{
+				Name:        "package",
+				Usage:       "the package(s) to compile",
+				Aliases:     []string{"p", "packages"},
+				EnvVars:     []string{"GOSCRIPT_PACKAGES"},
+				Destination: &packages,
+			},
+			&cli.StringFlag{
+				Name:        "output",
+				Usage:       "the output typescript path to use",
+				Destination: &config.OutputPath,
+				Value:       "./output",
+				EnvVars:     []string{"GOSCRIPT_OUTPUT"},
+			},
+			&cli.StringFlag{
+				Name:        "dir",
+				Usage:       "the working directory to use for the compiler (default: current directory)",
+				Destination: &config.Dir,
+				Value:       "",
+				EnvVars:     []string{"GOSCRIPT_DIR"},
+			},
+			&cli.StringSliceFlag{
+				Name:        "build-flags",
+				Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
+				Usage:       "Go build flags (tags) to use during analysis",
+				Destination: &buildFlags,
+				EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
+			},
+			&cli.BoolFlag{
+				Name:        "disable-emit-builtin",
+				Usage:       "disable emitting built-in packages that have handwritten equivalents",
+				Destination: &config.DisableEmitBuiltin,
+				Value:       false,
+				EnvVars:     []string{"GOSCRIPT_DISABLE_EMIT_BUILTIN"},
+			},
+			&cli.BoolFlag{
+				Name:        "all-dependencies",
+				Usage:       "compile all dependencies of the requested packages",
+				Aliases:     []string{"all-deps", "deps"},
+				Destination: &config.AllDependencies,
+				Value:       false,
+				EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
+			},
 		},
-	},
-}}
+	}
+}
 
 // compilePackage tries to compile the package.
-func compilePackage(c *cli.Context) error {
-	pkgs := cliCompilerPkg.Value()
+func compilePackage(ctx context.Context, config *compiler.Config, pkgs []string) error {
 	if len(pkgs) == 0 {
 		return errors.New("package(s) must be specified")
 	}
 
-	// build flags
-	cliCompilerConfig.BuildFlags = slices.Clone(cliCompilerBuildFlags.Value())
-
-	_, err := cliCompiler.CompilePackages(context.Background(), pkgs...)
+	logger := logrus.New()
+	logger.SetLevel(logrus.DebugLevel)
+	le := logrus.NewEntry(logger)
+	comp, err := compiler.NewCompiler(config, le, nil)
+	if err != nil {
+		return err
+	}
+	_, err = comp.CompilePackages(ctx, pkgs...)
 	return err
 }

package/cmd/goscript/cmd_compile_test.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCompileCommandForwardsBuildFlags(t *testing.T) {
+	dir := t.TempDir()
+	outputDir := filepath.Join(dir, "output")
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cli\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "default.go"), strings.Join([]string{
+		"//go:build !customtag",
+		"",
+		"package main",
+		`const selected = "default"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "tagged.go"), strings.Join([]string{
+		"//go:build customtag",
+		"",
+		"package main",
+		`const selected = "custom"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "main.go"), strings.Join([]string{
+		"package main",
+		"func main() {",
+		"  println(selected)",
+		"}",
+		"",
+	}, "\n"))
+
+	app := newApp()
+	err := app.Run([]string{
+		"goscript",
+		"compile",
+		"--package",
+		".",
+		"--output",
+		outputDir,
+		"--dir",
+		dir,
+		"--build-flags",
+		"-tags=customtag",
+	})
+	if err != nil {
+		t.Fatalf("compile command failed: %v", err)
+	}
+
+	generatedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "main.gs.ts")
+	generated, err := os.ReadFile(generatedPath)
+	if err != nil {
+		t.Fatalf("read generated file: %v", err)
+	}
+	if !strings.Contains(string(generated), `./tagged.gs.ts`) {
+		t.Fatalf("expected main output to import tagged source, got:\n%s", generated)
+	}
+	taggedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "tagged.gs.ts")
+	tagged, err := os.ReadFile(taggedPath)
+	if err != nil {
+		t.Fatalf("read tagged generated file: %v", err)
+	}
+	if !strings.Contains(string(tagged), `"custom"`) {
+		t.Fatalf("expected tagged generated file to use tagged source, got:\n%s", tagged)
+	}
+	if strings.Contains(string(tagged), `"default"`) {
+		t.Fatalf("tagged generated file used source excluded by build tag:\n%s", tagged)
+	}
+}
+
+func writeFile(t *testing.T, path string, content string) {
+	t.Helper()
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatalf("write %s: %v", path, err)
+	}
+}

package/cmd/goscript/main.go

@@ -10,6 +10,14 @@ import (
 var version = "dev"
 
 func main() {
+	app := newApp()
+	if err := app.Run(os.Args); err != nil {
+		_, _ = os.Stderr.WriteString(err.Error() + "\n")
+		os.Exit(1)
+	}
+}
+
+func newApp() *cli.App {
 	app := cli.NewApp()
 	app.Version = version
 
@@ -18,10 +26,8 @@ func main() {
 	}
 
 	app.Usage = "GoScript compiles Go to Typescript."
-	app.Commands = append(app.Commands, CompileCommands...)
+	app.Commands = append(app.Commands, compileCommands()...)
+	app.Commands = append(app.Commands, testCommands()...)
 
-	if err := app.Run(os.Args); err != nil {
-		_, _ = os.Stderr.WriteString(err.Error() + "\n")
-		os.Exit(1)
-	}
+	return app
 }

package/compiler/build-flags.go

@@ -0,0 +1,38 @@
+package compiler
+
+import "slices"
+
+import "strings"
+
+const goScriptBuildTag = "goscript"
+
+func goScriptBuildFlags(flags []string) []string {
+	normalized := append([]string(nil), flags...)
+	for i, flag := range normalized {
+		switch {
+		case flag == "-tags" && i+1 < len(normalized):
+			normalized[i+1] = appendBuildTag(normalized[i+1], goScriptBuildTag)
+			return normalized
+		case strings.HasPrefix(flag, "-tags="):
+			normalized[i] = "-tags=" + appendBuildTag(strings.TrimPrefix(flag, "-tags="), goScriptBuildTag)
+			return normalized
+		}
+	}
+	return append(normalized, "-tags="+goScriptBuildTag)
+}
+
+func appendBuildTag(value string, tag string) string {
+	tags := strings.FieldsFunc(value, func(r rune) bool {
+		return r == ',' || r == ' ' || r == '\t' || r == '\n'
+	})
+	if slices.Contains(tags, tag) {
+		return value
+	}
+	if strings.TrimSpace(value) == "" {
+		return tag
+	}
+	if strings.ContainsAny(value, " \t\n") {
+		return value + " " + tag
+	}
+	return value + "," + tag
+}