cmd: Rename jx to jnx and split out flag version

Makefile

@@ -14,12 +14,11 @@ clean::  ## Remove generated files
 
 build: | $(O)  ## Build binaries of directories in ./cmd to out/
 	go build -o $(O) ./cmd/...
-	go build -tags flag -o $(O)/jx-flag ./cmd/jx
 
 install:  ## Build and install binaries in $GOBIN or $GOPATH/bin
 	go install ./cmd/...
 
-$(O)/jx: build
+$(O)/jnx: build
 
 .PHONY: build install
 
@@ -33,8 +32,8 @@ test: test-go test-jsonnet  ## Run tests and generate a coverage file
 test-go: | $(O)
 	go test -coverprofile=$(COVERFILE) ./...
 
-test-jsonnet: $(O)/jx
-	$(O)/jx -J $(JSONNET_UNIT) lib/jx_test.jsonnet
+test-jsonnet: $(O)/jnx
+	$(O)/jnx -J $(JSONNET_UNIT) lib/jnx_test.jsonnet
 
 check-coverage: test  ## Check that test coverage meets the required level
 	@go tool cover -func=$(COVERFILE) | $(CHECK_COVERAGE) || $(FAIL_COVERAGE)

cmd/jx/doc.go → cmd/jnx/doc.go

@@ -1,6 +1,6 @@
-// jx evaluates a jsonnet file and outputs it as JSON.
+// jnx evaluates a jsonnet file and outputs it as JSON.
 //
-// Usage: jx [<filename>]
+// Usage: jnx [<filename>]
 //
 // Arguments:
 //   [<filename>]    File to evaluate. stdin is used if omitted or "-"

cmd/jnx/jnxflag/main.go

@@ -0,0 +1,88 @@
+// jnxflag evaluates a jsonnet file and outputs it as JSON.
+//
+// Usage of ./jnxflag:
+//   -A var[=str]
+//         Add top-level arg var[=str] (from environment if <str> is omitted)
+//   -J dir
+//         Add a library search dir
+//   -V var[=str]
+//         Add extVar var[=str] (from environment if <str> is omitted)
+//   -ext-code var[=code]
+//         Add extVar var[=code] (from environment if <code> is omitted)
+//   -ext-code-file var=file
+//         Add extVar var=file code from a file
+//   -ext-str var[=str]
+//         Add extVar var[=str] (from environment if <str> is omitted)
+//   -ext-str-file var=file
+//         Add extVar var=file string from a file
+//   -jpath dir
+//         Add a library search dir
+//   -tla-code var[=code]
+//         Add top-level arg var[=code] (from environment if <code> is omitted)
+//   -tla-code-file var=file
+//         Add top-level arg var=file code from a file
+//   -tla-str var=[=str]
+//         Add top-level arg var=[=str] (from environment if <str> is omitted)
+//   -tla-str-file var=file
+//         Add top-level arg var=file string from a file
+//
+// This program exists just to implement the standard Go flag package parsing.
+// The full jnx program uses the kong library and has more features.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"foxygo.at/jsonnext"
+	jsonnet "github.com/google/go-jsonnet"
+)
+
+type config struct {
+	jsonnext.Config
+	Filename string `arg:"" optional:"" help:"File to evaluate. stdin is used if omitted or \"-\""`
+}
+
+func main() {
+	cli := parseCLI()
+	vm := cli.Config.MakeVM("JNXPATH")
+
+	out, err := run(vm, cli.Filename)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	fmt.Print(out)
+}
+
+// Parse CLI using Go's flag package and the helpers in jsonnext.
+func parseCLI() *config {
+	c := &config{}
+	c.Config = *jsonnext.ConfigFlags(flag.CommandLine)
+
+	flag.Parse()
+	if flag.NArg() > 1 {
+		flag.Usage()
+		os.Exit(1)
+	} else if flag.NArg() == 1 {
+		c.Filename = flag.Args()[0]
+	}
+
+	return c
+}
+
+func run(vm *jsonnet.VM, filename string) (string, error) {
+	node, _, err := vm.ImportAST("", filename)
+	if err != nil {
+		return "", err
+	}
+
+	out, err := vm.Evaluate(node)
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}

cmd/jx/main.go → cmd/jnx/main.go

@@ -4,20 +4,22 @@ import (
 	"fmt"
 	"os"
 
-	jxkong "foxygo.at/jsonnext/kong"
+	jnxkong "foxygo.at/jsonnext/kong"
+	"github.com/alecthomas/kong"
 	jsonnet "github.com/google/go-jsonnet"
 )
 
 type config struct {
-	jxkong.Config
+	jnxkong.Config
 	Filename string `arg:"" optional:"" help:"File to evaluate. stdin is used if omitted or \"-\""`
 }
 
 func main() {
-	cli := parseCLI()
-	vm := cli.Config.MakeVM("JXPATH")
+	c := &config{Config: *jnxkong.NewConfig()}
+	kong.Parse(c)
+	vm := c.Config.MakeVM("JNXPATH")
 
-	out, err := run(vm, cli.Filename)
+	out, err := run(vm, c.Filename)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)

