tabry 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a76bb8b85fa94e61bf625e435711d8e3385f5aa50a87a7c410e4f252947ffea
-  data.tar.gz: '0632896bf92ca8b57a08db3b153e32aed0da12c71d9604d7260de2fba6fc9707'
+  metadata.gz: 87fa1708b1efb9ef81588017419bb6c63455ee786870f882783cf59f22ea462b
+  data.tar.gz: f0822419f2a36d48148cf7cf0ecdbd195666e2c5fe284d2e8dd6a563976c0842
 SHA512:
-  metadata.gz: 8420bd16657ebbe6e2f13c55a14e62fffab982b5d81f71d76c36ccdd97d36ee4a09ce7ccf1386c5b0b553681b48d7b3fdd90336fb72574d55ba426ca22200ed9
-  data.tar.gz: 1dcd973c7608319c73ae59ab8c516e0ccb54ec9c6bf909f13235e3be238e1059e93d2ba067d99a66b8de8fb5cca9c69e2cf861b1393aecbd9076580fbbdef37c
+  metadata.gz: de752dc58cefc4cc1caed94a4f0ae34758fdb40a9973f48ed5471b17fef517b0eecfbfd7e3735179793cce8d16d739d2cb2fe6d833c3f765f5c57e353dac1b7a
+  data.tar.gz: 3e26e31d951fbc7f076b3c6e5b2c96eccfd1287c5469f84447ec549dc6aca51746dc193cbed36276b2e81dab67ce2bee8204cc0e8bb6b4010a07b284bac75f32

data/bin/tabry-fish

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run by the tabry_fish.sh fish tab completion function to plug into Tabry
+# to get completion options.
+# Fish-specific entrypoint
+
+require_relative "../lib/tabry/shells/fish/wrapper"
+Tabry::Fish::Wrapper.run(*ARGV)

data/bin/tabry-generate-fish-complete

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/tabry/cli/all_in_one"
+require_relative "../lib/tabry/shells/fish"
+
+Tabry::CLI::AllInOne.run do
+  config(names_underscores_to_dashes: true) do
+    desc <<~DESC
+      Generates fish completion for the tabry relative to this script
+      for the given command name and tabry JSON/YML file. Generates
+      fish functions unique to the command name to avoid conflicting with
+      other potential tabry installations.
+    DESC
+    arg :command_name, "Name of the command, e.g. 'mycli'"
+    arg :tabry_json_path, "Path to the mycli.json or mycli.yml compiled tabry file"
+    flagarg "uniq-fn-id,i", <<~DESC
+      Unique identifier to use for the unique tabry completion bash functions
+      (default is the capitalized command name)
+    DESC
+  end
+
+  def main
+    puts Tabry::Shells::Fish.generate(
+      args.command_name,
+      args.tabry_json_path,
+      uniq_fn_id: flags.uniq_fn_id,
+    )
+  end
+end
+
+

data/lib/tabry/cli/all_in_one.rb

@@ -25,7 +25,7 @@ module Tabry
 
           # Hack to avoid processing block any more if only running completion
           # That way you an have expensive requires after the include
-          if (ARGV.first == "completion") && ARGV.length == 3 && ARGV[2].to_s =~ /^[0-9]+$/
+          if ((ARGV.first == "completion")) && ARGV.length == 3 && ARGV[2].to_s =~ /^[0-9]+$/
             throw :run_completion, true
           end
         end
@@ -45,14 +45,26 @@ module Tabry
 
       def self.define_completion_methods(cli_class, config, cmd_name: nil)
         cli_class.module_eval do
+
           define_method :completion__bash do
             require_relative "../shells/bash"
             Kernel.puts Tabry::Shells::Bash.generate_self(cmd_name: cmd_name)
           end
 
+          define_method :completion__fish do
+            require_relative "../shells/fish"
+            Kernel.puts Tabry::Shells::Fish.generate_self(cmd_name: cmd_name)
+          end
+
           define_method :completion do
