tabry 0.1.5 → 0.2.2

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

@@ -97,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
 
@@ -215,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(
@@ -229,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
@@ -239,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
@@ -248,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/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

@@ -10,11 +10,13 @@ describe Tabry::ShellSplitter do
     end
 
     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"
-                                                                                                ])
+      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.5"
+  s.version     = "0.2.2"
   s.summary     = "Tab completion and CLIs extraordinaire"
   s.authors     = ["Evan Battaglia"]
   s.email       = "battaglia.evan@gmail.com"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tabry
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.2
 platform: ruby
 authors:
 - Evan Battaglia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-21 00:00:00.000000000 Z
+date: 2023-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry-byebug
@@ -84,6 +84,7 @@ description:
 email: battaglia.evan@gmail.com
 executables:
 - tabry-bash
+- tabry-generate-bash-complete
 - tabry-help
 - tabry-test-options
 - tabry-test-parse
@@ -91,9 +92,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/tabry-bash
+- bin/tabry-generate-bash-complete
 - bin/tabry-help
 - bin/tabry-test-options
 - bin/tabry-test-parse
+- lib/tabry/cli/all_in_one.rb
 - lib/tabry/cli/arg_proxy.rb
 - lib/tabry/cli/base.rb
 - lib/tabry/cli/builder.rb
@@ -101,6 +104,12 @@ files:
 - lib/tabry/cli/internals.rb
 - lib/tabry/cli/util.rb
 - lib/tabry/cli/util/config.rb
+- lib/tabry/config_builder.rb
+- lib/tabry/config_builder/arg_or_flag_builder.rb
+- lib/tabry/config_builder/flagarg_builder.rb
+- lib/tabry/config_builder/generic_builder.rb
+- lib/tabry/config_builder/sub_builder.rb
+- lib/tabry/config_builder/top_level_builder.rb
 - lib/tabry/config_loader.rb
 - lib/tabry/core_ext/string/colors.rb
 - lib/tabry/machine.rb
@@ -135,6 +144,7 @@ files:
 - lib/tabry/runner.rb
 - lib/tabry/shell_splitter.rb
 - lib/tabry/shells/bash.rb
+- lib/tabry/shells/bash/wrapper.rb
 - lib/tabry/state.rb
 - lib/tabry/usage_generator.rb
 - lib/tabry/util.rb
@@ -148,12 +158,29 @@ files:
 - spec/fixtures/basiccli.tabry
 - spec/fixtures/basiccli2.tabry
 - spec/fixtures/basiccli2.yml
+- spec/fixtures/config_builder/args.rb
+- spec/fixtures/config_builder/args.tabry
+- spec/fixtures/config_builder/args.yml
+- spec/fixtures/config_builder/defs.rb
+- spec/fixtures/config_builder/defs.tabry
+- spec/fixtures/config_builder/defs.yml
+- spec/fixtures/config_builder/flags.rb
+- spec/fixtures/config_builder/flags.tabry
+- spec/fixtures/config_builder/flags.yml
+- spec/fixtures/config_builder/subs.rb
+- spec/fixtures/config_builder/subs.tabry
+- spec/fixtures/config_builder/subs.yml
+- spec/fixtures/config_builder/underscoresdashes.rb
+- spec/fixtures/config_builder/underscoresdashes.tabry
+- spec/fixtures/config_builder/underscoresdashes.yml
 - spec/fixtures/vehicles.tabry
 - spec/fixtures/vehicles.yaml
-- spec/lib/tabry/cli/util_spec.rb
 - spec/spec_helper.rb
+- spec/tabry/cli/all_in_one_spec.rb
 - spec/tabry/cli/arg_proxy_spec.rb
 - spec/tabry/cli/builder_spec.rb
+- spec/tabry/cli/util_spec.rb
+- spec/tabry/config_builder_spec.rb
 - spec/tabry/config_loader_spec.rb
 - spec/tabry/machine_spec.rb
 - spec/tabry/models/args_list_spec.rb
@@ -168,6 +195,7 @@ files:
 - spec/tabry/result_spec.rb
 - spec/tabry/runner_spec.rb
 - spec/tabry/shell_splitter_spec.rb
+- spec/tabry/shells/bash_spec.rb
 - spec/tabry/usage_generator_spec.rb
 - tabry.gemspec
 - treesitter/Cargo.toml

data/spec/lib/tabry/cli/util_spec.rb

@@ -1,60 +0,0 @@
-# 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
-  end
-end