completely 0.8.0.rc5 → 0.8.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fdb300c1ddaaf4ab1cfa6ca3e0b1371f4fbf33f1a22f29357bae06da0a973fc
-  data.tar.gz: 3c812320dc20d2b9c13bf08e5cff2c596cd873880d8ec5b19b3a0bee68afd875
+  metadata.gz: cd6a89f32abe46975fa2f733f3ec78ac814a9af33695e2527a1df270a3693f80
+  data.tar.gz: 3452a9ffa65f0fdbc70d96c3163c19036b4fae67dbad8377d1c6525735287b1a
 SHA512:
-  metadata.gz: 83f853427d2f54f0b86d736c1d54e526a74806b643c7d4dc12ea857eeacde38e18b8272374253845e697545168d0afcc9ec48d52fad7c00969d4be972c919b26
-  data.tar.gz: 8f463487ca5084e78b11875f3b1d591359c0252055cdd44bb9df06024076b0dc6627647e9d30cd8beaeab1d97ec8b06eb1d986b634513eb5bb8e63184514daad
+  metadata.gz: 137940d533ad4b1565d6447bbcea7fec87abbfda0df9956e6a876339d0aebe18e072282e32d92df5003c5a5b6eb0a3f070c5b4b24598ee09ab43502bbc34e248
+  data.tar.gz: 4accdb72c5cbe8921b88cfc1429b7bbcf0ac85ef24e607cc2b700f1f38080759ff5f54ae21b624317ee1ff4583885fc1ee5e446c930243381d8ecd3179eaa852

data/README.md

@@ -115,6 +115,36 @@ The `patterns` section describes valid command shapes:
 - `<token>` references `tokens.token`.
 - `<token>...` marks the final positional as repeatable.
 
