tabry 0.1.0

data/spec/fixtures/basiccli2.yml

@@ -0,0 +1,7 @@
+cmd: basiccli2
+main:
+  subs:
+    - name: waz
+      args:
+        - name: bar
+

data/spec/fixtures/vehicles.tabry

@@ -0,0 +1,60 @@
+# Silly example to test various things
+# Compile with:
+# treesitter/tabry-compile.js spec/fixtures/vehicles.tabry > spec/fixtures/vehicles.yaml
+
+cmd vehicles
+desc "Build and control vehicles"
+
+flag verbose,v "Give more details in output"
+
+sub build {
+  varargs vehicle-types @vehicle-type-arg
+}
+
+sub list-vehicles
+
+sub move {
+  sub go,g @vehicle-type-arg
+  sub stop,s @vehicle-type-arg
+  sub crash @vehicle-type-arg {
+    opt arg crash-into-vehicle @vehicle-type-arg {
+      desc "Crash into another vehicle, default is to crash into a fire hydrant"
+    }
+    flagarg speed {
+      # ^ could be done with opts const, but this is just to test opts shell
+      opts shell "echo fast && echo slow"
+    }
+    flag dry-run "Don't actually crash, just simulate it"
+    flagarg output-to-file,f {
+      opts file
+      opts const "-"
+    }
+    flagarg output-to-directory,dir,d { opts dir }
+  }
+  sub freeway-crash,pileup,p @vehicle-type-arg {
+    desc "Crash on the freeway (AKA a 'pile up')"
+    opt varargs crash-into-vehicles @vehicle-type-arg {
+      title "vehicle to crash into"
+      desc "List of vehicles to crash into. Optional, leave out for a '1 car pileup' -- just crashing into center divider"
+    }
+  }
+}
+
+sub sub-with-sub-or-arg {
+  arg { opts const (x y z) }
+  sub subsub
+}
+
+sub sub-with-mandatory-flag {
+  opt arg { opts const (a b c) }
+  reqd flagarg mandatory
+  flagarg verbose,v # to test overriding a flag
+}
+
+defargs @vehicle-type-arg {
+  arg vehicle-type @vehicle-type
+}
+
+defopts @vehicle-type {
+  opts const (car bike)
+}

data/spec/fixtures/vehicles.yaml

@@ -0,0 +1,135 @@
+cmd: vehicles
+main:
+  description: Build and control vehicles
+  flags:
+    - name: verbose
+      aliases:
+        - v
+      description: Give more details in output
+  subs:
+    - name: build
+      args:
+        - name: vehicle-types
+          options:
+            - type: include
+              value: vehicle-type-arg
+          varargs: true
+    - name: list-vehicles
+    - name: move
+      subs:
+        - name: go
+          aliases:
+            - g
+          args:
+            - include: vehicle-type-arg
+          flags:
+            - include: vehicle-type-arg
+          subs:
+            - include: vehicle-type-arg
+        - name: stop
+          aliases:
+            - s
+          args:
+            - include: vehicle-type-arg
+          flags:
+            - include: vehicle-type-arg
+          subs:
+            - include: vehicle-type-arg
+        - name: crash
+          args:
+            - include: vehicle-type-arg
+            - name: crash-into-vehicle
+              optional: true
+              options:
+                - type: include
+                  value: vehicle-type-arg
+              description: Crash into another vehicle, default is to crash into a fire hydrant
+          flags:
+            - include: vehicle-type-arg
+            - name: speed
+              arg: true
+              options:
+                - type: shell
+                  value: echo fast && echo slow
+            - name: dry-run
+              description: Don't actually crash, just simulate it
+            - name: output-to-file
+              aliases:
+                - f
+              arg: true
+              options:
+                - type: file
+                - type: const
+                  value: "-"
+            - name: output-to-directory
+              aliases:
+                - dir
+                - d
+              arg: true
+              options:
+                - type: dir
+          subs:
+            - include: vehicle-type-arg
+        - name: freeway-crash
+          aliases:
+            - pileup
+            - p
+          args:
+            - include: vehicle-type-arg
+            - name: crash-into-vehicles
+              optional: true
+              options:
+                - type: include
+                  value: vehicle-type-arg
+              varargs: true
+              title: vehicle to crash into
+              description: List of vehicles to crash into. Optional, leave out for a '1 car
+                pileup' -- just crashing into center divider
+          flags:
+            - include: vehicle-type-arg
+          subs:
+            - include: vehicle-type-arg
+          description: Crash on the freeway (AKA a 'pile up')
+    - name: sub-with-sub-or-arg
+      args:
+        - options:
+            - type: const
+              value: x
+            - type: const
+              value: "y"
+            - type: const
+              value: z
+      subs:
+        - name: subsub
+    - name: sub-with-mandatory-flag
+      args:
+        - optional: true
+          options:
+            - type: const
+              value: a
+            - type: const
+              value: b
+            - type: const
+              value: c
+      flags:
+        - name: mandatory
+          required: true
+          arg: true
+        - name: verbose
+          aliases:
+            - v
+          arg: true
+arg_includes:
+  vehicle-type-arg:
+    args:
+      - name: vehicle-type
+        options:
+          - type: include
+            value: vehicle-type
+option_includes:
+  vehicle-type:
+    - type: const
+      value: car
+    - type: const
+      value: bike
+

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+ENV["RAILS_ENV"] ||= "test"
+
+require "simplecov"
+SimpleCov.start do
+  add_filter "spec"
+  track_files "lib/**/*.rb"
+end
+SimpleCov.minimum_coverage(80)