kong/example_test.go

@@ -4,19 +4,19 @@ import (
 	"fmt"
 	"os"
 
-	jxkong "foxygo.at/jsonnext/kong"
+	jnxkong "foxygo.at/jsonnext/kong"
 	"github.com/alecthomas/kong"
 )
 
 func Example() {
-	// Define kong CLI struct embedding jxkong.Config, adding your own
+	// Define kong CLI struct embedding jnxkong.Config, adding your own
 	// application-specific flags and args.
 	cli := struct {
-		jxkong.Config
+		jnxkong.Config
 		Verbose  bool
 		Filename string `arg:""`
 	}{
-		Config: *jxkong.NewConfig(), // foxygo.at/jsonnext/kong imported as jxkong
+		Config: *jnxkong.NewConfig(), // foxygo.at/jsonnext/kong imported as jnxkong
 	}
 
 	// Simulate command line arguments

kong/kong_conformance_test.go

@@ -7,13 +7,13 @@ import (
 
 	"foxygo.at/jsonnext"
 	"foxygo.at/jsonnext/conformance"
-	jxkong "foxygo.at/jsonnext/kong"
+	jnxkong "foxygo.at/jsonnext/kong"
 )
 
 type suite struct{}
 
 func (s *suite) Parse(t *testing.T, args []string) (*jsonnext.Config, error) {
-	kcfg := jxkong.NewConfig()
+	kcfg := jnxkong.NewConfig()
 	parser, err := kong.New(kcfg)
 	if err != nil {
 		return nil, err

lib/array_test.jsonnet

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 
 local array = import 'array.jsonnet';
 local test = import 'jsonnetunit/test.libsonnet';

lib/jnx.jsonnet

@@ -0,0 +1,9 @@
+// Package jnx is a top-level package to import the subpackages of the
+// jnx library.
+{
+  array:: import 'array.jsonnet',
+  object:: import 'object.jsonnet',
+  op:: import 'op.jsonnet',
+  string:: import 'string.jsonnet',
+  value:: import 'value.jsonnet',
+}

lib/jx_test.jsonnet → lib/jnx_test.jsonnet

@@ -1,22 +1,22 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 //
 // Roll-up all the tests in this directory
 //
 
+local jnx = import 'jnx.jsonnet';
 local test = import 'jsonnetunit/test.libsonnet';
-local jx = import 'jx.jsonnet';
 
-local jx_test = { name: 'jx.jsonnet test' } + test.suite({
+local jnx_test = { name: 'jnx.jsonnet test' } + test.suite({
   testImport: {
-    // Force evaluation of imports in `jx.jsonnet` by using std.prune over
+    // Force evaluation of imports in `jnx.jsonnet` by using std.prune over
     // all fields. This will cause a failure if a file cannot be imported.
-    actual: std.prune(std.objectValuesAll(jx)),
+    actual: std.prune(std.objectValuesAll(jnx)),
     expect: [],  // empty because all fields are hidden and thus pruned.
   },
 });
 
 [
-  jx_test,
+  jnx_test,
   import 'array_test.jsonnet',
   import 'object_test.jsonnet',
   import 'op_test.jsonnet',

lib/jx.jsonnet

@@ -1,9 +1,2 @@
-// Package jx is a top-level package to import the subpackages of the
-// jx library.
-{
-  array:: import 'array.jsonnet',
-  object:: import 'object.jsonnet',
-  op:: import 'op.jsonnet',
-  string:: import 'string.jsonnet',
-  value:: import 'value.jsonnet',
-}
+// Kept for backwards compatibilty for now. Will be removed in the future.
+import 'jnx.jsonnet'

lib/object_test.jsonnet

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 
 local test = import 'jsonnetunit/test.libsonnet';
 local object = import 'object.jsonnet';

lib/op_test.jsonnet

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 
 local test = import 'jsonnetunit/test.libsonnet';
 local op = import 'op.jsonnet';

lib/string_test.jsonnet

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 
 local test = import 'jsonnetunit/test.libsonnet';
 local string = import 'string.jsonnet';

lib/value_test.jsonnet

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S jx -J //github.com/yugui/jsonnetunit/raw/master
+#!/usr/bin/env -S jnx -J //github.com/yugui/jsonnetunit/raw/master
 
 local test = import 'jsonnetunit/test.libsonnet';
 local value = import 'value.jsonnet';