tabry 0.1.4 → 0.2.1

data/spec/fixtures/vehicles.yaml

@@ -101,6 +101,11 @@ main:
               value: z
       subs:
         - name: subsub
+    - name: sub-with-sub-or-opt-arg
+      subs:
+        - name: subsub
+      args:
+        - optional: true
     - name: sub-with-mandatory-flag
       args:
         - optional: true

data/spec/tabry/cli/all_in_one_spec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/tabry/cli/all_in_one"
+require_relative "../../../lib/tabry/shells/bash"
+require_relative "../../../lib/tabry/shells/bash/wrapper"
+
+module Tabry::Spec
+  module Cli
+    module AllInOneSpec
+      class << self
+        attr_accessor :log
+      end
+    end
+  end
+end
+
+describe Tabry::CLI::AllInOne do
+  before do
+    Tabry::Spec::Cli::AllInOneSpec.log = []
+    allow(Kernel).to receive(:exit).and_raise(StandardError.new("exit called"))
+  end
+
+  describe ".build" do
+    let(:cli) do
+      described_class.build do
+        config do
+          completion
+
+          cmd :abc
+
+          sub :foo do
+            arg :bar
+          end
+
+          sub :foo2 do
+            sub :bar2
+          end
+        end
+
+        Tabry::Spec::Cli::AllInOneSpec.log << :after_config
+
+        def foo
+          Tabry::Spec::Cli::AllInOneSpec.log << [:foo, args.bar]
+        end
+
+        def foo2__bar2
+          Tabry::Spec::Cli::AllInOneSpec.log << [:foo2__bar2]
+        end
+      end
+    end
+
+    it "creates a builder with CLI" do
+      expect(cli).to be_a(Tabry::CLI::Builder)
+      expect(cli.cli_class).to be_a(Class)
+      expect(cli.cli_class).to be < Tabry::CLI::Base
+    end
+
+    it "makes the config using the config block" do
+      conf = cli.runner.config
+      expect(conf).to be_a(Tabry::Models::Config)
+      expect(conf.main.subs.by_name.keys).to include("foo2")
+    end
+
+    it "makes a CLI with the methods in the block" do
+      cli.run(["foo", "bararg"])
+      expect(Tabry::Spec::Cli::AllInOneSpec.log).to eq [
+        :after_config,
+        [:foo, "bararg"],
+      ]
+    end
+
+    it "creates a #completion__bash method which generates completion" do
+      expect(Tabry::Shells::Bash).to receive(:generate_self).and_return("bash completion stuff")
+      expect_any_instance_of(Kernel).to receive(:puts).with("bash completion stuff")
+      cli.run(["completion", "bash"])
+    end
+
+    it "creates a #completion method which generates options" do
+      expect(Tabry::Bash::Wrapper).to receive(:run).with("cmd line", "6", config: instance_of(Tabry::Models::Config))
+      cli.run(["completion", "cmd line", "6"])
+    end
+
+    it "quits the block early after loading config and the subcommand to be run is #complete" do
+      allow(Tabry::Bash::Wrapper).to receive(:run)
+      expect(Tabry::Spec::Cli::AllInOneSpec.log).to eq([])
+    end
+
+    it "can take a config object passed in to config" do
+      conf = Tabry::ConfigBuilder.build { sub :bar }
+      cli = described_class.build do
+        config conf
+
+        def bar; end
+      end
+
+      expect(cli.runner.config).to eq(conf)
+    end
+  end
+
+  describe "#run" do
+    it "runs build and then runs the builder with ARGV" do
+      stub_const("ARGV", ["abc", "def"])
+      test_blk = proc { completion }
+      test_builder = instance_double(Tabry::CLI::Builder)
+      expect(described_class).to receive(:build) do |**kwargs, &blk|
+        expect(blk).to eql(test_blk)
+        expect(kwargs).to eq({ cli: "fake cli", config: "fake config" })
+        test_builder
+      end
+      expect(test_builder).to receive(:run).with(%w[abc def])
+      described_class.run(cli: "fake cli", config: "fake config", &test_blk)
+    end
+  end
+
+  describe "#completion_only" do
+    it "creates a #completion__bash method which generates completion" do
+      stub_const("ARGV", %w[completion bash])
+      expect(Tabry::Shells::Bash).to receive(:generate_self).with(cmd_name: "foo").and_return("bash completion stuff")
+      expect_any_instance_of(Kernel).to receive(:puts).with("bash completion stuff")
+
+      described_class.completion_only do
+        cmd :foo
+        sub :bar
+      end
+    end
+
+    it "creates a #completion method which generates options" do
+      stub_const("ARGV", ["completion", "cmd line", "6"])
+      expect(Tabry::Bash::Wrapper).to receive(:run) do |cmd_line, comp_point, config:|
+        expect(cmd_line).to eq("cmd line")
+        expect(comp_point).to eq("6")
+        expect(config.cmd).to eq("foo")
+        expect(config.main.subs.by_name.keys).to eq(["bar"])
+      end
+      described_class.completion_only do
+        cmd :foo
+        sub :bar
+      end
+    end
+  end
+end

