atli 0.1.9 → 0.1.10

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

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Deps
+# -----------------------------------------------------------------------
+
+require 'nrser'
+require 'nrser/labs/i8'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Completion
+module  Bash
+
+# Definitions
+# =======================================================================
+  
+# Structre to hold Bash complete request parameters
+class Request < I8::Struct.new(
+  cur: t.str,
+  prev: t.str,
+  cword: t.non_neg_int,
+  split: t.bool,
+  words: t.array( t.str )
+)
+  
+end # class Request
+
+
+# /Namespace
+# =======================================================================
+
+end # module Bash
+end # module  Completion
+end # class   Thor

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

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# ========================================================================
+
+# Project / Package
+# ------------------------------------------------------------------------
+
+# Need to make sure {Thor} is loaded first in case a user file requires
+# us here beforehand
+require 'thor'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Completion
+module  Bash
+
+
+# Definitions
+# =======================================================================
+
+# {Thor} added as a {Thor.subcommand} to the includer of 
+# {Thor::Completion::Bash} to expose Bash completion endpoints.
+# 
+class Subcmd < ::Thor
+
+  # Commands
+  # ========================================================================
+
+  desc  'complete -- CUR PREV CWORD SPLIT WORDS...',
+        "Provide Bash completions"
+  
+  # Execute Bash completion.
+  # 
+  # @param [Array] *_
+  #   Ignored - input custom read from `ARGV`.
+  # 
+  # @return [void]
+  #   Never returns - manually calls `exit` when done.
+  # 
+  def complete *_
+    # logger.level = :trace
+
+    logger.trace "Starting Bash complete...",
+      ARGV: ARGV,
+      args: args
+
+    args = ARGV.dup
+
+    args.shift while args[0] != '--'
+    args.shift
+
+    cur, prev, cword, split, *words = args
+
+    request = Request.new \
+      cur: cur, # options[:cur],
+      prev: prev, # options[:prev],
+      cword: cword.to_i, # options[:cword],
+      split: split.truthy?, # options[:split],
+      words: words
+
+    logger.trace "Bash complete Request loaded",
+      request: request
+
+    results = begin
+      self.class.target.bash_complete( request: request, index: 1 )
+    rescue StandardError => error
+      logger.error "Error raised processing Bash complete request",
+        { request: request },
+        error
+      
+      []
+    end
+
+    joined = results.shelljoin
+
+    logger.trace "Sending Bash compelte response",
+      request: request,
+      results: results,
+      joined: joined
+
+    puts joined
+    exit true
+  end # #complete
+
+
+  desc  'setup',
+        "Source this output in your shell or profile to install."
+  
+  long_desc <<~END
+    Prints Bash source code to STDOUT that hooks `complete` into the exe.
+  END
+
+  example "source <(#{ $0 } bash-complete setup)"
+
+  # Print Bash source code to hook into `complete` to `$stdout`.
+  # 
+  # @return [nil]
+  # 
+  def setup
+    bin = File.basename $0
+    name = bin.underscore
+
+    erb_src_path = ::Thor::ROOT.join  'support',
+                                      'completion',
+                                      'complete.inc.bash.erb'
+
+    erb_src = erb_src_path.read
+
+    bash_src = binding.erb erb_src
+
+    puts bash_src
+
+    nil
+  end # #setup
+
+end # class Subcmd
+
+
+# /Namespace
+# =======================================================================
+
+end # module  Bash
+end # module  Completion
+end # class   Thor

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

