tabry 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53cb186e419ee3ddbecddaf09ac32b39d93d5668c58fd81bc8d08ff16e1b168d
-  data.tar.gz: c5d7fa4e944df15ff727eb0a9d38e2550da6988bdcf83f2dbaa743252f3c9669
+  metadata.gz: 87fa1708b1efb9ef81588017419bb6c63455ee786870f882783cf59f22ea462b
+  data.tar.gz: f0822419f2a36d48148cf7cf0ecdbd195666e2c5fe284d2e8dd6a563976c0842
 SHA512:
-  metadata.gz: 1da3914992fd9ca409800f0183992fe6a742f0d55f04573e20c119cace1b00538294113c675a8281ff881703cbb13fb5a1802d4d164d9343dd4d5543cd9f2ca5
-  data.tar.gz: 6a9797aaf76219131bcb3a6faa780ebedd0cd7971ad98f91e0d9f56d3d3302f4c29b62c9c4db0025fea4a1fea9047a40e54bf55400d2de1a7837915ddb7edc06
+  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/top_level_builder.rb

@@ -24,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/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

@@ -6,7 +6,7 @@ module Tabry
   module Models
     class MethodOption < OptionBase
       # TODO: Handled upstream for now, could change later.
-      def options(_token)
+      def options(_token, _params)
         [value.to_sym]
       end
     end

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

data/lib/tabry/shells/fish.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Used to generate a tab-completion function for a Tabry CLI using absolute
+# paths to the tabry-bash script in this repo and to the Tabry JSON/YML file.
+# Using uniquely-named tab-completion functions and absolute paths means you can
+# have different Tabry-based CLIs using different versions of Tabry without any
+# conflicts.
+# See sh/bash/README.md and "Adding Tab Completion to your CLI" in main README
+
+require "shellwords"
+
+module Tabry
+  module Shells
+    module Fish
+      # NOTE! This code uses sh/fish/tabry_fish.fish and is described in
+      # sh/fish/README.md; see that README for more info
+      def self.generate(cmd_name, tabry_file_path, uniq_fn_id: nil)
+        generate_internal(
+          cmd_name: cmd_name,
+          import_path: File.expand_path(tabry_file_path),
+          tabry_fish_executable: File.expand_path("#{path_to_tabry}/bin/tabry-fish"),
+          tabry_fish_arg: nil,
+          uniq_fn_id: uniq_fn_id
+        )
+      end
+
+      # Generate fish completion code that will run the currently running
+      # command ($0) with "completion" to get completion options. "cmd_name"
+      # is used to tell fish which command to make options for
+      def self.generate_self(cmd_name: nil)
+        cmd_name ||= File.basename($0)
+        generate_internal(
+          cmd_name: cmd_name,
+          import_path: "",
+          tabry_fish_executable: File.expand_path($0),
+          tabry_fish_arg: "completion",
+        )
+      end
+
+      def self.path_to_tabry
+        File.expand_path("#{__dir__}/../../../")
+      end
+
+      def self.esc(s)
+        Shellwords.escape(s)
+      end
+
+      def self.add_uniq_id(str, pattern, uniq_id)
+        str.gsub! pattern, "#{pattern}_#{uniq_id}"
+      end
+
+      def self.generate_internal(cmd_name:, import_path:, tabry_fish_executable:, tabry_fish_arg:, uniq_fn_id: nil)
+        # uniq_fn_id is added to the bash functions to ensure they are unique
+        # -- by default this is the capitalized command name
+        uniq_fn_id ||= cmd_name
+        uniq_fn_id = uniq_fn_id.upcase.gsub(/[^A-Z0-9_]/, "_")
+        script = File.read("#{__dir__}/../../../sh/fish/tabry_fish.fish")
+
+        add_uniq_id(script, "tabry_completion_init", uniq_fn_id)
+        add_uniq_id(script, "__fish_tabry_internal_invoke", uniq_fn_id)
+        add_uniq_id(script, "__fish_tabry_check_only_args", uniq_fn_id)
+        add_uniq_id(script, "__fish_tabry_check_only_file", uniq_fn_id)
+        add_uniq_id(script, "__fish_tabry_check_args_and_file", uniq_fn_id)
+        add_uniq_id(script, "__fish_tabry_completions", uniq_fn_id)
+
+        script.gsub! "# TABRY_IMPORT_PATH_REPLACE (DO NOT REMOVE)", "set TABRY_IMPORTS_PATH #{esc import_path}"
+        script.gsub! "# TABRY_EXECUTABLE_REPLACE (DO NOT REMOVE)", "set TABRY_EXECUTABLE #{esc tabry_fish_executable}"
+        if !tabry_fish_arg.nil?
+          script.gsub! "# TABRY_ARG_REPLACE (DO NOT REMOVE)", "set TABRY_ARG #{esc tabry_fish_arg}"
+        end
+
+        <<~END_FISH_CODE_TEMPLATE
+          # The following Autocomplete is for a Tabry-powered command. It was
+          # generated by the command itself. See the documentation located in
+          # #{esc path_to_tabry}/sh/fish/README.md
+          #{script}
+          tabry_completion_init_#{uniq_fn_id} #{esc cmd_name}
+        END_FISH_CODE_TEMPLATE
+      end
+    end
+  end
+end