data/spec/tabry/cli/arg_proxy_spec.rb

@@ -49,14 +49,14 @@ describe Tabry::CLI::ArgProxy do
     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(Kernel).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(Kernel).to receive(:exit).with(1)
       expect do
         args.reqd[3]
       end.to output(/FATAL: Missing required argument number 4/).to_stderr

data/spec/tabry/cli/builder_spec.rb

@@ -28,7 +28,33 @@ class Tabry::CLI::Builder
   end
 
   class TestCliFoo < Tabry::CLI::Base
-    sub_route :bar, TestCliFooBar
+    sub_route :bar, to: TestCliFooBar
+  end
+
+  class TestCli2 < Tabry::CLI::Base
+    class << self
+      attr_accessor :actions_run, :cli_object
+    end
+
+    after_action :my_after_action, except: :build2
+
+    def build2
+      self.class.actions_run << :build2
+    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
 
   class TestCli < Tabry::CLI::Base
@@ -37,9 +63,10 @@ class Tabry::CLI::Builder
     end
 
     before_action :my_before_action, only: :build
-    after_action :my_after_action, except: :build2
+    after_action :my_after_action
 
-    sub_route :foo, TestCliFoo
+    sub_route :foo, to: TestCliFoo
+    sub_route :sub, :build2, to: TestCli2, full_method_name: true
 
     def main
       self.class.actions_run << :main
@@ -49,18 +76,10 @@ class Tabry::CLI::Builder
       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
@@ -78,7 +97,7 @@ describe Tabry::CLI::Builder do
 
   before do
     runner = instance_double(Tabry::Runner)
-    allow(Tabry::Runner).to receive(:new).with(config_name: "theconfigname").and_return runner
+    allow(Tabry::Runner).to receive(:new).with(config: "theconfigname").and_return runner
     allow(runner).to receive(:parse).with(%w[the raw args]).and_return result
   end
 
@@ -99,7 +118,8 @@ describe Tabry::CLI::Builder do
   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(:cli_class2) { Tabry::CLI::Builder::TestCli2 }
+  let(:cli_class_foo_bar) { Tabry::CLI::Builder::TestCliFooBar }
   let(:actions_run) { cli_class.actions_run }
   let(:cli_object) { cli_class.cli_object }
 
@@ -108,6 +128,8 @@ describe Tabry::CLI::Builder do
     cli_class.cli_object = nil
     cli_class2.actions_run = []
     cli_class2.cli_object = nil
+    cli_class_foo_bar.actions_run = []
+    cli_class_foo_bar.cli_object = nil
   end
 
   describe "successful runs" do
@@ -132,7 +154,7 @@ describe Tabry::CLI::Builder do
     describe "except on actions" do
       let(:state) { { subcommand_stack: %w[build2] } }
 
-      it { expect(actions_run).to eq %i[build2] }
+      it { expect(cli_class2.actions_run).to eq %i[build2] }
     end
 
     describe "handling multiple levels of subcommand routing" do
@@ -143,14 +165,23 @@ describe Tabry::CLI::Builder do
       end
 
       it "maps to the sub-CLI" do
-        expect(cli_class2.actions_run).to eq(%i[before_action waz])
+        expect(cli_class_foo_bar.actions_run).to eq(%i[before_action waz])
+      end
+    end
+
+    describe "subcommand routing with full_method_name: true" do
+      let(:state) { { subcommand_stack: %i[sub sub_sub] } }
+
+      it "preserves the full method name" do
+        expect(cli_class.actions_run).to eq(%i[])
+        expect(cli_class2.actions_run).to eq(%i[sub__sub_sub after_action])
       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]) }
