atli 0.1.9 → 0.1.10

data/lib/thor/execution.rb

@@ -46,7 +46,8 @@ class Thor::Execution
   # Mixins
   # ============================================================================
   
-  include SemanticLogger::Loggable
+  # Add {.logger} and {#logger}
+  include NRSER::Log::Mixin
   
   
   # Attributes

data/lib/thor/parser/argument.rb

@@ -1,8 +1,51 @@
 class Thor
-  class Argument #:nodoc:
+  class Argument
+    
+    # Constants
+    # ========================================================================
+
     VALID_TYPES = [:numeric, :hash, :array, :string]
 
+    
+    # Mixins
+    # ========================================================================
+
+    include NRSER::Log::Mixin
+
+    
+    # Attributes
+    # ========================================================================
+
     attr_reader :name, :description, :enum, :required, :type, :default, :banner
+    
+
+    # Optional block to provide dynamic shell completion.
+    # 
+    # @return [nil]
+    #   This argument does not provide dynamic completion.
+    # 
+    # @return [Proc<() => Array<String>>]
+    #   Arity `0` proc that will be called with no arguments to provide 
+    #   dynamic completion options.
+    # 
+    # @return [Proc<(request:, klass:, command:) => Array<String>]
+    #   Arity `-1` proc that will be passed:
+    #   
+    #   -   {Thor::Completion::Bash::Request} `request:`
+    #       The completion request.
+    #       
+    #   -   {Class<Thor::Base>} `klass:`
+    #       The {Thor} or {Thor::Group} subclass being completed.
+    #       
+    #   -   {Thor::Command} `command:`
+    #       The command being completed.
+    #   
+    #   As in the arity `0` case, must return an array of string completion
+    #   options.
+    #     
+    attr_reader :complete
+    
+
     alias_method :human_name, :name
 
     def initialize(name, options = {})
@@ -10,16 +53,24 @@ class Thor
 
       type = options[:type]
 
-      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
-      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
+      if name.nil?
+        raise ArgumentError,
+          "#{class_name} name can't be nil."
+      end
+
+      if type && !valid_type?(type)
+        raise ArgumentError,
+          "Type :#{type} is not valid for #{class_name.downcase}s."
+      end
 
-      @name        = name.to_s
-      @description = options[:desc]
-      @required    = options.key?(:required) ? options[:required] : true
-      @type        = (type || :string).to_sym
-      @default     = options[:default]
-      @banner      = options[:banner] || default_banner
-      @enum        = options[:enum]
+      @name         = name.to_s
+      @description  = options[:desc]
+      @required     = options.key?(:required) ? options[:required] : true
+      @type         = (type || :string).to_sym
+      @default      = options[:default]
+      @banner       = options[:banner] || default_banner
+      @enum         = options[:enum]
+      @complete     = options[:complete]
 
       validate! # Trigger specific validations
     end

data/lib/thor/parser/arguments.rb

@@ -1,6 +1,8 @@
+require 'nrser'
+
 class Thor
   class Arguments # rubocop:disable ClassLength
-    include SemanticLogger::Loggable
+    include NRSER::Log::Mixin
     
     NUMERIC = /[-+]?(\d*\.\d+|\d+)/
 

data/lib/thor/parser/option.rb

@@ -3,6 +3,8 @@ require 'active_support/core_ext/string/inflections'
 
 class Thor
   class Option < Argument #:nodoc:
+    include NRSER::Log::Mixin
+
     attr_reader :aliases, :group, :lazy_default, :hide
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
@@ -78,6 +80,53 @@ class Thor
       @switch_name ||= dasherized? ? name : dasherize(name)
     end
 
+
+    def self.alias_to_switch_name alias_name
+      alias_name.sub( /\A\-{1,2}/, '' ).dasherize
+    end
+
+
+    def all_switch_names
+      [
+        name.dasherize,
+        *aliases.map { |alias_name|
+          self.class.alias_to_switch_name( alias_name )
+        }
+      ]
+    end
+
+
+    def short_switch_names
+      all_switch_names.select { |name| name.length == 1 }
+    end
+
+
+    def short_switch_tokens
+      short_switch_names.map { |name| "-#{ name }" }
+    end
+
+
+    def long_switch_names
+      all_switch_names.select { |name| name.length > 1 }
+    end
+
+
+    def long_switch_tokens
+      if boolean?
+        long_switch_names.flat_map { |name|
+          [ "--#{ name }", "--no-#{ name }" ]
+        }
+      else
+        long_switch_names.map { |name| "--#{ name }" }
+      end
+    end
+
+
+    def all_switch_tokens
+      [*long_switch_tokens, *short_switch_tokens]
+    end
+
+
     def human_name
       @human_name ||= dasherized? ? undasherize(name) : name
     end

data/lib/thor/parser/options.rb

@@ -65,19 +65,22 @@ class Thor
     # @param [Hash<Symbol, Thor::Option>] hash_options
     #   
     # 
-    def initialize  hash_options = {},
-                    defaults = {},
+    def initialize  options_to_parse_by_name = {},
+                    option_default_values = {},
                     stop_on_unknown = false,
                     disable_required_check = false
       @stop_on_unknown = stop_on_unknown
       @disable_required_check = disable_required_check