data/lib/tabry/version.rb

@@ -0,0 +1,3 @@
+module Tabry
+  VERSION = "0.2.4"
+end

data/sh/fish/README.md

@@ -2,8 +2,9 @@ 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
+1. Source `tabry_fish.fish`
 2. Add a call to `tabry_completion_init`, for each command
+3. Ensure the `TABRY_IMPORTS_PATH` environment variable is defined and points to where your compiled tabry files are located.
 
 ```sh
 source tabry_fish.fish

data/sh/fish/tabry_fish.fish

@@ -12,14 +12,19 @@ end
 
 # return true if tabry only reports commands
 function __fish_tabry_internal_invoke
-  set SCRIPT (status --current-filename)
-  set SCRIPT_DIR (dirname $SCRIPT)
+  # TABRY_IMPORT_PATH_REPLACE (DO NOT REMOVE)
+  # TABRY_EXECUTABLE_REPLACE (DO NOT REMOVE)
+  # TABRY_ARG_REPLACE (DO NOT REMOVE)
+  set -x TABRY_FISH_MODE true
 
   # -C "Get cursor position"
   set cursor_position (commandline -C)
   set cmd (commandline)
-  set result ($SCRIPT_DIR/../../bin/tabry-bash "$cmd" "$cursor_position")
-  echo $result
+
+  set result ($TABRY_EXECUTABLE $TABRY_ARG "$cmd" "$cursor_position")
+  for arg in $result
+    echo $arg
+  end
 end
 
 # return true if tabry only reports file
@@ -75,16 +80,14 @@ function __fish_tabry_completions
 
   set args      (echo "$result"|sed 's/  .*//')
 
-  # The '--' arg is needed in case $result contains flag-like strings
-  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"]
+    # $result will be something like: ["foo 'this is foo'" "bar" "baz" "" "file"]
     #   where "file" is special, since it's after the space.
-    for arg in $args_parsed
+    for arg in $result
+      set clean_arg (echo "$arg"|sed 's/  .*//')
       if test "x$arg" != "x"
         echo "$arg"
       else

data/spec/tabry/cli/all_in_one_spec.rb

@@ -3,6 +3,7 @@
 require_relative "../../../lib/tabry/cli/all_in_one"
 require_relative "../../../lib/tabry/shells/bash"
 require_relative "../../../lib/tabry/shells/bash/wrapper"
+require_relative "../../../lib/tabry/shells/fish"
 
 module Tabry::Spec
   module Cli
@@ -124,6 +125,17 @@ describe Tabry::CLI::AllInOne do
       end
     end
 
+    it "creates a #completion__fish method which generates completion" do
+      stub_const("ARGV", %w[completion fish])
+      expect(Tabry::Shells::Fish).to receive(:generate_self).with(cmd_name: "foo").and_return("fish completion stuff")
+      expect_any_instance_of(Kernel).to receive(:puts).with("fish 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:|

data/tabry.gemspec

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-# TODO: these 2 lines are cargo cult
-lib = File.expand_path("lib", __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative './lib/tabry/version'
 
 Gem::Specification.new do |s|
   s.name        = "tabry"
-  s.version     = "0.2.3"
+  s.version     = Tabry::VERSION
   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.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Evan Battaglia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-23 00:00:00.000000000 Z
+date: 2023-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry-byebug
@@ -84,7 +84,9 @@ description:
 email: battaglia.evan@gmail.com
 executables:
 - tabry-bash
+- tabry-fish
 - tabry-generate-bash-complete
+- tabry-generate-fish-complete
 - tabry-help
 - tabry-test-options
 - tabry-test-parse
@@ -92,7 +94,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/tabry-bash
+- bin/tabry-fish
 - bin/tabry-generate-bash-complete
+- bin/tabry-generate-fish-complete
 - bin/tabry-help
 - bin/tabry-test-options
 - bin/tabry-test-parse
@@ -148,9 +152,12 @@ files:
 - lib/tabry/shell_tokenizer.rb
 - lib/tabry/shells/bash.rb
 - lib/tabry/shells/bash/wrapper.rb
+- lib/tabry/shells/fish.rb
+- lib/tabry/shells/fish/wrapper.rb
 - lib/tabry/state.rb
 - lib/tabry/usage_generator.rb
 - lib/tabry/util.rb
+- lib/tabry/version.rb
 - sh/bash/README.md
 - sh/bash/tabry_bash.sh
 - sh/bash/tabry_bash_core.sh