tabry 0.1.0

data/spec/tabry/models/args_list_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/args_list"
+
+describe Tabry::Models::ArgsList do
+  subject do
+    described_class.new(root: double, raw: [
+                          { "name" => "foo", "description" => "the foo arg" },
+                          { "name" => "bar", "description" => "the bar arg" },
+                          { "name" => "things", "description" => "the waz arg", "varargs" => true },
+                        ])
+  end
+
+  describe "#[]" do
+    it "provides access to arguments by index" do
+      expect(subject[0].name).to eq("foo")
+      expect(subject[0]).to be_a(Tabry::Models::Arg)
+      expect(subject[1].name).to eq("bar")
+      expect(subject[2].name).to eq("things")
+      expect(subject[2]).to be_a(Tabry::Models::Arg)
+      expect(subject[2].varargs?).to be(true)
+    end
+  end
+
+  describe "#varargs_arg" do
+    it "returns the vararg if there is one" do
+      expect(subject.varargs_arg).to eq(subject[2])
+    end
+
+    it "returns nil if there is no varargs" do
+      args_list = described_class.new(root: double, raw: [{ "name" => "foo" }])
+      expect(args_list.varargs_arg).to be_nil
+    end
+  end
+end

data/spec/tabry/models/config_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/config"
+
+describe Tabry::Models::Config do
+  subject { described_class.new(raw: JSON.parse(config_hash.to_json)) }
+
+  let(:config_hash) do
+    {
+      cmd: "foo",
+      main: {
+        subs: [
+          {
+            name: "sub1",
+            description: "first-level sub",
+            subs: [
+              {
+                name: "sub1.1",
+                description: "sub under a sub"
+              }
+            ]
+          },
+          {
+            name: "sub2",
+            description: "first-level sub 2",
+            subs: [
+              { name: "sub21", subs: [{ name: "subs211" }] }
+            ],
+          }
+        ]
+      }
+    }
+  end
+
+  describe "#dig_sub_array" do
+    it "returns the array of subcommands leading up to the specified subcommand" do
+      res = subject.dig_sub_array(%w[sub1 sub1.1])
+      expect(res.map(&:name)).to eq([nil, "sub1", "sub1.1"])
+      expect(res).to eq([
+                          subject.main,
+                          subject.main.subs[0],
+                          subject.main.subs[0].subs[0]
+                        ])
+    end
+
+    it "returns an array with just the main subcommand if an empty array is passed in" do
+      res = subject.dig_sub_array(%w[])
+      expect(res).to eq([subject.main])
+    end
+  end
+
+  describe "#dig_sub" do
+    it "returns the sub referenced" do
+      expect(subject.dig_sub(%w[sub2])).to eq(subject.main.subs[1])
+    end
+
+    it "returns the main sub if an empty array is passed" do
+      expect(subject.dig_sub(%w[])).to eq(subject.main)
+    end
+  end
+end

data/spec/tabry/models/const_option_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/const_option"
+
+describe Tabry::Models::ConstOption do
+  subject do
+    described_class.new(root: double, raw: { "type" => "const", "value" => "foobar" })
+  end
+
+  it "filters by prefix" do
+    expect(subject.options("")).to eq(%w[foobar])
+    expect(subject.options("f")).to eq(%w[foobar])
+    expect(subject.options("foo")).to eq(%w[foobar])
+    expect(subject.options("w")).to eq(%w[])
+  end
+end

data/spec/tabry/models/dir_option_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/dir_option"
+
+describe Tabry::Models::DirOption do
+  subject do
+    described_class.new(root: double, raw: { "type" => "dir" })
+  end
+
+  # Handled by tabru=bash/tabry-bash.sh/shell, we just return a symbol to
+  # communicate to tabry-bash
+  it "returns a array with a symbol" do
+    expect(subject.options("whatever")).to eq([:directory])
+  end
+end

data/spec/tabry/models/file_option_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/file_option"
+
+describe Tabry::Models::FileOption do
+  subject do
+    described_class.new(root: double, raw: { "type" => "file" })
+  end
+
+  # Handled by tabru=bash/tabry-bash.sh/shell, we just return a symbol to
+  # communicate to tabry-bash
+  it "returns a array with a symbol" do
+    expect(subject.options("whatever")).to eq([:file])
+  end
+end