-      options = hash_options.values
-      super(options)
+
+      options = options_to_parse_by_name.values
+      super( options )
 
       # Add defaults
-      defaults.each do |key, value|
-        @assigns[key.to_s] = value
-        @non_assigned_required.delete(hash_options[key])
+      option_default_values.each do |option_name, value|
+        @assigns[ option_name.to_s ] = value
+
+        @non_assigned_required.delete \
+          options_to_parse_by_name[ option_name ]
       end
 
       @shorts = {}

data/lib/thor/version.rb

@@ -14,7 +14,7 @@ class Thor
   # 
   # @return [String]
   # 
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
   
   
   # The version of Thor that Atli is up to date with.
@@ -27,5 +27,16 @@ class Thor
   # 
   # @return [String]
   # 
-  THOR_VERSION = '0.1.9'
+  THOR_VERSION = '0.1.10'
+
+
+  # Are we running from the source code (vesus from a Gem install)?
+  # 
+  # Looks for the `//dev` directory, which is not included in the package.
+  # 
+  # @return [Boolean]
+  # 
+  def self.running_from_source?
+    ( ROOT + 'dev' ).directory?
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atli
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Neil Souza (Atli)
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-06 00:00:00.000000000 Z
+date: 2018-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.8
+        version: 0.3.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.8
+        version: 0.3.9
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -54,6 +54,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: yard-activesupport-concern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
@@ -91,13 +105,20 @@ files:
 - lib/thor/actions/file_manipulation.rb
 - lib/thor/actions/inject_into_file.rb
 - lib/thor/base.rb
+- lib/thor/base/arguments_concern.rb
 - lib/thor/base/class_methods.rb
 - lib/thor/base/common_class_options.rb
+- lib/thor/base/shared_concern.rb
+- lib/thor/base/shared_options_concern.rb
 - lib/thor/command.rb
 - lib/thor/completion/bash.rb
+- lib/thor/completion/bash/argument_mixin.rb
+- lib/thor/completion/bash/command_mixin.rb
+- lib/thor/completion/bash/request.rb
+- lib/thor/completion/bash/subcmd.rb
+- lib/thor/completion/bash/thor_mixin.rb
 - lib/thor/core_ext/hash_with_indifferent_access.rb
 - lib/thor/core_ext/io_binary_read.rb
-- lib/thor/core_ext/ordered_hash.rb
 - lib/thor/error.rb
 - lib/thor/example.rb
 - lib/thor/execution.rb

data/lib/thor/core_ext/ordered_hash.rb

@@ -1,129 +0,0 @@
-class Thor
-  module CoreExt
-    class OrderedHash < ::Hash
-      if RUBY_VERSION < "1.9"
-        def initialize(*args, &block)
-          super
-          @keys = []
-        end
-
-        def initialize_copy(other)
-          super
-          # make a deep copy of keys
-          @keys = other.keys
-        end
-
-        def []=(key, value)
-          @keys << key unless key?(key)
-          super
-        end
-
-        def delete(key)
-          if key? key
-            index = @keys.index(key)
-            @keys.delete_at index
-          end
-          super
-        end
-
-        def delete_if
-          super
-          sync_keys!
-          self
-        end
-
-        alias_method :reject!, :delete_if
-
-        def reject(&block)
-          dup.reject!(&block)
-        end
-
-        def keys
-          @keys.dup
-        end
-
-        def values
-          @keys.map { |key| self[key] }
-        end
-
-        def to_hash
-          self
-        end
-
-        def to_a
-          @keys.map { |key| [key, self[key]] }
-        end
-
-        def each_key
-          return to_enum(:each_key) unless block_given?
-          @keys.each { |key| yield(key) }
-          self
-        end
-
-        def each_value
-          return to_enum(:each_value) unless block_given?
-          @keys.each { |key| yield(self[key]) }
-          self
-        end
-
-        def each
-          return to_enum(:each) unless block_given?
-          @keys.each { |key| yield([key, self[key]]) }
-          self
-        end
-
-        def each_pair
-          return to_enum(:each_pair) unless block_given?
-          @keys.each { |key| yield(key, self[key]) }
-          self
-        end
-
-        alias_method :select, :find_all
-
-        def clear
-          super
-          @keys.clear
-          self
-        end
-
-        def shift
-          k = @keys.first
-          v = delete(k)
-          [k, v]
-        end
-
-        def merge!(other_hash)
-          if block_given?
-            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
-          else
-            other_hash.each { |k, v| self[k] = v }
-          end
-          self
-        end
-
-        alias_method :update, :merge!
-
-        def merge(other_hash, &block)
-          dup.merge!(other_hash, &block)
-        end
-
-        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
-        def replace(other)
-          super
-          @keys = other.keys
-          self
-        end
-
-        def inspect
-          "#<#{self.class} #{super}>"
-        end
-
-        private
-
-        def sync_keys!
-          @keys.delete_if { |k| !key?(k) }
-        end
-      end
-    end
-  end
-end