tabry 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b1cb912ae500805787b62500d1c4995215bc9e3c8a4ccf32b7224bc4fa227c6
-  data.tar.gz: 68244bb100b3a262527b723b02fd6e73e9158f756bf44df960f8e5bd3d7e4679
+  metadata.gz: fe7c5c94f54f4d6fb603a73a8ec6b8364c63b6247a9dc3f095d4359fe96b5018
+  data.tar.gz: 4a29c24624360099c44dfd5c8c1420ef701bb21ee6535dc1e7a3540315002811
 SHA512:
-  metadata.gz: 0d6e9694ca66c39e5627eed4e8159ad95510ae1f146221529d068ca92c32d3e9d3d3208d7da59909467f2833fcf0a064735e49c75816e3b11741fe659bf8d92f
-  data.tar.gz: 0572051e1da3fa757609b2c5e956f745f434487e089268db318c1410f72e32a5bf906d4a4a4277cc23a40b77ed64ac8d41b1ebcb9fa0a78c0d0cff3c382c81f9
+  metadata.gz: b9b58e549801135afe35686048bd3b84b76c9e41cb5ecd5dc49bff3a1c3ea3ac26f10a2187eca5775ce4aa2d02d46157c559cefc2d376267ff62ebcf630b721c
+  data.tar.gz: a21e775881c48a511363cce6690e99cd13ccb32a3b829670bf049f3de63ab6e590b351a591717bb8137f112eb0e81514f548cefb8e3a0f4a79e5339118fafb33

data/bin/tabry-bash

@@ -8,27 +8,12 @@ require "shellwords"
 require "yaml"
 require_relative "../lib/tabry/util"
 require_relative "../lib/tabry/runner"
+require_relative "../lib/tabry/shell_splitter"
 
 # Bash-specific entrypoint, taking COMP_WORDS and COMP_CWORDS and returning possible options
 
-COMP_POINT_SENTINEL = "\uFFFF"
-
-# TODO: in weird scenarios this acts weird: namely, special shell operators like <(ls), $$((1 + 1))
-# Also it crashed on unbalanced quotes, like: foo "bar<TAB>
-# however, this will handle the common scenarios of escaping with quotes, single quotes, and backslashes
-# Split up args and put the argument that comp_point is in in the `last_arg` variable.
-# Just cutting off everything after comp_point might have worked, although
-# maybe we wanted the whole arg? Not sure this is the best.
 cmd_line, comp_point = ARGV
-cmd_line = cmd_line.dup
-cmd_line[comp_point.to_i...comp_point.to_i] = COMP_POINT_SENTINEL
-cmd, *all_args = Shellwords.split(cmd_line)
-last_arg_index = all_args.index { |arg| arg.include?(COMP_POINT_SENTINEL) }
-args = all_args[0..last_arg_index]
-last_arg = args.pop.gsub! COMP_POINT_SENTINEL, ""
-
-cmd_name = cmd.gsub(%r{.*/}, "")
-
+cmd_name, args, last_arg = Tabry::ShellSplitter.split(cmd_line, comp_point)
 opts = Tabry::Runner.new(config_name: cmd_name).options(args, last_arg)
 
 if Tabry::Util.debug?

data/lib/tabry/cli/base.rb

@@ -14,8 +14,11 @@ module Tabry
         @internals = internals
       end
 
-      def self.sub_route(prefix, cli_class)
-        (@sub_route_clis ||= {})[prefix.to_s] = cli_class
+      def self.sub_route(*prefixes, to:, **opts)
+        prefixes.map(&:to_s).each do |prefix|
+          (@sub_route_clis ||= {})[prefix] = to
+          (@sub_route_clis_opts ||= {})[prefix] = opts
+        end
       end
 
       def self.after_action(*method_names, only: nil, except: nil, &blk)

data/lib/tabry/cli/builder.rb

@@ -72,8 +72,12 @@ module Tabry
         sub_name, rest = met.split("__", 2)
 
         if sub_route_clis&.dig(sub_name)
+          # Instantiate CLI if it hasn't already (and store instantiation)
           sub_route_clis[sub_name] = instantiate_cli(sub_route_clis[sub_name], internals)