+Pattern config is compiled as a command tree. Option group placement is
+therefore meaningful: an option group belongs to the command word immediately
+before it. In the example above, `root` options belong to `mygit`, `init`
+options belong to `mygit init`, and `status` options belong to `mygit status`.
+
+This is useful for commands that have global options and command-specific
+options:
+
+```yaml
+patterns:
+  - docker [global options] container [container options]
+  - docker [global options] container cp [cp options] <source> <dest>
+
+options:
+  global:
+    - --config <file>
+  container:
+    - --latest
+  cp:
+    - -a|--archive
+
+tokens:
+  file: +file
+  source: [container:/app, local.txt]
+  dest: [container:/tmp, ./out]
+```
+
+If a completed command line contains an option that is not valid at the current
+node, Completely stops offering suggestions for that command line.
+
 The `options` section defines option groups:
 
 ```yaml

data/lib/completely/commands/init.rb

@@ -32,7 +32,7 @@ module Completely
 
       def sample_path
         @sample_path ||= begin
-          raise Error, "Invalid format: #{format}" unless sample_filenames.key? format
+          raise Error, "Invalid format: #{format}" unless sample_filenames.has_key? format
 
           File.expand_path "../templates/#{sample_filename}", __dir__
         end

data/lib/completely/completions.rb

@@ -101,48 +101,61 @@ module Completely
       config.is_a? PatternConfig
     end
 
-    def pattern_routes
-      config.model[:routes]
+    def pattern_tree
+      config.model[:tree]
     end
 
-    def pattern_programs
-      pattern_routes.map { |route| route.dig(:words, 0, :name) }
+    def pattern_nodes
+      @pattern_nodes ||= flatten_pattern_tree pattern_tree
     end
 
-    def pattern_root_words
-      pattern_routes.flat_map do |route|
-        word = route[:words][1]
-        word ? [word[:name], *word[:aliases]] : []
-      end.uniq
+    def pattern_programs
+      config.model[:programs]
     end
 
-    def pattern_route_id(route)
-      pattern_routes.index route
+    def pattern_node_id(node)
+      pattern_nodes.index { |entry| entry[:node].equal? node }
     end
 
-    def pattern_route_conditions(route)
-      route[:words][1..].map.with_index do |word, index|
-        names = [word[:name], *word[:aliases]]
-        names.map { |name| %["${non_options[#{index}]}" == "#{bash_escape name}"] }.join(' || ')
+    def pattern_node_options(node)
+      node[:option_groups].flat_map do |name|
+        config.model[:options][name] || []
       end
     end
 
-    def pattern_route_word_count(route)
-      route[:words].size - 1
+    def pattern_node_depth(node)
+      pattern_nodes.dig(pattern_node_id(node), :depth)
     end
 
-    def pattern_route_options(route)
-      route[:option_groups].flat_map do |name|
-        config.model[:options][name] || []
+    def pattern_child_transitions(node)
+      node[:children].flat_map do |child|
+        pattern_word_names(child[:word]).map do |name|
+          { name: name, node: child }
+        end
       end
     end
 
+    def pattern_node_child_words(node)
+      node[:children].flat_map { |child| pattern_word_names child[:word] }.uniq
+    end
+
     def pattern_has_unique_options?
-      pattern_routes.any? do |route|
-        pattern_route_options(route).any? { |option| !option[:repeatable] }
+      pattern_nodes.any? do |entry|
+        pattern_node_options(entry[:node]).any? { |option| !option[:repeatable] }
       end
     end
 
+    def pattern_word_names(word)
+      [word[:name], *word[:aliases]]
+    end
+
+    def flatten_pattern_tree(node, depth = 0)
+      [
+        { node: node, depth: depth },
+        *node[:children].flat_map { |child| flatten_pattern_tree child, depth + 1 },
+      ]
+    end
+
     def pattern_source_empty?(source)
       source[:items].empty?
     end

data/lib/completely/pattern_config.rb

@@ -11,10 +11,11 @@ module Completely
       validate!
 
       @model ||= {
-        program: program,
-        routes:  routes,
-        options: parsed_options,
-        tokens:  tokens,
+        program:  program,
+        programs: programs,
+        tree:     tree,
+        options:  parsed_options,
+        tokens:   tokens,
       }
     end
 
@@ -37,11 +38,63 @@ module Completely
     end
 
     def program
-      routes.first.dig(:words, 0, :name)
+      programs.first
     end
 
-    def routes
-      @routes ||= patterns.map { |pattern| parse_pattern pattern }
+    def programs
+      @programs ||= patterns.filter_map do |pattern|
+        part = pattern_parts(pattern).find { |pattern_part| command_word? pattern_part }
+        parse_word(part)[:name] if part
+      end
+    end
+
+    def tree
+      @tree ||= begin
+        root = nil
+
+        patterns.each do |pattern|
+          current = nil
+
+          pattern_parts(pattern).each do |part|
+            if option_group?(part)
+              add_option_group current, option_group_name(part)
+            elsif token?(part)
+              current[:positionals] << parse_token(part)
+            else
+              word = parse_word part
+              current = current ? find_or_create_child(current, word) : (root ||= build_tree_node(word))
+              merge_word! current[:word], word
+            end
+          end
+        end
+
+        root
+      end
+    end
+
+    def build_tree_node(word)
+      { word: word, option_groups: [], positionals: [], children: [] }
+    end
+
+    def add_option_group(node, name)
+      node[:option_groups] << name unless node[:option_groups].include? name
+    end
+
+    def find_or_create_child(node, word)
+      node[:children].find { |child| same_word? child[:word], word } ||
+        node[:children].tap { |children| children << build_tree_node(word) }.last
+    end
+
+    def same_word?(left, right)
+      word_names(left).intersect? word_names(right)
+    end
+
+    def word_names(word)
+      [word[:name], *word[:aliases]]
+    end
+
+    def merge_word!(target, source)
+      target[:aliases] = (word_names(target) | word_names(source)) - [target[:name]]
     end
 
     def parsed_options
@@ -99,22 +152,6 @@ module Completely
       end
     end
 
-    def parse_pattern(pattern)
-      result = { words: [], option_groups: [], positionals: [] }
-
-      pattern_parts(pattern).each do |part|
-        if option_group?(part)
-          result[:option_groups] << option_group_name(part)
-        elsif token?(part)
-          result[:positionals] << parse_token(part)
-        else
-          result[:words] << parse_word(part)
-        end
-      end
-
-      result
-    end
-
     def parse_word(part)
       names = part.split('|')
       { name: names.first, aliases: names[1..] || [] }
@@ -182,6 +219,10 @@ module Completely
       part.start_with?('[') && part.end_with?(']')
     end
 
+    def command_word?(part)
+      !option_group?(part) && !token?(part)
+    end
+
     def option_group_name(part)
       part[1..-2].sub(/\s+options\z/, '')
     end

data/lib/completely/templates/pattern-config/sample.yaml

@@ -1,5 +1,6 @@
 patterns:
   - mygit [root options]
+  - mygit [root options] clone [clone options] <source> <dest>
   - mygit init [init options] <directory>
   - mygit status [status options]
 
@@ -7,6 +8,9 @@ options:
   root:
     - -h|--help
     - -v|--version
+    - --config <file>
+  clone:
+    - --depth <depth>
   init:
     - --bare
   status:
@@ -16,6 +20,10 @@ options:
     - --verbose (repeatable)
 
 tokens:
+  file: +file
+  source: $(git branch --format='%(refname:short)' 2>/dev/null)
+  dest: +directory
+  depth: [1, 10, 100]
   directory: +directory
   branch: $(git branch --format='%(refname:short)' 2>/dev/null)
   format: [short, long]

data/lib/completely/templates/pattern-config/template.erb

@@ -4,11 +4,15 @@
 # completely (https://github.com/bashly-framework/completely)
 # Modifying it manually is not recommended
 
-<%= function_name %>_route_flag_expects_value() {
+<%= function_name %>_node_flag_state() {
   case "$1:$2" in
-% pattern_routes.each do |route|
-% pattern_route_options(route).select { |option| option[:value] }.each do |option|
-    <%= pattern_route_id route %>:<%= option[:names].map { |name| bash_escape name }.join("|#{pattern_route_id route}:") %>) return 0 ;;
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% pattern_node_options(node).select { |option| option[:value] }.each do |option|
+    <%= pattern_node_id node %>:<%= option[:names].map { |name| bash_escape name }.join("|#{pattern_node_id node}:") %>) return 2 ;;
+% end
+% pattern_node_options(node).reject { |option| option[:value] }.each do |option|
+    <%= pattern_node_id node %>:<%= option[:names].map { |name| bash_escape name }.join("|#{pattern_node_id node}:") %>) return 0 ;;
 % end
 % end
   esac
@@ -29,26 +33,30 @@
 }
 
 % end
-<%= function_name %>_resolve_route() {
-  route_id=
-  route_word_count=-1
-  route_has_positionals=0
+<%= function_name %>_resolve_node() {
+  node_id=0
+  node_word_count=0
   positional_index=0
-% pattern_routes.each do |route|
-% conditions = pattern_route_conditions(route)
-  if (( ${#non_options[@]} >= <%= pattern_route_word_count route %> )) &&
-    (( <%= pattern_route_word_count route %> > route_word_count ))<%= conditions.empty? ? '' : ' &&' %>
-% conditions.each_with_index do |condition, index|
-    [[ <%= condition %> ]]<%= index == conditions.size - 1 ? '' : ' &&' %>
-% end
-  then
-    route_id=<%= pattern_route_id route %>
-    route_word_count=<%= pattern_route_word_count route %>
-    route_has_positionals=<%= route[:positionals].empty? ? 0 : 1 %>
-    positional_index=$((${#non_options[@]} - <%= pattern_route_word_count route %>))
-  fi
 
+  local word
+  for word in "${non_options[@]}"; do
+    case "$node_id:$word" in
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% pattern_child_transitions(node).each do |transition|
+      <%= pattern_node_id node %>:<%= bash_escape transition[:name] %>)
+        node_id=<%= pattern_node_id transition[:node] %>
+        node_word_count=<%= pattern_node_depth transition[:node] %>
+        ;;
 % end
+% end
+      *)
+        break
+        ;;
+    esac
+  done
+
+  positional_index=$((${#non_options[@]} - node_word_count))
 }
 
 <%= function_name %>() {
@@ -65,11 +73,12 @@
 
   local non_options=()
   local completed_options=()
-  local route_id=
-  local route_word_count=-1
-  local route_has_positionals=0
+  local node_id=
+  local node_word_count=-1
   local positional_index=0
-  <%= function_name %>_resolve_route
+  local invalid_completion=0
+  local flag_state=0
+  <%= function_name %>_resolve_node
 
   local skip_next=0
   for word in "${completed[@]}"; do
@@ -79,28 +88,32 @@
     fi
 
     if [[ "${word:0:1}" == "-" ]]; then
+      <%= function_name %>_node_flag_state "$node_id" "$word"
+      flag_state=$?
+      if (( flag_state == 1 )); then
+        invalid_completion=1
+        break
+      fi
+
       completed_options+=("$word")
-      if <%= function_name %>_route_flag_expects_value "$route_id" "$word"; then
+      if (( flag_state == 2 )); then
         skip_next=1
       fi
       continue
     fi
 
     non_options+=("$word")
-    <%= function_name %>_resolve_route
+    <%= function_name %>_resolve_node
   done
 
   COMPREPLY=()
+  (( invalid_completion )) && return
 
-  if [[ -z "$route_id" ]] || { (( route_word_count == 0 )) && (( !route_has_positionals )) && [[ "${cur:0:1}" != "-" ]]; }; then
-    while read -r; do COMPREPLY+=("$REPLY"); done < <(compgen -W "<%= bash_double_quote_escape pattern_root_words.join(' ') %>" -- "$cur")
-    return
-  fi
-
-  case "$route_id:$prev" in
-% pattern_routes.each do |route|
-% pattern_route_options(route).select { |option| option[:value] }.each do |option|
-    <%= pattern_route_id route %>:<%= option[:names].map { |name| bash_escape name }.join("|#{pattern_route_id route}:") %>)
+  case "$node_id:$prev" in
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% pattern_node_options(node).select { |option| option[:value] }.each do |option|
+    <%= pattern_node_id node %>:<%= option[:names].map { |name| bash_escape name }.join("|#{pattern_node_id node}:") %>)
 % if pattern_source_empty? option[:value][:source]
       return
 % else
@@ -112,12 +125,27 @@
 % end
   esac
 
+  if [[ "${cur:0:1}" != "-" ]] && (( positional_index == 0 )); then
+    case "$node_id" in
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% child_words = pattern_node_child_words(node)
+% next if child_words.empty?
+      <%= pattern_node_id node %>)
+        while read -r; do COMPREPLY+=("$REPLY"); done < <(compgen -W "<%= bash_double_quote_escape child_words.join(' ') %>" -- "$cur")
+        return
+        ;;
+% end
+    esac
+  fi
+
   if [[ "${cur:0:1}" == "-" ]]; then
-    case "$route_id" in
-% pattern_routes.each do |route|
-      <%= pattern_route_id route %>)
+    case "$node_id" in
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+      <%= pattern_node_id node %>)
         local words=()
-% pattern_route_options(route).each do |option|
+% pattern_node_options(node).each do |option|
 % if option[:repeatable]
         words+=(<%= option[:names].map { |name| %["#{bash_escape name}"] }.join(' ') %>)
 % else
@@ -131,10 +159,11 @@
     esac
   fi
 
-% pattern_routes.each do |route|
-% route[:positionals].each_with_index do |positional, index|
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% node[:positionals].each_with_index do |positional, index|
 % next unless positional[:repeatable]
-  if [[ "$route_id" == "<%= pattern_route_id route %>" ]] && (( positional_index >= <%= index %> )); then
+  if [[ "$node_id" == "<%= pattern_node_id node %>" ]] && (( positional_index >= <%= index %> )); then
 % if pattern_source_empty? positional[:source]
     return
 % else
@@ -145,11 +174,12 @@
 
 % end
 % end
-  case "$route_id:$positional_index" in
-% pattern_routes.each do |route|
-% route[:positionals].each_with_index do |positional, index|
+  case "$node_id:$positional_index" in
+% pattern_nodes.each do |entry|
+% node = entry[:node]
+% node[:positionals].each_with_index do |positional, index|
 % next if positional[:repeatable]
-    <%= pattern_route_id route %>:<%= index %>)
+    <%= pattern_node_id node %>:<%= index %>)
 % if pattern_source_empty? positional[:source]
       return
 % else

data/lib/completely/version.rb

@@ -1,3 +1,3 @@
 module Completely
-  VERSION = '0.8.0.rc5'
+  VERSION = '0.8.0.rc6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: completely
 version: !ruby/object:Gem::Version
-  version: 0.8.0.rc5
+  version: 0.8.0.rc6
 platform: ruby
 authors:
 - Danny Ben Shitrit