atli 0.1.9 → 0.1.10

data/lib/thor/base/class_methods.rb

@@ -129,94 +129,21 @@ module ClassMethods
   end
   
   
-  # Adds an argument to the class and creates an attr_accessor for it.
-  #
-  # Arguments are different from options in several aspects. The first one
-  # is how they are parsed from the command line, arguments are retrieved
-  # from position:
-  #
-  #   thor command NAME
-  #
-  # Instead of:
-  #
-  #   thor command --name=NAME
-  #
-  # Besides, arguments are used inside your code as an accessor
-  # (self.argument), while options are all kept in a hash (self.options).
-  #
-  # Finally, arguments cannot have type :default or :boolean but can be
-  # optional (supplying :optional => :true or :required => false), although
-  # you cannot have a required argument after a non-required argument. If
-  # you try it, an error is raised.
-  #
-  # ==== Parameters
-  # name<Symbol>:: The name of the argument.
-  # options<Hash>:: Described below.
-  #
-  # ==== Options
-  # :desc     - Description for the argument.
-  # :required - If the argument is required or not.
-  # :optional - If the argument is optional or not.
-  # :type     - The type of the argument, can be :string, :hash, :array,
-  #             :numeric.
-  # :default  - Default value for this argument. It cannot be required and
-  #             have default values.
-  # :banner   - String to show on usage notes.
-  #
-  # ==== Errors
-  # ArgumentError:: Raised if you supply a required argument after a non
-  #                 required one.
-  #
-  def argument(name, options = {})
-    is_thor_reserved_word?(name, :argument)
-    no_commands { attr_accessor name }
-
-    required = if options.key?(:optional)
-      !options[:optional]
-    elsif options.key?(:required)
-      options[:required]
-    else
-      options[:default].nil?
-    end
-
-    remove_argument name
-
-    if required
-      arguments.each do |argument|
-        next if argument.required?
-        raise ArgumentError,
-          "You cannot have #{name.to_s.inspect} as required argument " \
-          "after the non-required argument #{argument.human_name.inspect}."
-      end
-    end
-
-    options[:required] = required
-
-    arguments << Thor::Argument.new(name, options)
-  end
-  
-  
-  # Returns this class arguments, looking up in the ancestors chain.
-  #
-  # ==== Returns
-  # Array[Thor::Argument]
-  #
-  def arguments
-    @arguments ||= from_superclass(:arguments, [])
-  end
-  
-  
   # Adds a bunch of options to the set of class options.
   #
   #   class_options :foo => false, :bar => :required, :baz => :string
   #
   # If you prefer more detailed declaration, check class_option.
   #
-  # ==== Parameters
-  # Hash[Symbol => Object]
+  # @param [Hash<(String | Symbol), Object>] options
+  #   New option definitions to add via {#build_options}.
+  # 
+  # @return [HashWithIndifferentAccess<String, Thor::Option>]
+  #   Hash of option names to the option instances.
   #
-  def class_options(options = nil)
-    @class_options ||= from_superclass(:class_options, {})
+  def class_options options = nil
+    @class_options ||= \
+      from_superclass( :class_options, HashWithIndifferentAccess.new )
     build_options(options, @class_options) if options
     @class_options
   end
@@ -248,27 +175,6 @@ module ClassMethods
   end
   
   
-  # Removes a previous defined argument. If :undefine is given, undefine
-  # accessors as well.
-  #
-  # ==== Parameters
-  # names<Array>:: Arguments to be removed
-  #
-  # ==== Examples
-  #
-  #   remove_argument :foo
-  #   remove_argument :foo, :bar, :baz, :undefine => true
-  #
-  def remove_argument(*names)
-    options = names.last.is_a?(Hash) ? names.pop : {}
-
-    names.each do |name|
-      arguments.delete_if { |a| a.name == name.to_s }
-      undef_method name, "#{name}=" if options[:undefine]
-    end
-  end
-  
-  
   # Removes a previous defined class option.
   #
   # ==== Parameters
@@ -304,25 +210,24 @@ module ClassMethods
   
   # Returns the commands for this Thor class.
   #