data/spec/tabry/models/options_list_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/options_list"
+
+describe Tabry::Models::OptionsList do
+  subject do
+    described_class.new(root: double, raw: JSON.parse(raw_array.to_json))
+  end
+
+  let(:raw_array) do
+    [
+      { type: "file" },
+      { type: "shell", value: "echo a && echo b" },
+      { type: "const", value: "foo" },
+      { type: "const", value: "bar" },
+      { type: "dir" },
+    ]
+  end
+
+  it "is enumerable over the options it creates" do
+    expect(subject.any? { |opt| opt.type == "dir" }).to be(true)
+    expect(subject.map(&:class)).to eq([
+                                         Tabry::Models::FileOption,
+                                         Tabry::Models::ShellOption,
+                                         Tabry::Models::ConstOption,
+                                         Tabry::Models::ConstOption,
+                                         Tabry::Models::DirOption,
+                                       ])
+  end
+
+  describe "options" do
+    it "aggregates options from all options" do
+      opts_results = [
+        %w[foo bar waz],
+        %w[a b c],
+        %w[1 a foo],
+        %w[ok ok ok],
+        %w[d c b a]
+      ]
+      subject.each_with_index do |opt, i|
+        expect(opt).to receive(:options).with("some-token").and_return(opts_results[i])
+      end
+      expect(subject.options("some-token")).to match_array(%w[a b c d foo bar waz ok 1])
+    end
+  end
+end

data/spec/tabry/models/shell_option_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/shell_option"
+
+describe Tabry::Models::ShellOption do
+  subject do
+    described_class.new(root: double, raw: {
+                          "type" => "shell", "value" => "echo a && echo a1 && echo b"
+                        })
+  end
+
+  it "filters by prefix" do
+    expect(subject.options("")).to match_array(%w[a a1 b])
+    expect(subject.options("a")).to match_array(%w[a a1])
+    expect(subject.options("a1")).to match_array(%w[a1])
+    expect(subject.options("a1 ")).to match_array(%w[])
+  end
+end

data/spec/tabry/models/subs_list_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../lib/tabry/models/subs_list"
+
+describe Tabry::Models::SubsList do
+  describe "#by_name" do
+    subject do
+      described_class.new(root: double, raw: [
+                            { "name" => "foo", "description" => "the foo sub" },
+                            { "name" => "bar", "description" => "the bar subcommand" },
+                            { "name" => "waz", "description" => "the waz subcommand" },
+                          ])
+    end
+
+    it "finds subcommands by name" do
+      bar = subject.by_name["bar"]
+      expect(bar).to be_a(Tabry::Models::Sub)
+      expect(bar.name).to eq("bar")
+      expect(bar.description).to eq("the bar subcommand")
+      expect(subject.by_name["waz"].name).to eq("waz")
+    end
+  end
+end

data/spec/tabry/options_finder_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/config_loader"
+require_relative "../../lib/tabry/options_finder"
+require_relative "../../lib/tabry/result"
+require_relative "../../lib/tabry/state"
+
+describe Tabry::OptionsFinder do
+  let(:config_fixture) { "#{__dir__}/../fixtures/vehicles.yaml" }
+  let(:config) { Tabry::ConfigLoader.load(name: config_fixture) }
+  let(:state) { {} }
+
+  examples = {
+    "lists possible subcommands of the main command" => [
+      %w[build list-vehicles move sub-with-sub-or-arg sub-with-mandatory-flag],
+      {}
+    ],
+    "lists possible subcommands of a subcommand" => [
+      %w[go stop crash freeway-crash],
+      subs: %w[move]
+    ],
+    "lists possible arguments (const)" => [
+      %w[car bike],
+      subs: %w[move go]
+    ],
+    "lists both possible args and subs if a subcommand can take either" => [
+      %w[x y z subsub],
+      subs: %w[sub-with-sub-or-arg]
+    ],
+    "lists possible flags if the last token starts with a dash" => [
+      %w[--verbose --speed --output-to-file --output-to-directory --dry-run],
+      subs: %w[move crash],
+      token: "-"
+    ],
+    "doesn't list a flag if it has already been given" => [
+      %w[--verbose --speed --output-to-file --output-to-directory],
+      flags: { "dry-run" => true },
+      subs: %w[move crash],
+      token: "-"
+    ],
+    "doesn't suggests flags if '--' has been used" => [
+      [],
+      dashdash: true,
+      subs: %w[move crash],
+      token: "-",
+    ],
+    "lists only a mandatory flag if it hasn't been given yet" => [
+      %w[--mandatory],
+      subs: %w[sub-with-mandatory-flag],
+    ],
+    "lists other args after a mandatory flag has been given" => [
+      %w[a b c],
+      subs: %w[sub-with-mandatory-flag],
+      flags: { "mandatory" => "foo" }
+    ],
+    "lists possibilities for a flag arguments (shell)" => [
+      %w[fast slow],
+      subs: %w[move crash],
+      mode: :flagarg,
+      current_flag: "speed",
+    ],
+    "lists possibilities for a flag arguments (file, const)" => [
+      [:file, "-"],
+      subs: %w[move crash],
+      mode: :flagarg,
+      current_flag: "output-to-file",
+    ],
+    "lists possibilities for a flag arguments (dir)" => [
+      [:directory],
+      subs: %w[move crash],
+      mode: :flagarg,
+      current_flag: "output-to-directory",
+    ],
+    "lists nothing if no options are defined" => [
+      [],
+      subs: %w[sub-with-sub-or-arg],
+      mode: :flagarg,
+      current_flag: "mandatory"
+    ],
+  }
+
+  examples.each do |name, (expected_options, hash)|
+    it name do
+      token = hash.delete(:token)
+      hash[:subcommand_stack] = hash.delete(:subs) || []
+      defaults = { mode: :subcommand, args: [], flags: {}, current_flag: nil, dashdash: nil }
+      result = Tabry::Result.new(config, Tabry::State.new(defaults.merge(hash)))
+      expect(described_class.options(result, token)).to match_array expected_options
+    end
+  end
+end