data/spec/tabry/cli/arg_proxy_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/tabry/cli/arg_proxy"
+
+describe Tabry::CLI::ArgProxy do
+  let(:named_args) do
+    {
+      "abc" => "123",
+      "def" => "456",
+      "ghi" => ["789", "000"],
+    }
+  end
+  let(:args) { described_class.new(named_args.values, named_args) }
+
+  describe "#[]" do
+    it "makes args accessible by name as a hash key (string)" do
+      expect(args["def"]).to eq("456")
+    end
+
+    it "makes args accessible by name as a hash key (symbol)" do
+      expect(args[:ghi]).to eq(%w[789 000])
+    end
+
+    it "makes args accessible by index" do
+      expect(args[0]).to eq("123")
+      expect(args[1]).to eq("456")
+    end
+
+    it "returns ungiven args as nil" do
+      expect(args["foo"]).to be_nil
+      expect(args[:bar]).to be_nil
+      expect(args[3]).to be_nil
+    end
+  end
+
+  describe "#accessing as a method" do
+    it "makes args accessible by name as a method" do
+      expect(args.def).to eq("456")
+    end
+
+    it "returns nil if not found" do
+      expect(args.foo).to be_nil
+    end
+  end
+
+  describe "#reqd" do
+    it "provides access to arguments through reqd" do
+      expect(args.reqd.def).to eq("456")
+    end
+
+    it "prints an error and exits if read thru reqd and the argument (name) is not found" do
+      expect(args.reqd).to receive(:exit).with(1)
+      expect do
+        args.reqd.foo
+      end.to output(/FATAL: Missing required argument foo/).to_stderr
+    end
+
+    it "prints an error and exits if read thru reqd and the argument (index) is not found" do
+      expect(args.reqd).to receive(:exit).with(1)
+      expect do
+        args.reqd[3]
+      end.to output(/FATAL: Missing required argument number 4/).to_stderr
+    end
+  end
+
+  describe "#slice" do
+    it "returns a hash with just the keys given" do
+      expect(args.slice(:abc, :ghi)).to eq(abc: "123", ghi: %w[789 000])
+    end
+  end
+
+  it "is enumerable like an array" do
+    proxy = described_class.new(%w[a b c], {})
+    expect(proxy.map { |arg| "ok" + arg }).to eq(%w[oka okb okc])
+  end
+end