+      it { expect(cli_class_foo_bar.actions_run).to eq(%i[before_action main]) }
     end
 
     describe "providing an ArgProxy in TestCLI#args" do
@@ -184,7 +215,7 @@ describe Tabry::CLI::Builder do
 
       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(Kernel).to receive(:exit).with(1)
         expect do
           subject
         end.to output(
@@ -198,7 +229,7 @@ describe Tabry::CLI::Builder do
 
       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(Kernel).to receive(:exit).with(0)
         expect { subject }.to output(/example command usage/).to_stdout
       end
     end
@@ -208,7 +239,7 @@ describe Tabry::CLI::Builder 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(Kernel).to receive(:exit).with(1)
           expect { subject }.to output(/FATAL: CLI does not support command wombat/).to_stderr
         end
       end
@@ -217,7 +248,7 @@ describe Tabry::CLI::Builder do
         let(:state) { { subcommand_stack: %w[foo] } }
 
         it "quits and shows an error" do
-          expect(builder).to receive(:exit).with(1)
+          expect(Kernel).to receive(:exit).with(1)
           expect { subject }.to output(/FATAL: CLI does not support command main/).to_stderr
         end
       end

data/spec/tabry/cli/util_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/tabry/cli/util"
+
+describe Tabry::CLI::Util do
+  describe ".make_cmdline" do
+    it "escapes a single string" do
+      expect(described_class.make_cmdline(
+               "hello %s", "world;abc"
+             )).to eq(
+               "hello world\\;abc"
+             )
+    end
+
+    it "escapes multiple string arguments" do
+      expect(described_class.make_cmdline(
+               "hello %s hi %s", "world;abc", "def;ghi"
+             )).to eq(
+               "hello world\\;abc hi def\\;ghi"
+             )
+    end
+
+    it "escapes array arguments" do
+      # args is an array of strings and arrays
+      expect(described_class.make_cmdline(
+               "hello %s hi %s", "world;abc", ["foo;bar", "waz;ok"]
+             )).to eq(
+               "hello world\\;abc hi foo\\;bar waz\\;ok"
+             )
+    end
+
+    it "treats a single array of strings as a list of args, not as one array arg" do
+      # args is an array with one array of strings
+      # an improvement might be to figure out how
+      # many '%s's there are in the cmdline
+      expect(described_class.make_cmdline(
+               "hello %s hi %s", ["world;abc", "foo;bar"]
+             )).to eq(
+               "hello world\\;abc hi foo\\;bar"
+             )
+    end
+
+    it "escapes arrays if given one array of mixed strings and arrays" do
+      expect(described_class.make_cmdline(
+               "hello %s hi %s", [["world;abc", "foo;bar"], "waz;ok"]
+             )).to eq(
+               "hello world\\;abc foo\\;bar hi waz\\;ok"
+             )
+    end
+
+    it "can send a single array argument by wrapping in an array" do
+      # args is an array with one array of one array
+      expect(described_class.make_cmdline(
+               "hello %s hi", [["foo;bar", "waz;ok"]]
+             )).to eq(
+               "hello foo\\;bar waz\\;ok hi"
+             )
+    end
+
+    it "can merge_stderr" do
+      expect(described_class.make_cmdline(
+               "echo %s | cat", "a", merge_stderr: true
+             )).to eq(
+               "{ echo a | cat ;} 2>&1"
+             )
+    end
+  end
+
+  describe "open_web_page" do
+    it 'uses "xdg-open" when on Linux' do
+      stub_const("RUBY_PLATFORM", "x86_64-linux")
+      expect(Kernel).to receive("system") do |cmdline|
+        expect(cmdline).to include("(xdg-open ")
+      end
+      described_class.open_web_page("http://example.com")
+    end
+
+    it 'uses "open" when on Darwin' do
+      stub_const("RUBY_PLATFORM", "x86_64-darwin")
+      expect(Kernel).to receive("system") do |cmdline|
+        expect(cmdline).to include("(open ")
+      end
+      described_class.open_web_page("http://example.com")
+    end
+  end
+
+  describe "backtick_or_die" do
+    before do
+      allow(Kernel).to receive(:exit)
+      allow(Kernel).to receive(:warn)
+    end
+
+    context "when the command returns a non-zero status code" do
+      before do
+        described_class.backtick_or_die("echo abc && echo def && echo ghi && false")
+      end
+
+      it "prints out the output" do
+        expect(Kernel).to have_received(:warn).with(
+          a_string_including("\ndef\n")
+        )
+      end
+
+      it "exits with a non-zero status code" do
+        expect(Kernel).to have_received(:exit).with(1)
+      end
+    end
+
+    context "when the command does not exist" do
+      before do
+        described_class.backtick_or_die("theresnowayanyonehasthiscommandinstalled-randomstuff-2390832190832jk4398190fdlksjhfdsalkjlkfdsaj43098432908fd")
+      end
+
+      it "exits with a non-zero status code" do
+        expect(Kernel).to have_received(:exit).with(1)
+      end
+
+      it "says that the command does not exist" do
+        expect(Kernel).to have_received(:warn).with(
+          a_string_including("command does not exist")
+        )
+      end
+    end
+  end
+end

data/spec/tabry/config_builder_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require_relative "../../lib/tabry/config_builder"
+
+describe Tabry::ConfigBuilder do
+  def sort_nested_hashes(object)
+    case object
+    when Hash
+      object.sort_by { |key, _val| key }.to_h.transform_values { |val| sort_nested_hashes(val) }
+    when Array
+      object.map { |val| sort_nested_hashes(val) }
+    else
+      object
+    end
+  end
+
+  %w[Args Defs Flags Subs Underscoresdashes].each do |fixture|
+    context "#{fixture} test fixture" do
+      it "matches what would be produced by the equivalent (old tabry language) tabry file" do
+        require_relative "../fixtures/config_builder/#{fixture.downcase}"
+        actual = Tabry::Spec::Fixtures::ConfigBuilder.const_get(fixture.to_sym)._raw
+        expected = YAML.load_file(File.expand_path("../fixtures/config_builder/#{fixture.downcase}.yml", __dir__))
+
+        actual = JSON.pretty_generate(sort_nested_hashes(actual))
+        expected = JSON.pretty_generate(sort_nested_hashes(expected))
+
+        expect(actual).to eql(expected)
+      end
+    end
+  end
+
+  it "defines a 'completion' shortcut with 'completion' and 'completion__bash' subs" do
+    config = described_class.build do
+      completion
+    end
+
+    expect(config._raw.dig("main", "subs")).to eq(
+      [
+        {
+          "description" => "Get tab completion shell config",
+          "name" => "completion",
+          "args" => [
+            {
+              "description" => "(for internal usage, when used instead of subcommand) full command line for getting completion options",
+              "name" => "cmd_line"
+            },
+            {
+              "description" => "(for internal usage, when used instead of subcommand) comp point",
+              "name" => "comp_point"
+            }
+          ],
+          "subs" => [
+            {
+              "description" => "Get tab completion for bash or zsh",
+              "name" => "bash"
+            }
+          ]
+        }
+      ]
+    )
+  end
+end

data/spec/tabry/config_loader_spec.rb

@@ -17,7 +17,7 @@ describe Tabry::ConfigLoader 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]
+      %w[build list-vehicles move sub-with-sub-or-arg sub-with-sub-or-opt-arg sub-with-mandatory-flag]
     )
   end
 