-          get_cli_object_and_met(sub_route_clis[sub_name], rest, internals)
+          opts = cli.class.instance_variable_get(:@sub_route_clis_opts)[sub_name]
+
+          new_met_name = opts[:full_method_name] ? met : rest
+          get_cli_object_and_met(sub_route_clis[sub_name], new_met_name, internals)
         else
           [cli, met]
         end

data/lib/tabry/cli/util.rb

@@ -9,8 +9,19 @@ module Tabry
       module_function
 
       def make_cmdline(cmdline, *args, echo: false, echo_only: false)
-        args = Array(args).flatten
-        cmdline = cmdline % args.map { |a| Shellwords.escape(a) }
+        # Allow to pass in an array, or varargs:
+        args = args.first if args.length == 1 && args.first.is_a?(Array)
+
+        args = args.map do |arg|
+          if arg.is_a?(Array)
+            # array of arguments get escaped separately and joined with strings (see specs)
+            arg.map { |a| Shellwords.escape(a) }.join(" ")
+          else
+            Shellwords.escape(arg)
+          end
+        end
+        cmdline = cmdline % args
+
         warn cmdline if echo || echo_only
         return nil if echo_only
 

data/lib/tabry/options_finder.rb

@@ -18,14 +18,18 @@ module Tabry
     def options(token)
       # Bit of a hack: send this down to autocomplete shell commands
       # TODO: set this only in ShellOption -- would require passing state down on thru
+      before_env = ENV.fetch("TABRY_AUTOCOMPLETE_STATE", nil)
       ENV["TABRY_AUTOCOMPLETE_STATE"] = {
         cmd: result.config.cmd,
         flags: result.state.flags,
         args: result.state.args,
+        current_token: token,
         current_flag: result.state.current_flag
       }.to_json
 
       send(:"options_#{state.mode}", token || "")
+    ensure
+      ENV["TABRY_AUTOCOMPLETE_STATE"] = before_env
     end
 
     private

data/lib/tabry/result.rb

@@ -35,7 +35,11 @@ module Tabry
 
     def wrong_number_of_args?
       n_args = state.args.length
-      if n_args == 0 && current_sub.subs.any?
+      # This could use some tweaking. I'm not at which point a subcommand
+      # should be considered to be invalid with no arguments... if it has a
+      # subcommand it's a good sign, but if it also has an optional argument
+      # that means it's OK. Probably need another "no_args" construct.
+      if n_args == 0 && current_sub.subs.any? && !(current_sub.args.any? && current_sub.min_args == 0)
         if current_sub.args.any?
           "missing subcommand or arg(s)"
         else