-            require_relative "../shells/bash/wrapper"
-            Tabry::Bash::Wrapper.run(args.cmd_line, args.comp_point, config: config)
+            fish_mode = ENV.fetch("TABRY_FISH_MODE", false)
+            if fish_mode
+              require_relative "../shells/fish/wrapper"
+              Tabry::Fish::Wrapper.run(args.cmd_line, args.comp_point, config: config)
+            else
+              require_relative "../shells/bash/wrapper"
+              Tabry::Bash::Wrapper.run(args.cmd_line, args.comp_point, config: config)
+            end
           end
         end
       end
@@ -77,13 +89,22 @@ module Tabry
         # If we recognize command is going to be a completion command, fast track and
         # run completion now
         if run_completion
-          require_relative "../shells/bash/wrapper"
-          Tabry::Bash::Wrapper.run(ARGV[1], ARGV[2], config: config)
+          if ARGV.first == "completion"
+            fish_mode = ENV.fetch("TABRY_FISH_MODE", false)
+            if fish_mode
+              require_relative "../shells/fish/wrapper"
+              Tabry::Fish::Wrapper.run(ARGV[1], ARGV[2], config: config)
+            else
+              require_relative "../shells/bash/wrapper"
+              Tabry::Bash::Wrapper.run(ARGV[1], ARGV[2], config: config)
+            end
+            exit
+          end
         end
 
         # If we recognize there is a "completion" subcommand, add completion
         # methods -- if not already defined by caller in the block
-        if config.main.subs.by_name["completion"] && !cli.instance_methods.include?(:completion__bash)
+        if config.main.subs.by_name["completion"] && !cli.instance_methods.include?(:completion__bash) && !cli.instance_methods.include?(:completion__fish)
           define_completion_methods(cli, config)
         end
 

data/lib/tabry/config_builder/arg_or_flag_builder.rb

@@ -21,6 +21,11 @@ module Tabry
         [{ "type" => "shell", "value" => cmd.to_s }]
       end
 
+      # maybe I should rename this ... and include... ?
+      def method(met_name)
+        [{ "type" => "method", "value" => met_name.to_s }]
+      end
+
       def file
         [{ "type" => "file" }]
       end

data/lib/tabry/config_builder/top_level_builder.rb

@@ -10,11 +10,13 @@ module Tabry
 
       def defargs(name, &blk)
         name = name.to_s.gsub(/^@/, "")
+        name = name.gsub("_", "-") if _opts[:names_underscores_to_dashes]
         _set_hash :arg_includes, name, _build(SubBuilder, &blk)
       end
 
       def defopts(name, &blk)
         name = name.to_s.gsub(/^@/, "")
+        name = name.gsub("_", "-") if _opts[:names_underscores_to_dashes]
         _set_hash :option_includes, name, _build(ArgOrFlagBuilder, &blk)["options"]
       end
 
@@ -22,6 +24,7 @@ module Tabry
         sub :completion do
           desc "Get tab completion shell config"
           sub :bash, "Get tab completion for bash or zsh"
+          sub :fish, "Get tab completion for fish"
           arg :cmd_line, "(for internal usage, when used instead of subcommand) full command line for getting completion options"
           arg :comp_point, "(for internal usage, when used instead of subcommand) comp point"
         end

data/lib/tabry/machine.rb

@@ -20,7 +20,7 @@ module Tabry
 
     def initialize(config)
       @config = config
-      @state = State.new(mode: :subcommand, subcommand_stack: [], args: [], flags: {})
+      @state = State.new(mode: :subcommand, subcommand_stack: [], args: [], flags: {}, help: false, dashdash: false)
     end
 
     def run(tokens)

data/lib/tabry/models/const_option.rb

@@ -5,7 +5,7 @@ require_relative "option_base"
 module Tabry
   module Models
     class ConstOption < OptionBase
-      def options(token)
+      def options(token, _params)
         if value.start_with?(token)
           [value]
         else

data/lib/tabry/models/flags_list.rb

@@ -16,10 +16,14 @@ module Tabry
         end
       end
 
-      def options(token, used:)
+      def options(token, used:, params:)
         to_a.map do |flag|
           if token&.start_with?("-") && flag.name_with_dashes.start_with?(token) && !used[flag.name]