@@ -27,7 +27,7 @@ describe Tabry::ConfigLoader do
     it "looks for yaml files in directories 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]
+        %w[build list-vehicles move sub-with-sub-or-arg sub-with-sub-or-opt-arg sub-with-mandatory-flag]
       )
     end
 

data/spec/tabry/options_finder_spec.rb

@@ -12,7 +12,7 @@ describe Tabry::OptionsFinder do
 
   examples = {
     "lists possible subcommands of the main command" => [
-      %w[build list-vehicles move sub-with-sub-or-arg sub-with-mandatory-flag],
+      %w[build list-vehicles move sub-with-sub-or-arg sub-with-sub-or-opt-arg sub-with-mandatory-flag],
       {}
     ],
     "lists possible subcommands of a subcommand" => [

data/spec/tabry/result_spec.rb

@@ -70,6 +70,10 @@ describe Tabry::Result do
              )).to be_nil
     end
 
+    it "doesn't complain if given no args to a subcommand with subcommands and optional args" do
+      expect(reason(subcommand_stack: %w[sub-with-sub-or-opt-arg])).to be_nil
+    end
+
     it "complains if mandatory varargs are not given" do
       expect(reason(
                subcommand_stack: %w[build]

data/spec/tabry/runner_spec.rb

@@ -4,7 +4,7 @@ require_relative "../../lib/tabry/runner"
 
 describe Tabry::Runner do
   subject do
-    described_class.new(config_name: "configname")
+    described_class.new(config: "configname")
   end
 
   let(:config) { instance_double(Tabry::Models::Config) }

data/spec/tabry/shell_splitter_spec.rb

@@ -3,18 +3,20 @@
 require_relative "../../lib/tabry/shell_splitter"
 
 describe Tabry::ShellSplitter do
-  describe '.split' do
+  describe ".split" do
     it "returns the command basename, argument, and last argument" do
-      str = 'foo/bar abc def ghi'
+      str = "foo/bar abc def ghi"
       expect(described_class.split(str, 13)).to eq(["bar", ["abc"], "def"])
     end
 
-    it "it handles quotes and backslashes like a shell" do
-      expect(described_class.split('"/foo bar/waz" a\'b \'c\\ d "ef g" "hi jk" lmn', 38)).to eq([
-        "waz",
-        ["ab c d", "ef g"],
-        "hi jk"
-      ])
+    it "handles quotes and backslashes like a shell" do
+      expect(described_class.split('"/foo bar/waz" a\'b \'c\\ d "ef g" "hi jk" lmn', 38)).to eq(
+        [
+          "waz",
+          ["ab c d", "ef g"],
+          "hi jk"
+        ]
+      )
     end
   end
 end

data/spec/tabry/shells/bash_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/tabry/shells/bash"
+
+describe Tabry::Shells::Bash do
+  describe ".generate_self" do
+    before { @backup, $0 = $0, "/bla/waz/abc" }
+    after { $0 = @backup }
+
+    it "tells bash to use the currently running command plus 'completion' to get completion options" do
+      expect(described_class.generate_self).to match(
+        %r{^ *TABRY_IMPORTS_PATH='' _tabry_ABC_completions_internal /bla/waz/abc completion$}
+      )
+    end
+
+    it "uses the cmd_name given for the command name for bash's 'complete'" do
+      result = described_class.generate_self
+      expect(result).to include("\ncomplete -F _tabry_ABC_completions abc\n")
+    end
+
+    it "defaults cmd_name to the basename of the currently running command" do
+      result = described_class.generate_self(cmd_name: 'wombat')
+      expect(result).to match(
+        %r{^ *TABRY_IMPORTS_PATH='' _tabry_WOMBAT_completions_internal /bla/waz/abc completion$}
+      )
+      expect(result).to include("\ncomplete -F _tabry_WOMBAT_completions wombat\n")
+    end
+  end
+
+  describe '.generate' do
+    it 'tells bash to use tabry-bash with a import path to get completion options' do
+      result = described_class.generate("my-cmd", "/path/to/mycmd.tabry")
+      expect(result).to include("TABRY_IMPORTS_PATH=/path/to/mycmd.tabry _tabry_MY_CMD_completions_internal /home/evan/dev/tabry/bin/tabry-bash \n")
+      expect(result).to include("complete -F _tabry_MY_CMD_completions my-cmd\n")
+    end
+
+    it "takes a uniq_fn_id parameter to override the default function names" do
+      result = described_class.generate("my-cmd", "/path/to/mycmd.tabry", uniq_fn_id: "my cmd tabryv0.2.0")
+      expect(result).to include("TABRY_IMPORTS_PATH=/path/to/mycmd.tabry _tabry_MY_CMD_TABRYV0_2_0_completions_internal /home/evan/dev/tabry/bin/tabry-bash \n")
+      expect(result).to include("complete -F _tabry_MY_CMD_TABRYV0_2_0_completions my-cmd\n")
+      expect(result).to include("_tabry_MY_CMD_TABRYV0_2_0_completions_internal()")
+    end
+  end
+end

data/tabry.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name        = "tabry"
-  s.version     = "0.1.4"
+  s.version     = "0.2.1"
   s.summary     = "Tab completion and CLIs extraordinaire"
   s.authors     = ["Evan Battaglia"]
   s.email       = "battaglia.evan@gmail.com"