data/lib/tabry/shell_splitter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Use Shellwords.split() to split a command line + comp point (index of the
+# cursor in the command line) into the args up to the current token plus
+# current token
+module Tabry
+  module ShellSplitter
+    module_function
+
+    COMP_POINT_SENTINEL = "\uFFFF"
+
+    def split(cmd_line, comp_point)
+      # Returns [cmd_name, args, last_arg]
+      # cmd_name is the basename of the command run
+      #
+      # TODO: in weird scenarios this acts weird: namely, special shell operators like <(ls), $$((1 + 1))
+      # Also it crashed on unbalanced quotes, like: foo "bar<TAB>
+      # however, this will handle the common scenarios of escaping with quotes, single quotes, and backslashes
+      # Split up args and put the argument that comp_point is in in the `last_arg` variable.
+      # Just cutting off everything after comp_point might have worked, although
+      # maybe we wanted the whole arg? Not sure this is the best.
+      cmd_line = cmd_line.dup
+      cmd_line[comp_point.to_i...comp_point.to_i] = COMP_POINT_SENTINEL
+      cmd, *all_args = Shellwords.split(cmd_line)
+      last_arg_index = all_args.index { |arg| arg.include?(COMP_POINT_SENTINEL) }
+      args = all_args[0..last_arg_index]
+      last_arg = args.pop.gsub! COMP_POINT_SENTINEL, ""
+
+      cmd_name = cmd.gsub(%r{.*/}, "")
+
+      [cmd_name, args, last_arg]
+    end
+  end
+end

data/sh/fish/README.md

@@ -0,0 +1,16 @@
+This directory includes fish completions for Tabry
+
+There are two steps to add to your ~/.config/fish/config.fish to use:
+
+1. Source this file
+2. Add a call to `tabry_completion_init`, for each command
+
+```sh
+source tabry_fish.fish
+tabry_completion_init "aws"
+tabry_completion_init "rapture"
+```
+
+Note: Currently, the fish completion support doesn't distinguish between directory completion and file completion. The native fish complete command doesn't seem to support it (https://fishshell.com/docs/current/completions.html), so something custom would have to be written.
+
+Also note: the bash completion code can be used to create completely separate tabry bash functions for each tabry-based CLI, so multiple tabry-based CLIs can use distinct tabry versions. The fish completion does not yet support this (see sh/bash/README.md).

data/sh/fish/tabry_fish.fish

@@ -0,0 +1,95 @@
+
+function tabry_completion_init
+  # Three separate complete calls here are needed to support files.
+  # One provides completions in the case where tabry offers _only_ arguments,
+  # another provides completions where tabry offers _only_ files,
+  # the third handles the case where tabry offers both files and arguments
+  set cmd $argv[1]
+  complete -f -c "$cmd" -n "__fish_tabry_check_only_args" -a "(__fish_tabry_completions)"
+  complete -c "$cmd" -n "__fish_tabry_check_only_file"
+  complete -c "$cmd" -n "__fish_tabry_check_args_and_file" -a "(__fish_tabry_completions)"
+end
+
+# return true if tabry only reports commands
+function __fish_tabry_internal_invoke
+  set SCRIPT (status --current-filename)
+  set SCRIPT_DIR (dirname $SCRIPT)
+
+  # -C "Get cursor position"
+  set cursor_position (commandline -C)
+  set cmd (commandline)
+  set result ($SCRIPT_DIR/../../bin/tabry-bash "$cmd" "$cursor_position")
+  echo $result
+end
+
+# return true if tabry only reports file
+function __fish_tabry_check_only_args
+  set result (__fish_tabry_internal_invoke)
+
+  set args      (echo "$result"|sed 's/  .*//')
+  set specials  (echo "$result"|grep -o '  file')
+
+  # https://github.com/fish-shell/fish-shell/issues/5186#issuecomment-421244106
+  if test "x$args" != "x" -a "$specials" != "  file"
+    # echo "confirming only args:  [$result,$args,$specials]" 1>&2
+    return 0;
+  else
+    # echo "rejecting only args: [$result,$args,$specials]" 1>&2
+    return 1;
+  end
+end
+
+# return true if tabry reports file _and_ commands
+function __fish_tabry_check_only_file
+  set result (__fish_tabry_internal_invoke)
+
+  set args      (echo "$result"|sed 's/  .*//')
+
+  if test "x$args" = "x" -a (string match -ra '  file' $result)
+    # echo "confirming only file" 1>&2
+    return 0;
+  else
+    # echo "rejecting only file: [$args,$specials]" 1>&2
+    return 1;
+  end
+end
+
+function __fish_tabry_check_args_and_file
+  set result (__fish_tabry_internal_invoke)
+
+  set args      (echo "$result"|sed 's/  .*//')
+
+  if test "x$args" != "x" -a (string match -ra '  file' $result)
+    # echo "confirming args and file" 1>&2
+    return 0;
+  else
+    # echo "rejecting args and file: [$args,$specials]" 1>&2
+    return 1;
+  end
+end
+
+function __fish_tabry_completions
+  set result (__fish_tabry_internal_invoke)
+
+  set args      (echo "$result"|sed 's/  .*//')
+
+  set args_parsed (string split ' ' $args)
+
+  if test "x$args" = "x"
+    # Don't offer anything if we don't have any completions
+    return 1;
+  else
+    # $args_parsed will be something like: ["foo" "bar" "baz" "" "file"]
+    #   where "file" is special, since it's after the space.
+    for arg in $args_parsed
+      if test "x$arg" != "x"
+        echo "$arg"
+      else
+        break;
+      end
+    end
+
+    # echo $args
+    return 0;
+  end
+end

data/spec/fixtures/vehicles.tabry

@@ -45,6 +45,11 @@ sub sub-with-sub-or-arg {
   sub subsub
 }
 
+sub sub-with-sub-or-opt-arg{
+  sub subsub
+  opt arg
+}
+
 sub sub-with-mandatory-flag {
   opt arg { opts const (a b c) }
   reqd flagarg mandatory

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/lib/tabry/cli/util_spec.rb

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

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
@@ -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

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" => [
@@ -88,4 +88,40 @@ describe Tabry::OptionsFinder do
       expect(described_class.options(result, token)).to match_array expected_options
     end
   end
+
+  describe "TABRY_AUTOCOMPLETE_STATE" do
+    before { @env_before = ENV.fetch("TABRY_AUTOCOMPLETE_STATE", nil) }
+
+    after { ENV["TABRY_AUTOCOMPLETE_STATE"] = @env_before }
+
+    let(:state) do
+      {
+        mode: :flagarg, current_flag: "speed",
+        subcommand_stack: %w[move crash],
+        flags: {}, args: []
+      }
+    end
+    let(:result) { Tabry::Result.new(config, Tabry::State.new(state)) }
+    let(:flag) { config.dig_sub(%w[move crash]).flags["speed"] }
+
+    it "sets TABRY_AUTOCOMPLETE_STATE with information about the state" do
+      expect(flag.options).to receive(:options) do
+        expect(JSON.parse(ENV.fetch("TABRY_AUTOCOMPLETE_STATE", nil), symbolize_names: true)).to eq(
+          args: [],
+          cmd: "vehicles",
+          current_flag: "speed",
+          current_token: "abcd",
+          flags: {}
+        )
+      end
+
+      described_class.options(result, "abcd")
+    end
+
+    it "sets TABRY_AUTOCOMPLETE_STATE back to what it was before" do
+      ENV["TABRY_AUTOCOMPLETE_STATE"] = "foobar1234"
+      described_class.options(result, "foo")
+      expect(ENV.fetch("TABRY_AUTOCOMPLETE_STATE", nil)).to eq("foobar1234")
+    end
+  end
 end

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/shell_splitter_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/shell_splitter"
+
+describe Tabry::ShellSplitter do
+  describe ".split" do
+    it "returns the command basename, argument, and last argument" do
+      str = "foo/bar abc def ghi"
+      expect(described_class.split(str, 13)).to eq(["bar", ["abc"], "def"])
+    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"
+                                                                                                ])
+    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.3"
+  s.version     = "0.1.5"
   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.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Evan Battaglia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-25 00:00:00.000000000 Z
+date: 2022-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry-byebug
@@ -133,6 +133,7 @@ files:
 - lib/tabry/options_finder.rb
 - lib/tabry/result.rb
 - lib/tabry/runner.rb
+- lib/tabry/shell_splitter.rb
 - lib/tabry/shells/bash.rb
 - lib/tabry/state.rb
 - lib/tabry/usage_generator.rb
@@ -141,12 +142,15 @@ files:
 - sh/bash/tabry_bash.sh
 - sh/bash/tabry_bash_core.sh
 - sh/bash/tabry_bash_help.sh
+- sh/fish/README.md
+- sh/fish/tabry_fish.fish
 - spec/fixtures/basiccli.json
 - spec/fixtures/basiccli.tabry
 - spec/fixtures/basiccli2.tabry
 - spec/fixtures/basiccli2.yml
 - spec/fixtures/vehicles.tabry
 - spec/fixtures/vehicles.yaml
+- spec/lib/tabry/cli/util_spec.rb
 - spec/spec_helper.rb
 - spec/tabry/cli/arg_proxy_spec.rb
 - spec/tabry/cli/builder_spec.rb
@@ -163,6 +167,7 @@ files:
 - spec/tabry/options_finder_spec.rb
 - spec/tabry/result_spec.rb
 - spec/tabry/runner_spec.rb
+- spec/tabry/shell_splitter_spec.rb
 - spec/tabry/usage_generator_spec.rb
 - tabry.gemspec
 - treesitter/Cargo.toml
@@ -220,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Tab completion and CLIs extraordinaire