-            flag.name_with_dashes
+            if params[:descriptions]
+              [flag.name_with_dashes, flag.description]
+            else
+              flag.name_with_dashes
+            end
           end
         end.compact
       end

data/lib/tabry/models/include_option.rb

@@ -7,8 +7,8 @@ module Tabry
     class IncludeOption < OptionBase
       attr_reader :include_name, :_root
 
-      def options(token)
-        flatten.options(token)
+      def options(token, params)
+        flatten.options(token, params)
       end
 
       def flatten

data/lib/tabry/models/method_option.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "option_base"
+
+module Tabry
+  module Models
+    class MethodOption < OptionBase
+      # TODO: Handled upstream for now, could change later.
+      def options(_token, _params)
+        [value.to_sym]
+      end
+    end
+  end
+end

data/lib/tabry/models/option.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "config_error"
-require_relative "const_option"
-require_relative "shell_option"
-require_relative "include_option"
-require_relative "file_option"
-require_relative "dir_option"
+%w[const shell include file dir method].each do |type|
+  require_relative "#{type}_option"
+end
 
 module Tabry
   module Models
@@ -18,6 +16,8 @@ module Tabry
           ConstOption.new(**args)
         when "shell"
           ShellOption.new(**args)
+        when "method"
+          MethodOption.new(**args)
         when "include"
           IncludeOption.new(**args)
         when "file"

data/lib/tabry/models/options_list.rb

@@ -10,8 +10,8 @@ module Tabry
         super(**args, klass: Option)
       end
 
-      def options(token)
-        to_a.map { |option| option.options(token) }.inject(&:|)
+      def options(token, params)
+        to_a.map { |option| option.options(token, params) }.inject(&:|)
       end
     end
   end

data/lib/tabry/models/shell_option.rb

@@ -5,7 +5,7 @@ require_relative "option_base"
 module Tabry
   module Models
     class ShellOption < OptionBase
-      def options(token)
+      def options(token, _params)
         `#{value}`.chomp.split("\n").select { |opt| opt.start_with?(token) }
       end
     end

data/lib/tabry/models/subs_list.rb

@@ -20,9 +20,20 @@ module Tabry
         end
       end
 
-      def options(token)
-        to_a.map(&:name).select { |name| name.start_with?(token) }
+      def options(token, params)
+        ::Tabry::Util.debug "checking:::: #{token}"
+        to_a
+          .select { |sub| sub.name.start_with?(token) }
+          .map do |sub|
+            if params[:descriptions]
+              [sub.name, sub.description]
+            else
+              sub.name
+            end
+          end
+          .compact
       end
+
     end
   end
 end

data/lib/tabry/options_finder.rb

@@ -4,15 +4,16 @@ require "json"
 
 module Tabry
   class OptionsFinder
-    attr_reader :result
+    attr_reader :result, :params
 
     # Returns an array of options
-    def self.options(result, token)
-      new(result).options(token)
+    def self.options(result, token, params)
+      new(result, params).options(token)
     end
 
-    def initialize(result)
+    def initialize(result, params)
       @result = result
+      @params = params
     end
 
     def options(token)
@@ -59,7 +60,7 @@ module Tabry
 
     def options_flagarg(token)
       result.sub_stack.map do |sub|
-        sub.flags[state.current_flag]&.options&.options(token)
+        sub.flags[state.current_flag]&.options&.options(token, params)
       end.compact.flatten.uniq
     end
 
@@ -68,14 +69,18 @@ module Tabry
         # once an arg has been given, can no longer use a subcommand
         []
       else
-        current_sub.subs.options(token)
+        current_sub.subs.options(token, params)
       end
     end
 
     def options_subcommand_flags(token)
       return [] if state.dashdash
 
-      result.sub_stack.map { |sub| sub.flags.options(token, used: state.flags) }.flatten.uniq
+      result
+        .sub_stack
+        .map { |sub| sub.flags.options(token, used: state.flags, params: params) }
+        .flatten(1)
+        .uniq
     end
 
     def options_subcommand_args(token)
@@ -85,7 +90,7 @@ module Tabry
               current_sub.args[state.args.length]
             end
 