data/spec/tabry/result_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/result"
+require_relative "../../lib/tabry/config_loader"
+require_relative "../../lib/tabry/state"
+
+describe Tabry::Result do
+  subject do
+    described_class.new(config, state)
+  end
+
+  let(:config_fixture) { "#{__dir__}/../fixtures/vehicles.yaml" }
+  let(:config) { Tabry::ConfigLoader.load(name: config_fixture) }
+
+  describe "#current_sub" do
+    let(:state) { Tabry::State.new(subcommand_stack: %w[move crash]) }
+
+    it "returns the last subcommand" do
+      expect(subject.current_sub).to be_a(Tabry::Models::Sub)
+      expect(subject.current_sub.name).to eq("crash")
+    end
+  end
+
+  describe "#invalid_usage_reason" do
+    def reason(state_hash)
+      state = { mode: :subcommand, args: [], flags: {} }.merge(state_hash)
+      described_class.new(config, Tabry::State.new(**state)).invalid_usage_reason
+    end
+
+    it "returns nil if everything is fine (subcommand with no args)" do
+      expect(reason(
+               subcommand_stack: %w[list-vehicles]
+             )).to be_nil
+    end
+
+    it "complains if mandatory args are not given" do
+      expect(reason(
+               subcommand_stack: %w[move go]
+             )).to eq('missing argument "vehicle-type"')
+    end
+
+    it "complains if a mandatory subcommand (of the main command) is not given" do
+      expect(reason(
+               subcommand_stack: %w[]
+             )).to eq("missing subcommand")
+    end
+
+    it "complains if a mandatory subcommand (of a subcommand) is not given" do
+      expect(reason(
+               subcommand_stack: %w[move]
+             )).to eq("missing subcommand")
+    end
+
+    it "complains if a mandatory subcommand or arg is not given" do
+      expect(reason(
+               subcommand_stack: %w[sub-with-sub-or-arg]
+             )).to eq("missing subcommand or arg(s)")
+    end
+
+    it "doesn't complain if mandatory args are given" do
+      expect(reason(
+               subcommand_stack: %w[move go],
+               args: %w[vehicle1],
+               flags: { "dry-run" => true, "output-to-file" => "some-file" }
+             )).to be_nil
+
+      expect(reason(
+               subcommand_stack: %w[sub-with-sub-or-arg],
+               args: %w[arg]
+             )).to be_nil
+    end
+
+    it "complains if mandatory varargs are not given" do
+      expect(reason(
+               subcommand_stack: %w[build]
+             )).to eq("missing one or more args")
+    end
+
+    it "doesn't complain if one vararg is given" do
+      expect(reason(
+               subcommand_stack: %w[build],
+               args: %w[vehicle1]
+             )).to be_nil
+
+      expect(reason(
+               subcommand_stack: %w[move freeway-crash],
+               args: %w[vehicle1 vehicle2]
+             )).to be_nil
+    end
+
+    it "doesn't complain if multiple varargs are given" do
+      expect(reason(
+               subcommand_stack: %w[build],
+               args: %w[vehicle1 vehicle2 vehicle3]
+             )).to be_nil
+
+      expect(reason(
+               subcommand_stack: %w[move freeway-crash],
+               args: %w[vehicle1 vehicle2 vehicle3 vehicle4]
+             )).to be_nil
+    end
+
+    it "doesn't complain if an optional arg is not given" do
+      expect(reason(
+               subcommand_stack: %w[move crash],
+               args: %w[vehicle1]
+             )).to be_nil
+    end
+
+    it "doesn't complain if an optional arg is given" do
+      expect(reason(
+               subcommand_stack: %w[move crash],
+               args: %w[vehicle1 vehicle2]
+             )).to be_nil
+    end
+
+    it "complains if too many args are given" do
+      expect(reason(
+               subcommand_stack: %w[move crash],
+               args: %w[vehicle1 vehicle2 vehicle3]
+             )).to eq("got 3 args, must be between 1 and 2")
+    end
+
+    # TODO: test also in machine
+    it "complains if a mandatory flag is not given" do
+      expect(reason(
+               subcommand_stack: %w[sub-with-mandatory-flag]
+             )).to eq("missing required flag mandatory")
+    end
+
+    it "doesn't complain if a mandatory flag is given" do
+      expect(reason(
+               subcommand_stack: %w[sub-with-mandatory-flag],
+               flags: { "mandatory" => "foo" }
+             )).to be_nil
+    end
+  end
+
+  describe "#usage" do
+    it "uses UsageGenerator" do
+      state = { mode: :subcommand, args: [], flags: {}, subcommand_stack: %w[move go] }
+      expect(Tabry::UsageGenerator).to receive(:new) do |sub_stack, cmd|
+        expect(sub_stack.map(&:class)).to eq([Tabry::Models::Sub, Tabry::Models::Sub, Tabry::Models::Sub])
+        expect(cmd).to eq("vehicles")
+        instance_double(Tabry::UsageGenerator, usage: "foobar")
+      end
+      usage = described_class.new(config, Tabry::State.new(**state)).usage
+      expect(usage).to eq("foobar")
+    end
+
+    it "passes in passed-in command to UsageGenerator" do
+      state = { mode: :subcommand, args: [], flags: {}, subcommand_stack: %w[] }
+      expect(Tabry::UsageGenerator).to receive(:new) do |_sub_stack, cmd|
+        expect(cmd).to eq("customcmd")
+        instance_double(Tabry::UsageGenerator, usage: "foobar")
+      end
+      usage = described_class.new(config, Tabry::State.new(**state)).usage("customcmd")
+      expect(usage).to eq("foobar")
+    end
+  end
+
+  describe "#top_level?" do
+    context "there is a subcommand" do
+      let(:state) { Tabry::State.new(subcommand_stack: %w[move crash]) }
+
+      it { expect(subject.top_level?).to be(false) }
+    end
+
+    context "if there is no subcommand" do
+      let(:state) { Tabry::State.new(subcommand_stack: %w[], args: %w[foo]) }
+
+      it { expect(subject.top_level?).to be(true) }
+    end
+  end
+
+  describe "#help?" do
+    context "if help is true in the state" do
+      let(:state) { Tabry::State.new(subcommand_stack: %w[move crash], help: true) }
+
+      it { expect(subject.help?).to be(true) }
+    end
+
+    context "if help is absent/nil from the state" do
+      let(:state) { Tabry::State.new(subcommand_stack: %w[move crash]) }
+
+      it { expect(subject.help?).to be_falsey }
+    end
+  end
+
+  describe "#named_args" do
+    let(:state) do
+      Tabry::State.new(subcommand_stack: %w[move crash], args: %w[car bicycle])
+    end
+
+    it "returns a hash of all the named args" do
+      expect(subject.named_args).to eq(
+        "vehicle-type" => "car",
+        "crash-into-vehicle" => "bicycle"
+      )
+    end
+
+    context "with varargs" do
+      let(:state) { Tabry::State.new(subcommand_stack: %w[build], args: %w[car jeep moped]) }
+
+      it "puts the varargs in the hash as an array" do
+        expect(subject.named_args).to eq("vehicle-types" => %w[car jeep moped])
+      end
+    end
+
+    context "with optional, non-empty varargs" do
+      let(:state) do
+        Tabry::State.new(subcommand_stack: %w[move freeway-crash], args: %w[car jeep moped])
+      end
+
+      it "puts the varargs in the hash as an array" do
+        expect(subject.named_args).to eq(
+          "vehicle-type" => "car",
+          "crash-into-vehicles" => %w[jeep moped]
+        )
+      end
+    end
+
+    context "with empty optional varargs" do
+      let(:state) do
+        Tabry::State.new(subcommand_stack: %w[move freeway-crash], args: %w[car])
+      end
+
+      it "puts the varargs in the hash as an array" do
+        expect(subject.named_args).to eq(
+          "vehicle-type" => "car",
+          "crash-into-vehicles" => %w[]
+        )
+      end
+    end
+  end
+end