@@ -0,0 +1,250 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Completion
+module  Bash
+
+
+# Definitions
+# =======================================================================
+
+# To be mixed in to {Thor}. It's all class methods at the moment.
+# 
+# @todo
+#   Deal with that {Thor::Group} thing? I never use it...
+#   
+module ThorMixin
+  
+  # Methods to be mixed as class methods in to {Thor}.
+  # 
+  module ClassMethods
+
+    # Handles Bash completion requests at the {Thor} *class* level.
+    # 
+    # This consists of:
+    # 
+    # 1.  Finding the next word in the `request` at of after `index` that
+    #     identifies next the command or subcommand.
+    #     
+    #     **NOTE** This is done by simply scanning over words that start 
+    #     with `-`, which will not work for options that take values as
+    #     separate shell words.
+    #     
+    # 2.  Looking for an exact match command or subcommand to the word from
+    #     (1), and passing processing off to the respective {Thor::Command}
+    #     instance or {Thor::Base} subclass.
+    # 
+    # 3.  Or returning an array of "starts with" matches for available
+    #     {Thor::Base::ClassMethods#all_commands} and any partial input.
+    #     
+    #     Checks against both {Thor::Command#name} ("method" name) and
+    #     {Thor::Command#usage_name}, preferring usage name.
+    # 
+    # @param [Request] request:
+    #   
+    # 
+    def bash_complete request:, index:
+      # logger.level = :trace
+
+      logger.trace __method__,
+        request: request,
+        index: index,
+        word: request.words[index]
+      
+      # Index we'll incremenet as we scan past options
+      scan_index = index
+      
+      while scan_index < request.cword &&
+            scan_index < request.words.length &&
+            request.words[scan_index].start_with?( '-' )
+        scan_index += 1
+      end
+
+      if scan_index == request.cword
+        return bash_complete_cur request: request
+      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 command or empty string found",
+            results: []
+        }
+      end
+      
+      # OK, we should have either '' or something we can match
+      match_word = request.words[scan_index]
+
+      # We have nothing, return all commands
+      if match_word == ''
+        return all_commands.values.map( &:usage_name ).tap { |results|
+          logger.trace "Empty match word, returning all commands",
+            results: results
+        }
+      end
+
+      # See what possibilities we have
+      possibilities = find_command_possibilities match_word.tr( '-', '_' )
+
+      case possibilities.length
+      when 0
+        # We couldn't match anything
+        logger.trace "Found no command possibilities",
+          match_word: match_word,
+          results: []
+
+        return []
+
+      when 1
+        # We have a unique match
+
+        logger.trace "Unique command matched",
+          match_word: match_word,
+          match: possibilities[0]
+      
+        # pass to below
+
+      else
+        # There is more than one possbility, but we're trying to fill in 
+        # something later on, so we're SO
+        return []
+      end
+
+      # See if we're got an extact match
+      cmd = all_commands[ possibilities[0].underscore ]
+      
+      # Bump the index to the scan index + 1 to go past the word we just
+      # used to find `cmd`
+      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 \
+          request: request,
+          index: index
+      else
+        cmd.bash_complete request: request, index: index, klass: self
+      end
+    end # #bash_complete
+
+
+    
+    private
+    # ========================================================================
+
+      def bash_complete_cur request:
+        logger.trace "START #{ self.class.safe_name }.#{ __method__ }",
+          cur: request.cur
+
+        cur_method_name = if request.cur.start_with? '-'
+          request.cur
+        else
+          request.cur.tr( '-', '_' )
+        end
+
+        method_name_matches = find_command_possibilities( cur_method_name ).map &:to_s
+
+        logger.trace "Matched #{ method_name_matches.length } method name(s)",
+          matches: method_name_matches # ,
+          # all_method_names: all_commands.keys,
+          # map: map
+        
+        case method_name_matches.length
+        when 0
+          return [].tap { |results|
+            logger.trace "No commands matched",
+              results: results
+          }
+        
+        when 1
+          method_name = method_name_matches[0]
+
+          logger.trace "Found unique method name",
+            method_name: method_name
+
+          cmd = all_commands[ method_name ] || all_commands[ map[ method_name ].to_s ]
+
+          logger.trace "Got command",
+            command: cmd
+
+          cmd.names_by_format.each { |format, name|
+            if name.start_with?( request.cur )
+              return [ name ].tap { |results|
+                logger.trace \
+                  "Prefix-matched cur against cmd's #{ format } name",
+                  name_format: format,
+                  results: results,
+                  cmd: cmd
+              }
+            end
+          }
+
+          matching_mappings = map.map { |map_name, cmd_name|
+            map_name.to_s if  cmd.name == cmd_name.to_s &&
+                              map_name.to_s.start_with?( request.cur )
+          }.compact
+
+          return matching_mappings unless matching_mappings.empty?
+
+          return [ request.cur ]
+
+        else
+          # There is more than one possbility...
+
+          cmd_matches = method_name_matches.map { |method_name|
+            all_commands[ method_name ] || all_commands[ map[ method_name ].to_s ]
+          }.uniq
+
+          logger.trace "Unique command matches",
+            cmd_matches: cmd_matches
+
+          usage_name_results = cmd_matches.map( &:usage_name ).select { |usage_name|
+            usage_name.start_with? request.cur
+          }
+
+          return usage_name_results unless usage_name_results.empty?
+
+          return method_name_matches.select { |method_name|
+            method_name.start_with? request.cur
+          }
+        end
+      end # #bash_complete_cur
+      
+    public # end private *****************************************************
+
+  end # module ClassMethods
+  
+
+  # Hook to mix {ClassMethods} in on include.
+  # 
+  def self.included base
+    base.extend ClassMethods
+  end
+
+end # module ThorMixin
+
+
+# /Namespace
+# =======================================================================
+
+end # module  Bash
+end # module  Completion
+end # class   Thor

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -1,5 +1,12 @@
+# Namespace
+# ========================================================================
+
 class Thor
 module CoreExt
+
+# Definitions
+# ========================================================================
+
 # A hash with indifferent access and magic predicates.
 #
 #   hash = HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
@@ -34,4 +41,11 @@ class HashWithIndifferentAccess < ::HashWithIndifferentAccess #:nodoc:
     
   public # end protected ***************************************************
   
-end; end; end
+end
+
+
+# /Namespace
+# ========================================================================
+
+end # module CoreExt
+end # class Thor