-      arg&.options&.options(token) || []
+      arg&.options&.options(token, params) || []
     end
   end
 end

data/lib/tabry/replty/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../cli/arg_proxy" # TODO: shared code now, probably move out of cli dir
+require_relative "../cli/flag_proxy" # TODO: shared code now, probably move out of cli dir
+
+module Tabry
+  module Replty
+    class Base
+      attr_reader :internals, :args, :flags
+
+      def internals=(internals)
+        @internals = internals
+        @args = ::Tabry::CLI::ArgProxy.new(internals.state.args, internals.result.named_args)
+        @flags = ::Tabry::CLI::FlagProxy.new(internals.state.flags)
+      end
+
+      # NOTE: internal functions (besides internal/args/flags) start with "tabry_"; reconsider scheme
+      def tabry_prompt
+        "> "
+      end
+    end
+  end
+end

data/lib/tabry/replty/builder.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "readline"
+require_relative "../cli/internals" # TODO: bring out of cli if shared code now, probably
+require_relative "../shell_tokenizer"
+require_relative "../runner"
+
+module Tabry
+  module Replty
+    class Builder
+      attr_reader :runner, :repl
+
+      # TODO: implement before_action, after_action, sub-REPLs; share code in run_result with CLI::Builder
+
+      def initialize(config, repl)
+        @runner = Tabry::Runner.new(config: config)
+        @repl = repl
+      end
+
+      def readline
+        Readline.readline(repl.tabry_prompt, true)
+      rescue Interrupt
+        puts "^C"
+        retry
+      end
+
+      def load_history(file)
+        return unless file
+
+        File.open(file) do |f|
+          f.each do |l|
+            Readline::HISTORY.push l.chomp
+          end
+        end
+      rescue Errno::ENOENT # rubocop:disable Lint/SuppressedException
+      end
+
+      def save_history(file, max_size = 10000)
+        return unless file
+
+        history = Readline::HISTORY.each
+
+        # Skip over excess elements:
+        (Readline::HISTORY.length - max_size).times do
+          history.next
+        end
+
+        File.open(file, "w") do |f|
+          loop { f.puts history.next }
+        end
+      end
+
+      def run(history_file: nil, tokenizer: ShellTokenizer)
+        history_file = history_file&.gsub(%r{^~/}, "#{Dir.home}/")
+        load_history(history_file)
+
+        Readline.completion_proc = proc do
+          cmd, args, last_arg = tokenizer.split_with_comppoint(Readline.line_buffer, Readline.point)
+          options = runner.options([cmd, *args].compact, last_arg)
+          options.map do |opt|
+            # if opt is a symbol, it's a "opts method" option type -- where a REPL method returns the options.
+            # TODO: a bit weird since the REPL's "args" and "flags" are wrong/old when that completion method is run
+            # also filter to start_with? is more appropriate in tabry, not here, but whatever
+            opt.is_a?(Symbol) ? repl.send(opt)&.select { |x| x.start_with?(last_arg) } : opt
+          end.flatten
+        end
+
+        while (cmdline = readline)
+          raw_args = tokenizer.split(cmdline)
+          next if raw_args.empty?
+
+          result = runner.parse(raw_args)
+          # TODO: usage has "myrepl" (command name) in; also, "got 1 args" is confusing when command doesn't exist
+          if result.help?
+            puts result.usage
+          elsif result.invalid_usage_reason
+            puts "Invalid usage: #{result.invalid_usage_reason}"
+            puts
+            puts result.usage
+          else
+            run_result(raw_args, result)
+          end
+        end
+
+        save_history(history_file)
+      end
+
+      def run_result(raw_args, result)
+        met = result.state.subcommand_stack.join("__").gsub("-", "_")
+        repl.internals = ::Tabry::CLI::Internals.new(
+          runner: runner, raw_args: raw_args,
+          state: result.state, met: met, result: result
+        )
+        catch(:tabry_replty_command_exit) do
+          repl.send(met.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/tabry/runner.rb

@@ -19,8 +19,8 @@ module Tabry
                 end
     end
 
-    def options(args, last = nil)
-      Tabry::OptionsFinder.options(parse(args), last)
+    def options(args, last = nil, params = {})
+      Tabry::OptionsFinder.options(parse(args), last, params)
     end
 
     def parse(args)

data/lib/tabry/shell_tokenizer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+# Code to tokenize whole command lines into command and argument
+# This may be adjustable in some cases
+module Tabry
+  module ShellTokenizer
+    module_function
+
+    COMP_POINT_SENTINEL = "\uFFFF"
+
+    # 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
+    #
+    # Returns [cmd_name, args, last_arg]
+    # cmd_name is the basename of the command run
+    #
+    def split_with_comppoint(cmd_line, comp_point)
+      # 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
+      all_tokens = Shellwords.split(cmd_line)
+
+      # ignore all tokens after the one with the sentinel, then replace the COMP_POINT_SENTINEL.
+      # the last token is now the token which the cursor is on (the entire token, not just before the cursor)
+      last_arg_index = all_tokens.index { |arg| arg.include?(COMP_POINT_SENTINEL) }
+      all_tokens = all_tokens[0..last_arg_index]
+      all_tokens.last.gsub! COMP_POINT_SENTINEL, ""
+
+      # take last_arg first -- will always be non-null (it will be empty if input string is empty).
+      last_arg = all_tokens.pop
+      cmd = all_tokens.shift
+
+      cmd_name = cmd&.gsub(%r{.*/}, "")
+
+      [cmd_name, all_tokens, last_arg]
+    end
+
+    def split(str)
+      Shellwords.split(str)
+    end
+  end
+end

data/lib/tabry/shells/bash/wrapper.rb

@@ -4,14 +4,14 @@ require "shellwords"
 require "yaml"
 require_relative "../../util"
 require_relative "../../runner"
-require_relative "../../shell_splitter"
+require_relative "../../shell_tokenizer"
 
 # Bash-specific entrypoint, taking COMP_WORDS and COMP_CWORDS and returning possible options
 module Tabry
   module Bash
     module Wrapper
       def self.run(cmd_line, comp_point, config: nil)
-        cmd_name, args, last_arg = Tabry::ShellSplitter.split(cmd_line, comp_point)
+        cmd_name, args, last_arg = Tabry::ShellTokenizer.split_with_comppoint(cmd_line, comp_point)
         opts = Tabry::Runner.new(config: config || cmd_name).options(args, last_arg)
 
         if Tabry::Util.debug?

data/lib/tabry/shells/fish/wrapper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "yaml"
+require_relative "../../util"
+require_relative "../../runner"
+require_relative "../../shell_tokenizer"
+
+# Fish-specific entrypoint
+module Tabry
+  module Fish
+    module Wrapper
+      DESCRIPTION_MAX_LENGTH = 50
+
+      def self.run(cmd_line, comp_point, config: nil)
+        cmd_name, args, last_arg = Tabry::ShellTokenizer.split_with_comppoint(cmd_line, comp_point)
+        opts = Tabry::Runner.new(config: config || cmd_name).options(args, last_arg, {descriptions: true})
+
+        if Tabry::Util.debug?
+          $stderr.puts
+          warn "debug: got command line and comp_point: #{cmd_line.inspect}, #{comp_point}"
+          warn "using args: #{args.inspect}"
+          warn "using lastarg: #{last_arg.inspect}"
+          warn "results from Tabry#options(): #{opts.inspect}"
+          warn "--- end debug output ---"
+        end
+
+        normal_opts = opts.select { |t,| t.is_a?(String) }
+        special_opts = opts.select { |t| t.is_a?(Symbol) }
+
+        puts normal_opts.map { |opt, desc| "#{Shellwords.escape(opt)}\t#{format_description(desc)}" }.join("\n")
+        if special_opts.any?
+          puts
+          puts special_opts.join("\n")
+        end
+      end
+
+      def self.format_description(description)
+        if description.nil?
+          ""
+        else
+          if description.length > DESCRIPTION_MAX_LENGTH
+            "#{description[0..(DESCRIPTION_MAX_LENGTH - 3)]}..."
+          else
+            description
+          end
+        end
+      end
+    end
+  end
+end