tabry 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a76bb8b85fa94e61bf625e435711d8e3385f5aa50a87a7c410e4f252947ffea
-  data.tar.gz: '0632896bf92ca8b57a08db3b153e32aed0da12c71d9604d7260de2fba6fc9707'
+  metadata.gz: 53cb186e419ee3ddbecddaf09ac32b39d93d5668c58fd81bc8d08ff16e1b168d
+  data.tar.gz: c5d7fa4e944df15ff727eb0a9d38e2550da6988bdcf83f2dbaa743252f3c9669
 SHA512:
-  metadata.gz: 8420bd16657ebbe6e2f13c55a14e62fffab982b5d81f71d76c36ccdd97d36ee4a09ce7ccf1386c5b0b553681b48d7b3fdd90336fb72574d55ba426ca22200ed9
-  data.tar.gz: 1dcd973c7608319c73ae59ab8c516e0ccb54ec9c6bf909f13235e3be238e1059e93d2ba067d99a66b8de8fb5cca9c69e2cf861b1393aecbd9076580fbbdef37c
+  metadata.gz: 1da3914992fd9ca409800f0183992fe6a742f0d55f04573e20c119cace1b00538294113c675a8281ff881703cbb13fb5a1802d4d164d9343dd4d5543cd9f2ca5
+  data.tar.gz: 6a9797aaf76219131bcb3a6faa780ebedd0cd7971ad98f91e0d9f56d3d3302f4c29b62c9c4db0025fea4a1fea9047a40e54bf55400d2de1a7837915ddb7edc06

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
 

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/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)
+        [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/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/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/sh/fish/tabry_fish.fish

@@ -29,7 +29,7 @@ function __fish_tabry_check_only_args
   set args      (echo "$result"|sed 's/  .*//')
   set specials  (echo "$result"|grep -o '  file')
 
-  # https://github.com/fish-shell/fish-shell/issues/5186#issuecomment-421244106
+  # https://github.com/fish-shell/fish-shell/issues/5186#issuecomment-421244106 (the random "x")
   if test "x$args" != "x" -a "$specials" != "  file"
     # echo "confirming only args:  [$result,$args,$specials]" 1>&2
     return 0;
@@ -45,7 +45,8 @@ function __fish_tabry_check_only_file
 
   set args      (echo "$result"|sed 's/  .*//')
 
-  if test "x$args" = "x" -a (string match -ra '  file' $result)
+  # The '--' arg is needed in case $result contains flag-like strings
+  if test "x$args" = "x" -a (string match -ra -- '  file' $result)
     # echo "confirming only file" 1>&2
     return 0;
   else
@@ -59,7 +60,8 @@ function __fish_tabry_check_args_and_file
 
   set args      (echo "$result"|sed 's/  .*//')
 
-  if test "x$args" != "x" -a (string match -ra '  file' $result)
+  # The '--' arg is needed in case $result contains flag-like strings
+  if test "x$args" != "x" -a (string match -ra -- '  file' $result)
     # echo "confirming args and file" 1>&2
     return 0;
   else
@@ -73,7 +75,8 @@ function __fish_tabry_completions
 
   set args      (echo "$result"|sed 's/  .*//')
 
-  set args_parsed (string split ' ' $args)
+  # 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

data/spec/fixtures/config_builder/underscoresdashes.yml

@@ -33,7 +33,7 @@ main:
         - include: project-and-environment
     - include: project-and-environment
 option_includes:
-  project_and_environment:
+  project-and-environment:
     - type: const
       value: a
 

data/spec/fixtures/vehicles-expectations.json

@@ -0,0 +1,351 @@
+{
+  "handles subcommands": [
+    [
+      "build"
+    ],
+    {
+      "subs": [
+        "build"
+      ],
+      "mode": "subcommand"
+    }
+  ],
+  "handles bogus subcommands": [
+    [
+      "bogus"
+    ],
+    {
+      "subs": [
+
+      ],
+      "args": [
+        "bogus"
+      ]
+    }
+  ],
+  "handles bogus subcommands of subcommands are treated as args": [
+    [
+      "move",
+      "bogus",
+      "bogus2"
+    ],
+    {
+      "subs": [
+        "move"
+      ],
+      "args": [
+        "bogus",
+        "bogus2"
+      ],
+      "mode": "subcommand"
+    }
+  ],
+  "handles subcommands of subcommands": [
+    [
+      "move",
+      "go"
+    ],
+    {
+      "subs": [
+        "move",
+        "go"
+      ]
+    }
+  ],
+  "handles subcommands aliases": [
+    [
+      "move",
+      "g"
+    ],
+    {
+      "subs": [
+        "move",
+        "go"
+      ]
+    }
+  ],
+  "handles argsuments": [
+    [
+      "build",
+      "arg1",
+      "arg2"
+    ],
+    {
+      "subs": [
+        "build"
+      ],
+      "args": [
+        "arg1",
+        "arg2"
+      ]
+    }
+  ],
+  "handles flags": [
+    [
+      "build",
+      "-v"
+    ],
+    {
+      "subs": [
+        "build"
+      ],
+      "flags": {
+        "verbose": true
+      },
+      "args": [
+
+      ],
+      "mode": "subcommand"
+    }
+  ],
+  "handles long flags": [
+    [
+      "--verbose",
+      "build"
+    ],
+    {
+      "subs": [
+        "build"
+      ],
+      "flags": {
+        "verbose": true
+      },
+      "args": [
+
+      ],
+      "mode": "subcommand"
+    }
+  ],
+  "handles flags interspersed with arguments": [
+    [
+      "move",
+      "-v",
+      "crash",
+      "arg1",
+      "--dry-run",
+      "arg2",
+      "arg3"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "arg1",
+        "arg2",
+        "arg3"
+      ],
+      "flags": {
+        "dry-run": true,
+        "verbose": true
+      },
+      "mode": "subcommand"
+    }
+  ],
+  "handles flags with an argument": [
+    [
+      "move",
+      "crash",
+      "--dry-run",
+      "arg1",
+      "-f",
+      "file",
+      "arg2",
+      "arg3"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "arg1",
+        "arg2",
+        "arg3"
+      ],
+      "flags": {
+        "dry-run": true,
+        "output-to-file": "file"
+      },
+      "mode": "subcommand"
+    }
+  ],
+  "handles double-dash to stop parsing of flags": [
+    [
+      "move",
+      "crash",
+      "--",
+      "--dry-run",
+      "arg1",
+      "-f",
+      "file",
+      "arg2",
+      "arg3"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "--dry-run",
+        "arg1",
+        "-f",
+        "file",
+        "arg2",
+        "arg3"
+      ],
+      "mode": "subcommand",
+      "dashdash": true
+    }
+  ],
+  "handles unknown long flags as args": [
+    [
+      "move",
+      "crash",
+      "--notaflag",
+      "arg2"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "--notaflag",
+        "arg2"
+      ],
+      "mode": "subcommand"
+    }
+  ],
+  "handles unknown short flags as args": [
+    [
+      "move",
+      "crash",
+      "-x",
+      "arg2",
+      "--dry-run"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "-x",
+        "arg2"
+      ],
+      "flags": {
+        "dry-run": true
+      },
+      "mode": "subcommand"
+    }
+  ],
+  "handles --help": [
+    [
+      "move",
+      "--help"
+    ],
+    {
+      "subs": [
+        "move"
+      ],
+      "flags": {
+      },
+      "args": [
+
+      ],
+      "help": true,
+      "mode": "subcommand"
+    }
+  ],
+  "handles -?": [
+    [
+      "move",
+      "foo",
+      "bar",
+      "--help",
+      "waz"
+    ],
+    {
+      "subs": [
+        "move"
+      ],
+      "flags": {
+      },
+      "args": [
+        "foo",
+        "bar",
+        "waz"
+      ],
+      "help": true
+    }
+  ],
+  "ignores -?/--help after double-dash": [
+    [
+      "move",
+      "--",
+      "--help",
+      "-?",
+      "--",
+      "-"
+    ],
+    {
+      "subs": [
+        "move"
+      ],
+      "flags": {
+      },
+      "args": [
+        "--help",
+        "-?",
+        "--",
+        "-"
+      ],
+      "help": false,
+      "dashdash": true
+    }
+  ],
+  "sets mode to flagarg when waiting for a flag argument": [
+    [
+      "move",
+      "crash",
+      "--dry-run",
+      "arg1",
+      "-f"
+    ],
+    {
+      "subs": [
+        "move",
+        "crash"
+      ],
+      "args": [
+        "arg1"
+      ],
+      "flags": {
+        "dry-run": true
+      },
+      "mode": "flagarg",
+      "current_flag": "output-to-file"
+    }
+  ],
+  "most specific sub's flag takes precedence in case of multiple matching": [
+    [
+      "sub-with-mandatory-flag",
+      "--verbose",
+      "foo",
+      "--mandatory",
+      "abc"
+    ],
+    {
+      "subs": [
+        "sub-with-mandatory-flag"
+      ],
+      "flags": {
+        "verbose": "foo",
+        "mandatory": "abc"
+      }
+    }
+  ]
+}