data/spec/tabry/cli/builder_spec.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/tabry/cli/builder"
+require_relative "../../../lib/tabry/cli/base"
+
+# probably test base & builder together in this file. and runner
+
+class Tabry::CLI::Builder
+  class TestCliFooBar < Tabry::CLI::Base
+    class << self
+      attr_accessor :actions_run, :cli_object
+    end
+
+    before_action :my_before_action
+
+    def main
+      self.class.actions_run << :main
+    end
+
+    def waz
+      self.class.actions_run << :waz
+    end
+
+    def my_before_action
+      self.class.actions_run << :before_action
+      self.class.cli_object = self
+    end
+  end
+
+  class TestCliFoo < Tabry::CLI::Base
+    sub_route :bar, TestCliFooBar
+  end
+
+  class TestCli < Tabry::CLI::Base
+    class << self
+      attr_accessor :actions_run, :cli_object
+    end
+
+    before_action :my_before_action, only: :build
+    after_action :my_after_action, except: :build2
+
+    sub_route :foo, TestCliFoo
+
+    def main
+      self.class.actions_run << :main
+    end
+
+    def build
+      self.class.actions_run << :build
+    end
+
+    def build2
+      self.class.actions_run << :build2
+    end
+
+    def my_action
+      self.class.actions_run << :my_action
+    end
+
+    def sub__sub_sub
+      self.class.actions_run << :sub__sub_sub
+    end
+
+    def my_before_action
+      self.class.actions_run << :before_action
+      self.class.cli_object = self
+    end
+
+    def my_after_action
+      self.class.actions_run << :after_action
+      self.class.cli_object = self
+    end
+  end
+end
+
+describe Tabry::CLI::Builder do
+  subject { builder.run(%w[the raw args]) }
+
+  before do
+    runner = instance_double(Tabry::Runner)
+    allow(Tabry::Runner).to receive(:new).with(config_name: "theconfigname").and_return runner
+    allow(runner).to receive(:parse).with(%w[the raw args]).and_return result
+  end
+
+  let(:result) do
+    instance_double(
+      Tabry::Result,
+      state: Tabry::State.new({ args: [], subcommand_stack: [] }.merge(state)),
+      help?: help?,
+      invalid_usage_reason: invalid_usage_reason,
+      named_args: named_args
+    )
+  end
+  let(:help?) { nil }
+  let(:invalid_usage_reason) { nil }
+  let(:named_args) { {} }
+  let(:state) { {} }
+
+  let(:builder) { described_class.new("theconfigname", Tabry::CLI::Builder::TestCli) }
+
+  let(:cli_class) { Tabry::CLI::Builder::TestCli }
+  let(:cli_class2) { Tabry::CLI::Builder::TestCliFooBar }
+  let(:actions_run) { cli_class.actions_run }
+  let(:cli_object) { cli_class.cli_object }
+
+  before do
+    cli_class.actions_run = []
+    cli_class.cli_object = nil
+    cli_class2.actions_run = []
+    cli_class2.cli_object = nil
+  end
+
+  describe "successful runs" do
+    before { subject }
+
+    describe "runs the method name, and before and after actions" do
+      let(:state) { { subcommand_stack: %w[build] } }
+
+      it { expect(actions_run).to eq %i[before_action build after_action] }
+    end
+
+    describe "changing - into _ in subcommand names, and :only on actions" do
+      let(:state) { { subcommand_stack: %w[my-action] } }
+
+      it { expect(actions_run).to eq %i[my_action after_action] }
+    end
+
+    describe "calling main as the main subcommand" do
+      it { expect(actions_run).to eq %i[main after_action] }
+    end
+
+    describe "except on actions" do
+      let(:state) { { subcommand_stack: %w[build2] } }
+
+      it { expect(actions_run).to eq %i[build2] }
+    end
+
+    describe "handling multiple levels of subcommand routing" do
+      let(:state) { { subcommand_stack: %i[foo bar waz] } }
+
+      it "doesn't run before/after actions" do
+        expect(actions_run).to eq(%i[])
+      end
+
+      it "maps to the sub-CLI" do
+        expect(cli_class2.actions_run).to eq(%i[before_action waz])
+      end
+    end
+
+    describe "handling multiple levels of subcommand routing (main method)" do
+      let(:state) { { subcommand_stack: %i[foo bar] } }
+
+      it { expect(cli_class2.actions_run).to eq(%i[before_action main]) }
+    end
+
+    describe "providing an ArgProxy in TestCLI#args" do
+      let(:state) { { args: %w[123 bar] } }
+      let(:named_args) { { "a" => "123" } }
+
+      it do
+        expect(cli_object.args).to be_a(Tabry::CLI::ArgProxy)
+        expect(cli_object.args.a).to eq("123")
+        expect(cli_object.args.waz).to be_nil
+        expect(cli_object.args[1]).to eq("bar")
+        expect(cli_object.args[2]).to be_nil
+      end
+    end
+
+    describe "providing access to flags in TestCLI#flags" do
+      let(:state) { { flags: { "foo" => "123", "bar" => true } } }
+
+      it do
+        expect(cli_object.args).to be_a(Tabry::CLI::ArgProxy)
+        expect(cli_object.flags.foo).to eq("123")
+        expect(cli_object.flags.bar).to be(true)
+        expect(cli_object.flags.waz).to be_nil
+      end
+    end
+  end
+
+  describe "unsuccessful or help runs" do
+    describe "invalid usage" do
+      let(:invalid_usage_reason) { "Bla bla not enough arguments or something" }
+
+      it "quits and shows an error and usage info if there is incorrect usage" do
+        expect(result).to receive(:usage).and_return "example command usage"
+        expect(builder).to receive(:exit).with(1)
+        expect do
+          subject
+        end.to output(
+          /Invalid usage: Bla bla not enough arguments or something.*example command usage/m
+        ).to_stdout
+      end
+    end
+
+    describe "help" do
+      let(:help?) { true }
+
+      it "quits and shows usage if help is passed in" do
+        expect(result).to receive(:usage).and_return "example command usage"
+        expect(builder).to receive(:exit).with(0)
+        expect { subject }.to output(/example command usage/).to_stdout
+      end
+    end
+
+    context "when the CLI class that doesn't implement a method" do
+      context "when the command is valid but the CLI class doesn't implement it" do
+        let(:state) { { subcommand_stack: %w[wombat] } }
+
+        it "quits and shows an error if there is the command is valid but the CLI class doesn't implement it" do
+          expect(builder).to receive(:exit).with(1)
+          expect { subject }.to output(/FATAL: CLI does not support command wombat/).to_stderr
+        end
+      end
+
+      context "when the sub-route CLI doesn't implement \"main\" and that is what is requested" do
+        let(:state) { { subcommand_stack: %w[foo] } }
+
+        it "quits and shows an error" do
+          expect(builder).to receive(:exit).with(1)
+          expect { subject }.to output(/FATAL: CLI does not support command main/).to_stderr
+        end
+      end
+    end
+  end
+end

