fix: cmd structure (#14)

* feat: change cmd structure

* fix: upgrade deps

* fix: upgrade deps

Author: matthewgetz

bowtie/doc.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
 
 	"github.com/go-rotini/jsonschema"
 )
@@ -37,7 +36,7 @@ var supportedDialects = []string{
 }
 
 // errStop is the sentinel returned by the dispatch loop when the harness
-// sends a "stop" command. main treats it as a graceful exit.
+// sends a "stop" command. runBowtie treats it as a graceful exit.
 var errStop = errors.New("bowtie: stop")
 
 // errEmptyCaseSchema is returned by compileCaseSchema when the case
@@ -146,22 +145,42 @@ type state struct {
 	dialect jsonschema.Draft
 }
 
-func main() {
-	os.Exit(run(os.Stdin, os.Stdout, os.Stderr))
-}
-
-// run is the testable core of main: it drives the dispatch loop against
-// the supplied I/O streams and returns the exit code main should pass to
-// os.Exit. Splitting the os.Exit call out keeps main itself a thin
-// shell while letting the package's tests cover the I/O wiring path.
-func run(in io.Reader, out, errOut io.Writer) int {
-	if err := dispatch(in, out); err != nil && !errors.Is(err, errStop) {
-		fmt.Fprintln(errOut, "bowtie:", err)
+// runBowtie is the "bowtie" subcommand: the stdin/stdout adapter that exposes
+// go-rotini/jsonschema to the Bowtie cross-implementation conformance harness
+// (https://bowtie.report). It takes no flags; the harness drives it over a
+// single-line-JSON request/response protocol on stdin/stdout. Recognized
+// commands are "start" (handshake → implementation descriptor), "dialect" (pin
+// a meta-schema URI), "run" (one case: compile + per-test results), and "stop"
+// (exit 0). The dispatch loop is factored out as dispatch(in, out) so tests can
+// drive it over bytes.Buffer pipes.
+func runBowtie(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+	// bowtie takes no flags, so any argument is either a help request or a
+	// mistake — reject it rather than silently blocking on stdin.
+	if len(args) > 0 {
+		switch args[0] {
+		case "-h", "--help", "help":
+			bowtieUsage(stdout)
+			return 0
+		default:
+			fmt.Fprintf(stderr, "bowtie: unexpected argument %q\n", args[0])
+			bowtieUsage(stderr)
+			return 2
+		}
+	}
+	if err := dispatch(stdin, stdout); err != nil && !errors.Is(err, errStop) {
+		fmt.Fprintln(stderr, "bowtie:", err)
 		return 1
 	}
 	return 0
 }
 
+// bowtieUsage writes the bowtie subcommand summary.
+func bowtieUsage(w io.Writer) {
+	fmt.Fprintln(w, "usage: jsonschema bowtie")
+	fmt.Fprintln(w, "Bowtie conformance-harness connector. Takes no flags; the harness drives")
+	fmt.Fprintln(w, "it over a single-line-JSON request/response protocol on stdin/stdout.")
+}
+
 // dispatch is the read-eval-print loop; tests drive it over bytes.Buffer
 // pipes instead of invoking the binary.
 func dispatch(in io.Reader, out io.Writer) error {
@@ -176,9 +195,6 @@ func dispatch(in io.Reader, out io.Writer) error {
 			continue
 		}
 		if err := handleLine(line, st, enc); err != nil {
-			if errors.Is(err, errStop) {
-				return err
-			}
 			return err
 		}
 	}

bowtie/main.go cmd/jsonschema/bowtie.gobowtie/main.go renamed to cmd/jsonschema/bowtie.go

@@ -358,33 +358,6 @@ func TestRunEmptySchema(t *testing.T) {
 	}
 }
 
-// TestRunRegistryAddResourceFailure covers the registry-add failure branch
-// of newCaseCompiler indirectly: with the registry pre-populated with
-// invalid JSON bytes, the failure surfaces as an errored response from
-// handleRun.
-func TestRunRegistryAddResourceFailure(t *testing.T) {
-	// Build the case envelope by hand so we can stuff bare text into the
-	// registry value (json.RawMessage decodes the value as opaque bytes).
-	// The trick: use a JSON string whose content is non-JSON text — that
-	// then gets passed verbatim to AddResource, which fails to decode it.
-	caseRaw := `{` +
-		`"description":"registry fail",` +
-		`"schema":{"type":"string"},` +
-		`"registry":{"https://example.com/x":"not a JSON object"},` +
-		`"tests":[{"description":"x","instance":"y"}]` +
-		`}`
-	var in bytes.Buffer
-	in.WriteString(`{"cmd":"start","version":1}` + "\n")
-	in.WriteString(`{"cmd":"run","seq":1,"case":` + caseRaw + `}` + "\n")
-	in.WriteString(`{"cmd":"stop"}` + "\n")
-	var out bytes.Buffer
-	_ = dispatch(&in, &out)
-	// The actual bytes passed to AddResource for "not a JSON object" are
-	// `"not a JSON object"` — a valid JSON string. AddResource accepts JSON
-	// strings as boolean schemas? Check the response: it should not panic.
-	// Even if the registry add succeeds, the test still exercises the path.
-}
-
 // TestEvaluateOneInstanceDecodeFailure covers the decode-error branch of
 // evaluateOne by calling it directly with a malformed raw message.
 func TestEvaluateOneInstanceDecodeFailure(t *testing.T) {
@@ -477,13 +450,10 @@ func TestDialectStateRecorded(t *testing.T) {
 	}
 }
 
-// TestEvaluateOnePanicRecovery synthesizes a panic mid-validation by passing
-// instance bytes that decode fine but a schema whose evaluator panics. There
-// is no public path that panics on validation; instead we exercise the
-// recover() defense by calling evaluateOne directly with a nil schema.
-func TestEvaluateOnePanicRecovery(t *testing.T) {
-	// Calling ValidateValue on a nil schema returns an error, not a panic;
-	// instead the test confirms the err-return branch within evaluateOne.
+// TestEvaluateOneValidateError covers evaluateOne's ValidateValue-error
+// branch: a nil schema makes ValidateValue return an error (not a panic),
+// which evaluateOne reports as an errored result.
+func TestEvaluateOneValidateError(t *testing.T) {
 	res := evaluateOne(nil, json.RawMessage(`"x"`))
 	if !res.Errored {
 		t.Errorf("expected errored=true, got %+v", res)
@@ -592,74 +562,51 @@ func TestDispatchSkipsBlankLines(t *testing.T) {
 	}
 }
 
-// TestRunHelperHappyPath covers the run() helper's success path.
+// TestRunHelperHappyPath covers the runBowtie helper's success path.
 func TestRunHelperHappyPath(t *testing.T) {
 	in := bytes.NewBufferString(`{"cmd":"stop"}` + "\n")
 	var out, errOut bytes.Buffer
-	if code := run(in, &out, &errOut); code != 0 {
+	if code := runBowtie(nil, in, &out, &errOut); code != 0 {
 		t.Errorf("run = %d, want 0; err=%q", code, errOut.String())
 	}
 }
 
-// TestRunHelperErrorPath covers the run() helper's non-stop-error path.
+// TestRunHelperErrorPath covers the runBowtie helper's non-stop-error path.
 func TestRunHelperErrorPath(t *testing.T) {
 	in := bytes.NewBufferString("not json\n")
 	var out, errOut bytes.Buffer
-	if code := run(in, &out, &errOut); code != 1 {
+	if code := runBowtie(nil, in, &out, &errOut); code != 1 {
 		t.Errorf("run = %d, want 1", code)
 	}
 	if !strings.Contains(errOut.String(), "bowtie:") {
 		t.Errorf("expected 'bowtie:' prefix in errOut: %q", errOut.String())
 	}
 }
 
-// TestHandleRunNewCaseCompilerError covers the newCaseCompiler-failure
-// branch of handleRun by directly invoking it with a case envelope whose
-// registry contains malformed JSON.
-func TestHandleRunNewCaseCompilerError(t *testing.T) {
-	// Construct a case envelope with a registry value that's a JSON string
-	// (valid in outer parse) — but stored in the case's Registry field as
-	// a json.RawMessage holding bare-text bytes the schema decoder can
-	// reject.
-	tc := testCase{
-		Description: "x",
-		Schema:      json.RawMessage(`{"type":"string"}`),
-		Registry: map[string]json.RawMessage{
-			"https://example.com/x": json.RawMessage(`not json`),
-		},
-		Tests: []testInstance{{Description: "x", Instance: json.RawMessage(`"y"`)}},
+// TestRunBowtie_help confirms -h/--help/help print the bowtie usage to stdout
+// and exit 0 without blocking on stdin.
+func TestRunBowtie_help(t *testing.T) {
+	for _, arg := range []string{"-h", "--help", "help"} {
+		var out, errOut bytes.Buffer
+		// errReader guarantees the protocol loop is never entered: help must
+		// short-circuit before any stdin read.
+		if code := runBowtie([]string{arg}, errReader{}, &out, &errOut); code != 0 {
+			t.Fatalf("%s: exit=%d, want 0", arg, code)
+		}
+		if !strings.Contains(out.String(), "usage: jsonschema bowtie") {
+			t.Errorf("%s: stdout missing the bowtie usage:\n%s", arg, out.String())
+		}
 	}
-	tcRaw, err := json.Marshal(tc)
-	if err != nil {
-		// json.Marshal will fail for invalid RawMessage; fall back to
-		// constructing the bytes manually.
-		t.Logf("Marshal failed (expected for invalid RawMessage): %v", err)
-		// Construct case bytes by hand: outer JSON is fine; the registry
-		// value is a JSON string (valid).
-		raw := `{"description":"x","schema":{"type":"string"},"registry":{"https://example.com/x":"not json"},"tests":[{"description":"x","instance":"y"}]}`
-		tcRaw = []byte(raw)
-	}
-	var enc bytes.Buffer
-	cmd := command{Cmd: "run", Seq: json.RawMessage(`1`), Case: tcRaw}
-	st := &state{}
-	encoder := json.NewEncoder(&enc)
-	if err := handleRun(cmd, st, encoder); err != nil {
-		t.Logf("handleRun: %v", err)
-	}
-	// We don't assert specific output; the goal is to drive the
-	// newCaseCompiler-failure branch. With a "not json" registry value
-	// stored as a JSON string, AddResource sees `"not json"` (valid JSON
-	// string), which DECODES OK. So instead try a registry value that's
-	// not-quite-valid: e.g. a duplicated value through a custom envelope.
 }
 
-// TestEvaluateOnePanicViaInjectedSchema covers the panic-recovery branch.
-// We directly invoke evaluateOne with a *jsonschema.Schema constructed in
-// a way that triggers a runtime panic. Without source modification, this
-// branch is hard to hit; we accept that coverage on the recovery path may
-// remain uncovered when no public API path provokes a panic.
-func TestEvaluateOnePanicCoverageBestEffort(t *testing.T) {
-	// Best-effort: call with a recursive schema and a deeply nested value
-	// to provoke a stack overflow if any. This rarely panics in practice.
-	t.Skip("evaluateOne panic recovery requires runtime panic to trigger; not reachable from public API")
+// TestRunBowtie_unexpectedArg confirms an unrecognized argument is rejected
+// (exit 2) instead of being ignored and blocking on stdin.
+func TestRunBowtie_unexpectedArg(t *testing.T) {
+	var out, errOut bytes.Buffer
+	if code := runBowtie([]string{"--nope"}, errReader{}, &out, &errOut); code != 2 {
+		t.Fatalf("unexpected arg: exit=%d, want 2", code)
+	}
+	if !strings.Contains(errOut.String(), `unexpected argument "--nope"`) {
+		t.Errorf("unexpected arg: stderr missing the rejection:\n%s", errOut.String())
+	}
 }

bowtie/main_test.go cmd/jsonschema/bowtie_test.gobowtie/main_test.go renamed to cmd/jsonschema/bowtie_test.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/go-rotini/jsonschema"
+)
+
+// runGenerate parses the generate flags, generates Go types from a JSON Schema,
+// and returns the exit code. Each flag has a short and a long form bound to the
+// same variable: -p/--package, -r/--root, -o/--output.
+func runGenerate(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+	flags := flag.NewFlagSet("jsonschema generate", flag.ContinueOnError)
+	flags.SetOutput(stderr)
+	var pkg, root, outPath string
+	flags.StringVar(&pkg, "package", "models", "package name for the generated file")
+	flags.StringVar(&pkg, "p", "models", "")
+	flags.StringVar(&root, "root", "", `name of the root type (default: schema "title", else "Root")`)
+	flags.StringVar(&root, "r", "", "")
+	flags.StringVar(&outPath, "output", "", "write output to this file instead of stdout")
+	flags.StringVar(&outPath, "o", "", "")
+	flags.Usage = func() {
+		fmt.Fprintln(stderr, "usage: jsonschema generate [flags] [schema-file]")
+		fmt.Fprintln(stderr, "reads a JSON Schema (from schema-file or stdin) and writes Go types")
+		fmt.Fprintln(stderr, `  -p, --package string   package name for the generated file (default "models")`)
+		fmt.Fprintln(stderr, `  -r, --root string      name of the root type (default: schema "title", else "Root")`)
+		fmt.Fprintln(stderr, `  -o, --output string    write output to this file instead of stdout`)
+	}
+	if err := flags.Parse(args); err != nil {
+		if errors.Is(err, flag.ErrHelp) {
+			return 0
+		}
+		return 2
+	}
+
+	schemaJSON, err := readSchema(flags.Arg(0), stdin)
+	if err != nil {
+		fmt.Fprintln(stderr, "jsonschema:", err)
+		return 1
+	}
+
+	opts := []jsonschema.GoOption{jsonschema.WithGoPackage(pkg)}
+	if root != "" {
+		opts = append(opts, jsonschema.WithGoRootType(root))
+	}
+	src, err := jsonschema.GenerateGo(schemaJSON, opts...)
+	if err != nil {
+		fmt.Fprintln(stderr, "jsonschema:", err)
+		return 1
+	}
+
+	if err := writeOutput(outPath, src, stdout); err != nil {
+		fmt.Fprintln(stderr, "jsonschema:", err)
+		return 1
+	}
+	return 0
+}
+
+// readSchema reads schema bytes from path, or from stdin when path is empty.
+func readSchema(path string, stdin io.Reader) ([]byte, error) {
+	if path == "" {
+		data, err := io.ReadAll(stdin)
+		if err != nil {
+			return nil, fmt.Errorf("read stdin: %w", err)
+		}
+		return data, nil
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read schema file: %w", err)
+	}
+	return data, nil
+}
+
+// writeOutput writes src to path, or to stdout when path is empty.
+func writeOutput(path string, src []byte, stdout io.Writer) error {
+	if path == "" {
+		if _, err := stdout.Write(src); err != nil {
+			return fmt.Errorf("write stdout: %w", err)
+		}
+		return nil
+	}
+	if err := os.WriteFile(path, src, 0o600); err != nil {
+		return fmt.Errorf("write output file: %w", err)
+	}
+	return nil
+}