-  # ==== Returns
-  # OrderedHash:: An ordered hash with commands names as keys and
-  #               Thor::Command objects as values.
+  # @return [HashWithIndifferentAccess<String, Thor::Command>]
+  # An hash with commands names as keys and Thor::Command objects as values.
   #
   def commands
-    @commands ||= Thor::CoreExt::OrderedHash.new
+    @commands ||= HashWithIndifferentAccess.new
   end
   alias_method :tasks, :commands
   
   
   # Returns the commands for this Thor class and all subclasses.
   #
-  # ==== Returns
-  # OrderedHash:: An ordered hash with commands names as keys and
-  #               Thor::Command objects as values.
+  # @return [HashWithIndifferentAccess<String, Thor::Command>]
+  #   An hash with commands names as keys and {Thor::Command}
+  #   objects as values.
   #
   def all_commands
     @all_commands ||= from_superclass(  :all_commands,
-                                        Thor::CoreExt::OrderedHash.new )
+                                        HashWithIndifferentAccess.new )
     @all_commands.merge!(commands)
   end
   alias_method :all_tasks, :all_commands
@@ -451,13 +356,12 @@ module ClassMethods
   # For details on why this is here see
   # {file:doc/files/notes/too-broken-to-fail.md Too Broken to Fail}.
   # 
-  def exec!(given_args = ARGV, config = {})
+  def exec! given_args = ARGV, config = {}
     execution = Thor::Execution.new thor_class:   self,
                                     given_args:   given_args,
                                     thor_config:  config
-    
     execution.exec!
-  end # #start
+  end # #exec!
   
 
   # Allows to use private methods from parent in child classes as commands.
@@ -485,7 +389,7 @@ module ClassMethods
         "#{namespace.inspect} namespace."
     end
     raise Thor::UndefinedCommandError,
-      "Could not find command #{command.inspect}."
+      "Could not find command #{command.inspect}, commands: #{ all_commands.keys }"
   end
   alias_method :handle_no_task_error, :handle_no_command_error
   
@@ -599,11 +503,12 @@ module ClassMethods
     # name<Symbol>:: The name of the argument.
     # options<Hash>:: Described in both class_option and method_option.
     # scope<Hash>:: Options hash that is being built up