data/spec/tabry/config_loader_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/config_loader"
+
+describe Tabry::ConfigLoader do
+  before do
+    @old_home = Dir.home
+    @old_tabry_imports_path = ENV.fetch("TABRY_IMPORTS_PATH", nil)
+  end
+
+  after do
+    ENV["HOME"] = @old_home
+    ENV["TABRY_IMPORTS_PATH"] = @old_tabry_imports_path
+  end
+
+  it "loads from absolute paths" do
+    config = described_class.load(name: "#{__dir__}/../fixtures/vehicles.yaml")
+    expect(config).to be_a(Tabry::Models::Config)
+    expect(config.main.subs.map(&:name)).to eq(
+      %w[build list-vehicles move sub-with-sub-or-arg sub-with-mandatory-flag]
+    )
+  end
+
+  describe "use of $TABRY_IMPORTS_PATH" do
+    before { ENV["TABRY_IMPORTS_PATH"] = "#{__dir__}/../fixtures/" }
+
+    it "looks for yaml files in TABRY_IMPORTS_PATH" do
+      config = described_class.load(name: "vehicles")
+      expect(config.main.subs.map(&:name)).to eq(
+        %w[build list-vehicles move sub-with-sub-or-arg sub-with-mandatory-flag]
+      )
+    end
+
+    it "looks for json files in TABRY_IMPORTS_PATH" do
+      config = described_class.load(name: "basiccli")
+      expect(config.main.subs.map(&:name)).to eq(%w[foo])
+    end
+
+    it "looks for yml files in TABRY_IMPORTS_PATH" do
+      config = described_class.load(name: "basiccli2")
+      expect(config.main.subs.map(&:name)).to eq(%w[waz])
+    end
+  end
+
+  describe "use of $HOME" do
+    before do
+      ENV["HOME"] = "#{__dir__}/../fixtures/dir_with_dot_tabry/"
+
+      # TABRY_IMPORTS_PATH is set first, so we have to null it out in case it is already set:
+      ENV["TABRY_IMPORTS_PATH"] = nil
+    end
+
+    it "looks for json files in HOME/.tabry" do
+      config = described_class.load(name: "basiccli")
+      expect(config.main.subs.map(&:name)).to eq(%w[foo])
+    end
+  end
+
+  context "when it can't find a config" do
+    it "raises an error" do
+      expect do
+        described_class.load(name: "fj093jf04309fj3490fj3490f43j90kldfsjghkljasdghklshfsdkhjagfklj")
+      end.to raise_error(
+        described_class::ConfigNotFound,
+        /Could not find Tabry config fj093jf04309fj3490fj3490f43j90kldfsjghkljasdghklshfsdkhjagfklj\.\(json, yml, yaml\)/
+      )
+    end
+  end
+end

