tabry 0.2.2 → 0.2.3

data/spec/tabry/machine_spec.rb

@@ -15,94 +15,17 @@ describe Tabry::Machine do
     expect(subject.args).to eq(arr)
   end
 
-  examples = {
-    "handles subcommands" => [
-      %w[build],
-      subs: %w[build], mode: :subcommand
-    ],
-    "handles bogus subcommands" => [
-      %w[bogus],
-      subs: [], args: %w[bogus]
-    ],
-    "handles bogus subcommands of subcommands are treated as args" => [
-      %w[move bogus bogus2],
-      subs: %w[move], args: %w[bogus bogus2], mode: :subcommand
-    ],
-    "handles subcommands of subcommands" => [
-      %w[move go],
-      subs: %w[move go],
-    ],
-    "handles subcommands aliases" => [
-      %w[move g],
-      subs: %w[move go],
-    ],
-    "handles argsuments" => [
-      %w[build arg1 arg2],
-      subs: %w[build], args: %w[arg1 arg2]
-    ],
-    "handles flags" => [
-      %w[build -v],
-      subs: %w[build], flags: { "verbose" => true }, args: [], mode: :subcommand
-    ],
-    "handles long flags" => [
-      %w[--verbose build],
-      subs: %w[build], flags: { "verbose" => true }, args: [], mode: :subcommand
-    ],
-    "handles flags interspersed with arguments" => [
-      %w[move -v crash arg1 --dry-run arg2 arg3],
-      subs: %w[move crash], args: %w[arg1 arg2 arg3],
-      flags: { "dry-run" => true, "verbose" => true }, mode: :subcommand
-    ],
-    "handles flags with an argument" => [
-      %w[move crash --dry-run arg1 -f file arg2 arg3],
-      subs: %w[move crash], args: %w[arg1 arg2 arg3],
-      flags: { "dry-run" => true, "output-to-file" => "file" }, mode: :subcommand
-    ],
-    "handles double-dash to stop parsing of flags" => [
-      %w[move crash -- --dry-run arg1 -f file arg2 arg3],
-      subs: %w[move crash], args: %w[--dry-run arg1 -f file arg2 arg3], mode: :subcommand
-    ],
-    "handles unknown long flags as args" => [
-      %w[move crash --notaflag arg2],
-      subs: %w[move crash], args: %w[--notaflag arg2], mode: :subcommand
-    ],
-    "handles unknown short flags as args" => [
-      %w[move crash -x arg2 --dry-run],
-      subs: %w[move crash], args: %w[-x arg2], flags: { "dry-run" => true }, mode: :subcommand
-    ],
-    "handles --help" => [
-      %w[move --help],
-      subs: %w[move], flags: {}, args: [], help: true, mode: :subcommand
-    ],
-    "handles -?" => [
-      %w[move foo bar --help waz],
-      subs: %w[move], flags: {}, args: %w[foo bar waz], help: true
-    ],
-    "ignores -?/--help after double-dash" => [
-      %w[move -- --help -? -- -],
-      subs: %w[move], flags: {}, args: %w[--help -? -- -], help: nil
-    ],
-    "sets mode to flagarg when waiting for a flag argument" => [
-      %w[move crash --dry-run arg1 -f],
-      subs: %w[move crash], args: %w[arg1], flags: { "dry-run" => true },
-      mode: :flagarg, current_flag: "output-to-file"
-    ],
-    # TODO: might want behavior to be different; currently I think if --verbose is before the
-    # subcommand it use's the main command's --verbose flag
-    "most specific sub's flag takes precedence in case of multiple matching" => [
-      %w[sub-with-mandatory-flag --verbose foo --mandatory abc],
-      subs: %w[sub-with-mandatory-flag],
-      flags: { "verbose" => "foo", "mandatory" => "abc" }
-    ]
-  }
+  examples = JSON.parse(File.read("#{__dir__}/../fixtures/vehicles-expectations.json"))
 
   examples.each do |test_name, (tokens, expectation)|
     it test_name do
       pending unless expectation
       result = described_class.run(config, tokens)
       expectation.each do |key, val|