data/spec/tabry/runner_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/runner"
+
+describe Tabry::Runner do
+  subject do
+    described_class.new(config_name: "configname")
+  end
+
+  let(:config) { instance_double(Tabry::Models::Config) }
+  let(:state) { instance_double(Tabry::State) }
+
+  before do
+    allow(Tabry::ConfigLoader).to receive(:load).with(name: "configname").and_return(config)
+  end
+
+  describe "#parse" do
+    it "calls the machine and makes a result" do
+      expect(Tabry::Machine).to receive(:run).with(config, %w[foo bar]).and_return state
+      res = subject.parse(%w[foo bar])
+      expect(res).to be_a(Tabry::Result)
+      expect(res.state).to eq(state)
+      expect(res.config).to eq(config)
+    end
+  end
+
+  describe "#options" do
+    it "runs OptionsFinder" do
+      res = instance_double(Tabry::Result)
+      expect(subject).to receive(:parse).with(%w[foo bar]).and_return res
+      expect(Tabry::OptionsFinder).to receive(:options).with(res, "waz").and_return %w[a b c]
+      expect(subject.options(%w[foo bar], "waz")).to eq(%w[a b c])
+    end
+  end
+end

data/spec/tabry/usage_generator_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/usage_generator"
+require_relative "../../lib/tabry/config_loader"
+
+describe Tabry::UsageGenerator do
+  let(:config_fixture) { "#{__dir__}/../fixtures/vehicles.yaml" }
+  let(:config) { Tabry::ConfigLoader.load(name: config_fixture) }
+  let(:usage) do
+    str = described_class.new(config.dig_sub_array(sub_stack), config.cmd).usage
+    decolorified = str.gsub(/\e\[(\d+)m/, "")
+    decolorified
+  end
+
+  describe "args" do
+    let(:sub_stack) { %w[move crash] }
+
+    it "shows args" do
+      expect(usage).to match(/^ARGS.*^ *vehicle-type/m)
+    end
+
+    it "shows optional args and descriptions" do
+      expect(usage).to match(/^ *crash-into-vehicle \(optional\)\n^ *Crash into another vehicle/m)
+    end
+
+    it "shows args in the Usage line" do
+      expect(usage).to include "Usage: vehicles move crash <vehicle-type> [<crash-into-vehicle>]"
+    end
+  end
+
+  describe "varargs" do
+    let(:sub_stack) { %w[move freeway-crash] }
+
+    it "shows varargs with the title" do
+      expect(usage).to include \
+        "vehicles move freeway-crash <vehicle-type> [<vehicle to crash into> [<vehicle to crash into>...]]"
+    end
+  end
+
+  describe "subcommands" do
+    let(:sub_stack) { %w[move] }
+
+    it "lists subcommands" do
+      expect(usage).to match(/^SUBCOMMANDS.*^ *crash/m)
+    end
+
+    it "shows a subcommand alias" do
+      expect(usage).to include "go (alias: g)"
+    end
+
+    it "shows subcommand aliases" do
+      expect(usage).to include "freeway-crash (aliases: pileup, p)"
+    end
+  end
+
+  describe "flags" do
+    let(:sub_stack) { %w[move crash] }
+
+    it "shows flags with titles" do
+      expect(usage).to match(/^ *FLAGS.*^ *--dry-run.*Don't actually crash/m)
+    end
+
+    it "shows flags aliases and args" do
+      expect(usage).to include "--output-to-file, -f <arg>"
+    end
+  end
+end