data/spec/tabry/machine_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/machine"
+require_relative "../../lib/tabry/config_loader"
+
+describe Tabry::Machine do
+  let(:config_fixture) { "#{__dir__}/../fixtures/vehicles.yaml" }
+  let(:config) { Tabry::ConfigLoader.load(name: config_fixture) }
+
+  def expect_sub_stack_and_args(arr)
+    expect(subject.subcommand_stack).to eq(arr)
+  end
+
+  def expect_args(arr)
+    expect(subject.args).to eq(arr)
+  end
+
+  examples = {
+    "handles subcommands" => [
+      %w[build],
+      subs: %w[build], mode: :subcommand
+    ],
+    "handles bogus subcommands" => [
+      %w[bogus],
+      subs: [], args: %w[bogus]
+    ],
+    "handles bogus subcommands of subcommands are treated as args" => [
+      %w[move bogus bogus2],
+      subs: %w[move], args: %w[bogus bogus2], mode: :subcommand
+    ],
+    "handles subcommands of subcommands" => [
+      %w[move go],
+      subs: %w[move go],
+    ],
+    "handles subcommands aliases" => [
+      %w[move g],
+      subs: %w[move go],
+    ],
+    "handles argsuments" => [
+      %w[build arg1 arg2],
+      subs: %w[build], args: %w[arg1 arg2]
+    ],
+    "handles flags" => [
+      %w[build -v],
+      subs: %w[build], flags: { "verbose" => true }, args: [], mode: :subcommand
+    ],
+    "handles long flags" => [
+      %w[--verbose build],
+      subs: %w[build], flags: { "verbose" => true }, args: [], mode: :subcommand
+    ],
+    "handles flags interspersed with arguments" => [
+      %w[move -v crash arg1 --dry-run arg2 arg3],
+      subs: %w[move crash], args: %w[arg1 arg2 arg3],
+      flags: { "dry-run" => true, "verbose" => true }, mode: :subcommand
+    ],
+    "handles flags with an argument" => [
+      %w[move crash --dry-run arg1 -f file arg2 arg3],
+      subs: %w[move crash], args: %w[arg1 arg2 arg3],
+      flags: { "dry-run" => true, "output-to-file" => "file" }, mode: :subcommand
+    ],
+    "handles double-dash to stop parsing of flags" => [
+      %w[move crash -- --dry-run arg1 -f file arg2 arg3],
+      subs: %w[move crash], args: %w[--dry-run arg1 -f file arg2 arg3], mode: :subcommand
+    ],
+    "handles unknown long flags as args" => [
+      %w[move crash --notaflag arg2],
+      subs: %w[move crash], args: %w[--notaflag arg2], mode: :subcommand
+    ],
+    "handles unknown short flags as args" => [
+      %w[move crash -x arg2 --dry-run],
+      subs: %w[move crash], args: %w[-x arg2], flags: { "dry-run" => true }, mode: :subcommand
+    ],
+    "handles --help" => [
+      %w[move --help],
+      subs: %w[move], flags: {}, args: [], help: true, mode: :subcommand
+    ],
+    "handles -?" => [
+      %w[move foo bar --help waz],
+      subs: %w[move], flags: {}, args: %w[foo bar waz], help: true
+    ],
+    "ignores -?/--help after double-dash" => [
+      %w[move -- --help -? -- -],
+      subs: %w[move], flags: {}, args: %w[--help -? -- -], help: nil
+    ],
+    "sets mode to flagarg when waiting for a flag argument" => [
+      %w[move crash --dry-run arg1 -f],
+      subs: %w[move crash], args: %w[arg1], flags: { "dry-run" => true },
+      mode: :flagarg, current_flag: "output-to-file"
+    ],
+    # TODO: might want behavior to be different; currently I think if --verbose is before the
+    # subcommand it use's the main command's --verbose flag
+    "most specific sub's flag takes precedence in case of multiple matching" => [
+      %w[sub-with-mandatory-flag --verbose foo --mandatory abc],
+      subs: %w[sub-with-mandatory-flag],
+      flags: { "verbose" => "foo", "mandatory" => "abc" }
+    ]
+  }
+
+  examples.each do |test_name, (tokens, expectation)|
+    it test_name do
+      pending unless expectation
+      result = described_class.run(config, tokens)
+      expectation.each do |key, val|
+        key = :subcommand_stack if key == :subs
+        expect(result.send(key)).to eq(val)
+      end
+    end
+  end
+end