atli 0.1.9 → 0.1.10

data/lib/thor/command.rb

@@ -1,5 +1,5 @@
-require 'semantic_logger'
-require_relative './completion/bash'
+require 'shellwords'
+require 'nrser'
 
 class Thor
   class Command < Struct.new( :name,
@@ -7,10 +7,11 @@ class Thor
                               :long_description,
                               :usage,
                               :examples,
+                              :arguments,
                               :options,
                               :ancestor_name )
-    include SemanticLogger::Loggable
-    include Thor::Completion::Bash::Command
+    
+    include NRSER::Log::Mixin
     
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
@@ -19,6 +20,7 @@ class Thor
                     long_description: nil,
                     usage: nil,
                     examples: [],
+                    arguments: [],
                     options: nil
       super \
         name.to_s,
@@ -26,6 +28,7 @@ class Thor
         long_description,
         usage,
         examples,
+        arguments,
         options || {}
     end
 
@@ -176,10 +179,11 @@ class Thor
       formatted ||= "".dup
 
       # Add usage with required arguments
-      formatted << if klass && !klass.arguments.empty?
+      arguments = klass&.arguments( command: self ) || []
+      formatted << unless arguments.empty?
                      usage.to_s.gsub(/^#{name}/) do |match|
                        match  << " " \
-                              << klass.arguments.map(&:usage).compact.join(" ")
+                              << arguments.map(&:usage).compact.join(" ")
                      end
                    else
                      usage.to_s
@@ -192,6 +196,47 @@ class Thor
       formatted.strip
     end
 
+
+    # The command's name as depicted in it's {#usage} message.
+    # 
+    # We prefer this format when completing commands because it's how we 
+    # depict the command to the user.
+    # 
+    # @see Thor::Completion
+    # @see #names_by_format
+    # 
+    # @return [String]
+    # 
+    def usage_name
+      @usage_name ||= usage.shellsplit[0]
+    end
+
+
+    # The name formats we recognize for the command, in command completion
+    # resolution order.
+    # 
+    # @note
+    #   In reality, since input words have `-` replaced with `_` when finding
+    #   their instances during execution, 
+    # 
+    # @return [Hash<Symbol, String>]
+    #   Keys and values in order (and order matters when completing commands,
+    #   first result takes priority):
+    #   
+    #   1.  `usage:`    {#usage_name}
+    #   2.  `method:`   {#name}, which is the command's actual method name,
+    #                   and hence "underscored".
+    #   3.  `dashed:`   A dash-separated version of {#name}.
+    # 
+    def names_by_format
+      @names_by_format ||= {
+        usage:  usage_name,
+        method: name,
+        dashed: name.dasherize,
+      }.freeze
+    end
+
+
   protected
 
     def not_debugging?(instance)

data/lib/thor/completion/bash.rb

@@ -1,27 +1,15 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# Requirements
-# =======================================================================
-
-# Stdlib
-# -----------------------------------------------------------------------
-
-# Deps
-# -----------------------------------------------------------------------
-
-require 'nrser'
-require 'nrser/labs/i8'
 
 # Project / Package
 # -----------------------------------------------------------------------
 
-
-# Refinements
-# =======================================================================
-
-require 'nrser/refinements/types'
-using NRSER::Types
+require_relative './bash/argument_mixin'
+require_relative './bash/command_mixin'
+require_relative './bash/request'
+require_relative './bash/subcmd'
+require_relative './bash/thor_mixin'
 
 
 # Namespace
@@ -36,122 +24,79 @@ module  Completion
 
 # Experimental support for Bash completions.
 # 
+# To enable, require this module and add the following to your entry-point
+# {Thor} subclass:
+# 
+#     include Thor::Completion::Bash
+# 
+# You should now have a `bash-complete` subcommand present. You can test
+# this out with
+# 
+#     YOUR_EXE bash-complete help
+# 
+# where `YOUR_EXE` is replaced with your executable name.
+# 
+# You should see output like
+#     
+#     Commands:
+#       locd bash-complete complete -- CUR PREV CWORD SPLIT WORDS...  # (...)
+#       locd bash-complete help [COMMAND]                             # (...)
+#       locd bash-complete setup                                      # (...)
+# 
+# 
+# Then, to hook your executable into Bash's `compelte` builtin:
+# 
+#     source <(YOUR_EXE bash-complete setup)
+# 
+# where, again, `YOUR_EXE` is replaced with your executable name.
+# 
 module Bash
   
-  Request = I8::Struct.new \
-    cur: t.str,
-    prev: t.str,
-    cword: t.non_neg_int,
-    split: t.bool,
-    words: t.array( t.str )
-  
-  # Needs to be mixed in to {Thor}. It's all class methods at the moment.
+  # Hook to setup Bash complete on including {Thor} subclass.
   # 
-  # @todo
-  #   Deal with that {Thor::Group} thing? I never use it...
-  #   
-  module Thor
-    
-    # Methods to be mixed as class methods in to {Thor}.
-    # 
-    module ClassMethods
-      
-      # Get this class' {Thor::Command} instances, keyed by how their names will
-      # appear in the UI (replace `_` with `-`).
-      # 
-      # @param [Boolean] include_hidden:
-      #   When `true`, "hidden" commands will also be included.
-      # 
-      # @return [Hash<String, Thor::Command>]
-      # 
-      def all_commands_by_ui_name include_hidden: false
-        all_commands.
-          each_with_object( {} ) { |(name, cmd), hash|
-            next if cmd.hidden? && !include_hidden
-            hash[ name.tr( '_', '-' ) ] = cmd
-          }
-      end # .all_commands_by_ui_name
-
-      # 
-      # 
-      def bash_complete comp_req:, index:
-        # Find the command, if any
-        
-        logger.info __method__,
-          comp_req: comp_req,
-          index: index,
-          word: comp_req.words[index]
-        
-        scan_index = index
-        
-        while (comp_req.words[scan_index] || '').start_with? '-'
-          scan_index += 1
-        end
-        
-        cmd_ui_name = comp_req.words[scan_index] || ''
-        
-        cmd = all_commands_by_ui_name[cmd_ui_name]
-        
-        if cmd.nil?
-          return all_commands_by_ui_name.keys.select { |ui_name|
-            ui_name.start_with? cmd_ui_name
-          }
-        end
-        
-        index = scan_index + 1
-        
-        # is it a subcommand?
-        if subcommand_classes.key? cmd.name
-          # It is, hand it off to there
-          subcommand_classes[cmd.name].bash_complete \
-            comp_req: comp_req,
-            index: index
-        else
-          # It's a command, have that handle it
-          cmd.bash_complete \
-            comp_req: comp_req,
-            index: index
-        end
-      end
-      
-    end # module ClassMethods
-    
-    # Hook to mix {ClassMethods} in on include.
-    # 
-    def self.included base
-      base.extend ClassMethods
-    end
-    
-  end # module Thor
-  
-  
-  # Methods that need to mixed in to {Thor::Command}.
+  # 1.  Mixes {ThorMixin} into {Thor}.
+  # 2.  Mixes {CommandMixin} into {Thor::Command}.
+  # 3.  Creates a new subclass of {Subcmd} boun0d to `base` and adds that
+  #     as `bash-complete` to `base` via {Thor.subcommand}.
+  # 
+  # @param [Class<Thor>] base
+  #   The class that inluded {Thor::Completion::Bash}. Should be a {Thor}
+  #   subclass and be the main/entry command of the program, though neither
+  #   of these are enforced.
   # 
-  module Command
+  # @return [nil]
+  #   Totally side-effect based.
+  # 
+  def self.included base
     
-    def bash_complete comp_req:, index:
-      # TODO Handle
-      return [] if comp_req.split
-      
-      logger.info __method__,
-        cmd_name: name,
-        options: options
-      
-      options.
-        each_with_object( [ '--help' ] ) { |(name, opt), results|
-          ui_name = name.to_s.tr( '_', '-' )
-          
-          if opt.type == :boolean
-            results << "--#{ ui_name }"
-            results << "--no-#{ ui_name }"
-          else
-            results << "--#{ ui_name }="
-          end
-        }.
-        select { |term| term.start_with? comp_req.cur }
+    unless Thor.include? ThorMixin
+      Thor.send :include, ThorMixin
+    end
+
+    unless Thor::Command.include? CommandMixin
+      Thor::Command.send :include, CommandMixin
+    end
+
+    unless Thor::Argument.include? ArgumentMixin
+      Thor::Argument.send :include, ArgumentMixin
     end
+
+    subcmd_class = Class.new Subcmd do
+      def self.target
+        @target
+      end
+    end
+
+    subcmd_class.instance_variable_set :@target, base
     
-  end # module Command
+    # Install {Subcmd} as a subcommand
+    base.send :subcommand,
+              'bash-complete',
+              subcmd_class,
+      desc:   "Support for Bash command completion."
+
+    nil
+  end # #.included
   
 end # module Bash
 

data/lib/thor/completion/bash/argument_mixin.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+require 'nrser'
+require 'nrser/labs/i8'
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Completion
+module  Bash
+
+
+# Definitions
+# =======================================================================
+
+# Methods mixed in to {Thor::Argument}.
+# 
+module ArgumentMixin
+
+  def bash_complete request:, klass:
+    # logger.level = :trace
+
+    logger.trace "ENTERING #{ self.class }##{ __method__ }",
+      name: name,
+      complete: complete,
+      request: request,
+      klass: klass
+
+    unless complete
+      return [].tap { |results|
+        logger.trace "No `#complete` proc to call",
+          results: results
+      }
+    end
+
+    values = case complete.arity
+    when 0
+      complete.call
+    else
+      complete.call request: request, klass: klass, command: self
+    end
+
+    logger.trace "Got values", values: values
+
+    values.
+      select { |value| value.start_with? request.cur }.
+      tap { |results|
+        logger.trace "Selected values for argument #{ name }",
+          results: results
+      }
+  end
+  
+end # module ArgumentMixin
+
+
+# /Namespace
+# =======================================================================
+
+end # module  Bash
+end # module  Completion
+end # class   Thor

data/lib/thor/completion/bash/command_mixin.rb

@@ -0,0 +1,236 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+require 'nrser'
+require 'nrser/labs/i8'
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Completion
+module  Bash
+
+
+# Definitions
+# =======================================================================
+
+# Methods mixed in to {Thor::Command}.
+# 
+module CommandMixin
+
+  def bash_complete_cur_split request:
+    # The input was split at a `=`, so we're looking for a value for
+    # an option whose name will be at {Request#prev}.
+
+    logger.trace "Processing split Bash complete request...",
+      command: self.name,
+      request: request
+
+    matching_options = options.values.select { |option|
+      option.long_switch_tokens.
+        reject { |token| token.end_with? '=' }.
+        include? request.prev
+    }
+
+    case matching_options.length
+    when 0
+      return [].tap { |results|
+        logger.trace "No matching options found",
+          results: results,
+          options: options.transform_values { |option|
+            {
+              tokens: option.all_switch_tokens,
+              names: option.all_switch_names,
+            }
+          }
+      }
+
+    when 1
+      option = matching_options[0]
+
+      logger.trace "Unique option found for `request.prev`",
+        prev: request.prev,
+        option: option
+      
+      if option.enum
+        return option.enum.
+          select { |value|
+            value.to_s.start_with? request.cur
+          }.
+          tap { |results|
+            logger.trace \
+              "Matched against enum option #{ option.name }",
+              prev: request.prev,
+              results: results,
+              option: option
+          }
+
+      elsif option.complete
+        return option.complete.call.
+          select { |value|
+            value.to_s.start_with? request.cur
+          }.
+          tap { |results|
+            logger.trace \
+              "Matched against complete option #{ option.name }",
+              prev: request.prev,
+              results: results,
+              option: option
+          }
+
+      else
+        return [].tap { |results|
+          logger.trace \
+            ( "Matched against non-enum option #{ option.name } " +
+              "but we don't have any completions to provide" ),
+            prev: request.prev,
+            results: results,
+            option: option
+        }
+      end
+
+    else
+      return [].tap { |results|
+        logger.trace "Multiple options found for prev",
+          results: results,
+          prev: request.prev,
+          options: matching_options
+      }
+    end
+  end
+
+  
+  def bash_complete_cur request:, arg_count:, klass:
+    return bash_complete_cur_split( request: request ) if request.split
+    
+    if request.cur == ''
+      results = [ '--help' ]
+
+      argument = klass.arguments( command: self )[arg_count]
+
+      if argument
+        results += argument.bash_complete( request: request, klass: klass )
+      end
+
+      results += options.values.flat_map { |option| option.long_switch_tokens }
+
+      return results.
+        tap { |results|
+          logger.trace "`request.cur` is ''; returning all long opts",
+            results: results
+        }
+    end
+
+    if request.cur.start_with? '-'
+      return options.values.flat_map { |option|
+        option.long_switch_names.flat_map { |name|
+          if option.boolean?
+            [ "--#{ name }", "--no-#{ name }" ]
+          else
+            "--#{ name }="
+          end
+        }
+      }.
+      +( [ '--help' ] ).
+      select { |token| token.start_with? request.cur }.
+      tap { |results|
+        logger.trace "Completing partial switch token",
+          results: results
+      }
+    end
+
+    argument = klass.arguments( command: self )[arg_count]
+    if argument
+      return argument.
+        bash_complete( request: request, klass: klass).
+        tap { |results|
+          logger.trace "We b here"
+        }
+    end
+
+    return []
+  end
+
+
+  def bash_complete request:, index:, klass:
+    # logger.level = :trace
+
+    logger.trace "ENTERING #{ self.class }##{ __method__ }",
+      request: request,
+      index: index,
+      index_word: request.words[index]
+
+    # Index we'll increment as we scan past options
+    scan_index = index
+    arg_count = 0
+    
+    # Skip over args (for now)
+    while scan_index < request.cword &&
+          scan_index < request.words.length &&
+          !request.words[scan_index].start_with?( '-' )
+      scan_index += 1
+      arg_count += 1
+    end
+
+    if  scan_index == request.cword ||
+        ( request.split &&
+          scan_index == request.cword - 1 )
+      return bash_complete_cur request: request, arg_count: arg_count, klass: klass
+    end
+
+    unless scan_index < request.words.length
+      # We ran out of words without hitting a command name or ending 
+      # empty string (for which we would provide all commands as options)
+      # 
+      # TODO  In the future we can deal with half-written class options
+      #       I guess? Maybe? But for now we just give up.
+      # 
+      return [].tap { |results|
+        logger.trace "No option or empty string found",
+          results: []
+      }
+    end
+
+    # match_word = request.words[scan_index]
+
+    # matching_options = options.values.select { |option|
+    #   option.all_switch_tokens.any? { |token| token.start_with? match_word }
+    # }
+
+    return [].tap { |results|
+      logger.trace "Not implemented",
+        results: results
+    }
+    
+  end
+  
+end # module CommandMixin
+
+
+# /Namespace
+# =======================================================================
+
+end # module  Bash
+end # module  Completion
+end # class   Thor