-    def build_option(name, options, scope) #:nodoc:
-      scope[name] = Thor::Option.new(
+    def build_option(name, options, scope)
+      option = Thor::Option.new(
         name,
         options.merge(:check_default_type => check_default_type?)
       )
+      scope[option.name] = option
     end
     
     
@@ -612,11 +517,17 @@ module ClassMethods
     #
     #   build_options :foo => true, :bar => :required, :baz => :string
     #
-    # ==== Parameters
-    # Hash[Symbol => Object]
-    def build_options(options, scope) #:nodoc:
+    # @param [Hash<(String | Symbol), Object>] options
+    # 
+    # @param [HashWithIndifferentAccess<String, Thor::Option>] scope
+    # 
+    # @return [nil]
+    #   New {Thor::Option} are added to `scope`.
+    # 
+    def build_options options, scope
       options.each do |key, value|
-        scope[key] = Thor::Option.parse(key, value)
+        option = Thor::Option.parse key, value
+        scope[option.name] = option
       end
     end
     

data/lib/thor/base/shared_concern.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Deps
+# -----------------------------------------------------------------------
+
+require 'active_support/concern'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Base
+
+# Definitions
+# =======================================================================
+
+# Share stuff... define {Thor::Argument}, {Thor::Option} and whatever else
+# you like once then apply those definitions to many commands.
+# 
+module SharedConcern
+
+  extend ActiveSupport::Concern
+  
+  class_methods do
+  # ==========================================================================
+
+    def shared_defs
+      @shared_defs ||= []
+    end
+
+
+    # def normalize_kind input
+    #   {
+    #     'arg' => 'argument',
+
+    #   }
+    # end
+
+
+    def def_shared kind, name:, groups: nil, **options
+      shared_defs << {
+        name: name.to_s,
+        kind: kind,
+        groups: Set[*groups],
+        options: options,
+      }
+    end
+    
+    
+    def include_shared *names, kinds: nil, groups: nil, **overrides
+      find_shared( *names, kinds: kinds, groups: groups ).
+        each do |name:, kind:, groups:, options:|
+          send kind, name, **options.merge( overrides )
+        end
+    end
+
+
+    # Find shared options given names and groups.
+    # 
+    # @param [*<Symbol>] names
+    #   Individual shared option names to include.
+    # 
+    # @param [nil | Symbol | Enumerable<Symbol>] groups:
+    #   Single or list of shared option groups to include.
+    # 
+    # @return [Hash<Symbol, Thor::SharedOption>]
+    #   Hash mapping option names (as {Symbol}) to instances.
+    # 
+    def find_shared *names, kinds: nil, groups: nil
+      groups_set = Set[*groups]
+      kinds_set = Set[*kinds]
+      names.map! &:to_s
+
+      results = []
+      
+      shared_defs.each do |name:, kind:, groups:, options:|
+        match = {}
+        
+        if names.include? name
+          match[:name] = true
+        end
+        
+        match_groups = groups & groups_set
+          
+        unless match_groups.empty?
+          match[:groups] = match_groups
+        end
+
+        if kinds_set.include? kind
+          match[:kind] = true
+        end
+        
+        unless match.empty?
+          results << {
+            name: name,
+            kind: kind,
+            groups: groups,
+            options: options,
+          }
+        end
+      end
+    end # #find_shared
+
+  end # class_methods ********************************************************
+  
+end # module SharedConcern
+
+# /Namespace
+# =======================================================================
+
+end # module Base
+end # class Thor

data/lib/thor/base/shared_options_concern.rb

@@ -0,0 +1,235 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+
+# Requirements
+# =======================================================================
+
+# Deps
+# -----------------------------------------------------------------------
+
+require 'active_support/concern'
+
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements/types'
+using NRSER::Types
+
+# Namespace
+# =======================================================================
+
+class   Thor
+module  Base
+
+
+# Definitions
+# =======================================================================
+
+# Support for sharing {Thor::Option} declarations among many 
+# {Thor::Command} (methods). All class methods.
+# 
+module SharedOptionsConcern
+  
+  # Mixins
+  # ========================================================================
+
+  # Get concerned
+  extend ActiveSupport::Concern
+
+  
+  class_methods do
+  # ==========================================================================
+
+    # Declare a shared method option with an optional groups that can then
+    # be added by name or group to commands.
+    # 
+    # The shared options can then be added to methods individually by name and
+    # collectively as groups with {Thor.include_method_options}.
+    # 
+    # @example
+    #   class MyCLI < Thor
+    #     
+    #     # Declare a shared option:
+    #     shared_option :force,
+    #       groups: :write,
+    #       desc: "Force the operation",
+    #       type: :boolean
+    #     
+    #     # ...
+    #     
+    #     desc            "write [OPTIONS] path",
+    #                     "Write to a path"
+    #     
+    #     # Add the shared options to the method:
+    #     include_options groups: :write
+    #     
+    #     def write       path
+    #       
+    #       # Get a slice of `#options` with any of the `:write` group options
+    #       # that were provided and use it in a method call:
+    #       MyModule.write path, **option_kwds( groups: :write )
+    #       
+    #     end
+    #   end
+    # 
+    # @param [Symbol] name
+    #   The name of the option.
+    # 
+    # @param [**<Symbol, V>] options
+    #   Keyword args used to initialize the {Thor::SharedOption}.
+    #   
+    #   All +**options+ are optional.
+    # 
+    # @option options [Symbol | Array<Symbol>] :groups
+    #   One or more _shared_ _option_ _group_ that the new option will belong
+    #   to.
+    #   
+    #   Examples:
+    #     groups: :read
+    #     groups: [:read, :write]
+    #   
+    #   *NOTE*  The keyword is +groups+ with an +s+! {Thor::Option} already has
+    #           a +group+ string attribute that, as far as I can tell, is only
+    #           
+    # @option options [String] :desc
+    #   Description for the option for help and feedback.
+    # 
+    # @option options [Boolean] :required
+    #   If the option is required or not.
+    # 
+    # @option options [Object] :default
+    #   Default value for this argument.
+    #   
+    #   It cannot be +required+ and have default values.
+    # 
+    # @option options [String | Array<String>] :aliases
+    #   Aliases for this option.
+    #   
+    #   Examples:
+    #     aliases: '-s'
+    #     aliases: '--other-name'
+    #     aliases: ['-s', '--other-name']
+    # 
+    # @option options [:string | :hash | :array | :numeric | :boolean] :type
+    #   Type of acceptable values, see
+    #   {types for method options}[https://github.com/erikhuda/thor/wiki/Method-Options#types-for-method_options]
+    #   in the Thor wiki.
+    # 
+    # @option options [String] :banner
+    #   String to show on usage notes.
+    # 
+    # @option options [Boolean] :hide
+    #   If you want to hide this option from the help.
+    # 
+    # @return (see .build_shared_option)
+    # 
+    def shared_method_option name, **options
+      # Don't think the `:for` option makes sense... that would just be a
+      # regular method option, right? I guess `:for` could be an array and
+      # apply the option to each command, but it seems like that would just
+      # be better as an extension to the {.method_option} behavior.
+      # 
+      # So, we raise if we see it
+      if options.key? :for
+        raise ArgumentError,
+          ".shared_method_option does not accept the `:for` option"
+      end
+      
+      build_shared_option(name, options)
+    end # #shared_method_option
+
+    alias_method :shared_option, :shared_method_option
+
+
+    # @return [Hash<Symbol, Thor::SharedOption]
+    #   Get all shared options
+    # 
+    def shared_method_options(options = nil)
+      @shared_method_options ||= begin
+        # Reach up the inheritance chain, if there's anyone there
+        if superclass.respond_to? __method__
+          superclass.send( __method__ ).dup
+        else
+          # Or just default to empty
+          {}
+        end
+      end
+      
+      if options
+        # We don't support this (yet at least)
+        raise NotImplementedError,
+          "Bulk set not supported, use .shared_method_option"
+        # build_shared_options(options, @shared_method_options)
+      end
+      @shared_method_options
+    end
+
+    alias_method :shared_options, :shared_method_options
+
+
+    # Find shared options given names and groups.
+    # 
+    # @param [*<Symbol>] names
+    #   Individual shared option names to include.
+    # 
+    # @param [nil | Symbol | Enumerable<Symbol>] groups:
+    #   Single or list of shared option groups to include.
+    # 
+    # @return [Hash<Symbol, Thor::SharedOption>]
+    #   Hash mapping option names (as {Symbol}) to instances.
+    # 
+    def find_shared_method_options *names, groups: nil
+      groups_set = Set[*groups]
+      
+      shared_method_options.each_with_object( {} ) do |(name, option), results|
+        match = {}
+        
+        if names.include? name
+          match[:name] = true
+        end
+        
+        match_groups = option.groups & groups_set
+          
+        unless match_groups.empty?
+          match[:groups] = match_groups
+        end
+        
+        unless match.empty?
+          results[name] = {
+            option: option,
+            match: match,
+          }
+        end
+      end
+    end # #find_shared_method_options
+
+    alias_method :find_shared_options, :find_shared_method_options
+
+
+    # Add the {Thor::SharedOption} instances with +names+ and in +groups+ to
+    # the next defined command method.
+    # 
+    # @param (see .find_shared_method_options)
+    # @return (see .find_shared_method_options)
+    # 
+    def include_method_options *names, groups: nil
+      find_shared_method_options( *names, groups: groups ).
+        each do |name, result|
+          method_options[name] = Thor::IncludedOption.new **result
+        end
+    end
+    
+    alias_method :include_options, :include_method_options
+
+  end # class_methods ********************************************************
+  
+end # module SharedOptionsConcern
+
+
+# /Namespace
+# =======================================================================
+
+end # module Base
+end # class Thor