-        key = :subcommand_stack if key == :subs
-        expect(result.send(key)).to eq(val)
+        key = 'subcommand_stack' if key == 'subs'
+        res = result.send(key.to_sym)
+        res = res.to_s if res.is_a?(Symbol)
+        expect(res).to eq(val)
       end
     end
   end

data/spec/tabry/shell_tokenizer_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/tabry/shell_tokenizer"
+
+describe Tabry::ShellTokenizer do
+  describe ".split_with_comppoint" do
+    it "returns the command basename, argument, and last argument" do
+      str = "foo/bar abc def ghi"
+      expect(described_class.split_with_comppoint(str, 13)).to eq(["bar", ["abc"], "def"])
+    end
+
+    it "returns [] as arguments and the last argument as non-nil when there is only one arg" do
+      expect(described_class.split_with_comppoint("foo bar", 5)).to eq(["foo", [], "bar"])
+    end
+
+    it "handles quotes and backslashes like a shell" do
+      expect(described_class.split_with_comppoint('"/foo bar/waz" a\'b \'c\\ d "ef g" "hi jk" lmn', 38)).to eq(
+        [
+          "waz",
+          ["ab c d", "ef g"],
+          "hi jk"
+        ]
+      )
+    end
+
+    it "supports tokens with argument (tab on command), yielding the last arg" do
+      expect(described_class.split_with_comppoint("abc", 2)).to eq([nil, [], "abc"])
+    end
+
+    it "supports empty strings" do
+      expect(described_class.split_with_comppoint("", 0)).to eq([nil, [], ""])
+    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.2.2"
+  s.version     = "0.2.3"
   s.summary     = "Tab completion and CLIs extraordinaire"
   s.authors     = ["Evan Battaglia"]
   s.email       = "battaglia.evan@gmail.com"

data/treesitter/corpus/opts.txt

@@ -5,6 +5,7 @@ Options
 arg {
   opts const a
   opts shell "ls"
+  opts method foo
   opts file
   opts dir
 }
@@ -17,5 +18,6 @@ arg {
     (block
       (opts_const_statement (string))
       (opts_shell_statement (string))
+      (opts_method_statement (string))
       (opts_file_statement)
       (opts_dir_statement))))

data/treesitter/grammar.js

@@ -27,6 +27,7 @@ module.exports = grammar({
       $._common_statement,
       $.opts_const_statement,
       $.opts_shell_statement,
+      $.opts_method_statement,
       $.opts_file_statement,
       $.opts_dir_statement,
       $.title_statement,
@@ -121,6 +122,12 @@ module.exports = grammar({
       'dir',
     ),
 
+    opts_method_statement: $ => seq(
+      'opts',
+      'method',
+      $.string
+    ),
+
     flagarg_statement: $ => seq(
       optional($.flag_modifier),
       'flagarg',

data/treesitter/src/grammar.json

@@ -77,6 +77,10 @@
           "type": "SYMBOL",
           "name": "opts_shell_statement"
         },
+        {
+          "type": "SYMBOL",
+          "name": "opts_method_statement"
+        },
         {
           "type": "SYMBOL",
           "name": "opts_file_statement"
@@ -389,6 +393,23 @@
         }
       ]
     },
+    "opts_method_statement": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "opts"
+        },
+        {
+          "type": "STRING",
+          "value": "method"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "string"
+        }
+      ]
+    },
     "flagarg_statement": {
       "type": "SEQ",
       "members": [

data/treesitter/src/node-types.json

@@ -101,6 +101,10 @@
           "type": "opts_file_statement",
           "named": true
         },
+        {
+          "type": "opts_method_statement",
+          "named": true
+        },
         {
           "type": "opts_shell_statement",
           "named": true
@@ -332,6 +336,21 @@
     "named": true,
     "fields": {}
   },
+  {
+    "type": "opts_method_statement",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "string",
+          "named": true
+        }
+      ]
+    }
+  },
   {
     "type": "opts_shell_statement",
     "named": true,
@@ -524,6 +543,10 @@
     "type": "include",
     "named": false
   },
+  {
+    "type": "method",
+    "named": false
+  },
   {
     "type": "opts",
     "named": false