atli 0.1.2 → 0.1.3

data/lib/thor/base.rb

@@ -1,3 +1,15 @@
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+require 'nrser'
+
+# Project / Package
+# -----------------------------------------------------------------------
 require "thor/command"
 require "thor/core_ext/hash_with_indifferent_access"
 require "thor/core_ext/ordered_hash"
@@ -7,6 +19,16 @@ require "thor/parser"
 require "thor/shell"
 require "thor/line_editor"
 require "thor/util"
+require 'thor/execution'
+require 'thor/base/common_class_options'
+
+
+# Refinements
+# =======================================================================
+
+using NRSER
+using NRSER::Types
+
 
 class Thor
   autoload :Actions,    "thor/actions"
@@ -148,47 +170,69 @@ class Thor
       
     # end protected
     
+    
+    # Module Methods
+    # ============================================================================
+    
+    # Hook called when {Thor::Base} is mixed in ({Thor} and {Thor::Group}).
+    # 
+    # Extends `base` with {Thor::Base::ClassMethods}, and includes
+    # {Thor::Invocation} and {Thor::Shell} in `base` as well.
+    # 
+    # @param [Module] base
+    #   Module (or Class) that included {Thor::Base}.
+    # 
+    # @return [void]
+    # 
+    def self.included base
+      base.extend ClassMethods
+      base.send :include, Invocation
+      base.send :include, Shell
+      
+      base.no_commands {
+        base.send :include, SemanticLogger::Loggable
+      }
+      
+    end
 
-    class << self
-      def included(base) #:nodoc:
-        base.extend ClassMethods
-        base.send :include, Invocation
-        base.send :include, Shell
-      end
+    # Returns the classes that inherits from Thor or Thor::Group.
+    #
+    # ==== Returns
+    # Array[Class]
+    #
+    def self.subclasses
+      @subclasses ||= []
+    end
 
-      # Returns the classes that inherits from Thor or Thor::Group.
-      #
-      # ==== Returns
-      # Array[Class]
-      #
-      def subclasses
-        @subclasses ||= []
-      end
+    # Returns the files where the subclasses are kept.
+    #
+    # ==== Returns
+    # Hash[path<String> => Class]
+    #
+    def self.subclass_files
+      @subclass_files ||= Hash.new { |h, k| h[k] = [] }
+    end
 
-      # Returns the files where the subclasses are kept.
-      #
-      # ==== Returns
-      # Hash[path<String> => Class]
-      #
-      def subclass_files
-        @subclass_files ||= Hash.new { |h, k| h[k] = [] }
+    # Whenever a class inherits from Thor or Thor::Group, we should track the
+    # class and the file on Thor::Base. This is the method responsible for it.
+    #
+    def self.register_klass_file(klass) #:nodoc:
+      file = caller[1].match(/(.*):\d+/)[1]
+      unless Thor::Base.subclasses.include?(klass)
+        Thor::Base.subclasses << klass
       end
 
-      # Whenever a class inherits from Thor or Thor::Group, we should track the
-      # class and the file on Thor::Base. This is the method responsible for it.
-      #
-      def register_klass_file(klass) #:nodoc:
-        file = caller[1].match(/(.*):\d+/)[1]
-        unless Thor::Base.subclasses.include?(klass)
-          Thor::Base.subclasses << klass
-        end
-
-        file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
-        file_subclasses << klass unless file_subclasses.include?(klass)
-      end
+      file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
+      file_subclasses << klass unless file_subclasses.include?(klass)
     end
-
+    
+    
+    # Methods that are mixed in as module/class/singleton methods to modules
+    # that include {Thor::Base}.
+    # 
     module ClassMethods
+      include Thor::Base::CommonClassOptions
+      
       def attr_reader(*) #:nodoc:
         no_commands { super }
       end
@@ -528,7 +572,7 @@ class Thor
           @namespace ||= Thor::Util.namespace_from_thor_class(self)
         end
       end
-
+      
       # Parses the command and options from the given args, instantiate the class
       # and invoke the command. This method is used when the arguments must be parsed
       # from an array. If you are inside Ruby and want to use a Thor class, you
@@ -541,11 +585,11 @@ class Thor
         config[:shell] ||= Thor::Base.shell.new
         dispatch(nil, given_args.dup, nil, config)
       rescue Thor::Error => e
-        config[:debug] || (
-          ENV["THOR_DEBUG"] == "1" ?
-            (raise e) :
-            config[:shell].error(e.message)
-        )
+        if config[:debug] || ENV["THOR_DEBUG"] == "1"
+          raise e
+        else
+          config[:shell].error(e.message)
+        end
         exit(1) if exit_on_failure?
       rescue Errno::EPIPE
         # This happens if a thor command is piped to something like `head`,
@@ -554,6 +598,22 @@ class Thor
         # computation will not occur.
         exit(0)
       end
+      
+      
+      # Like {#start}, but explicitly for handling over control in an
+      # executable.
+      # 
+      # 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 = {})
+        execution = Thor::Execution.new thor_class:   self,
+                                        given_args:   given_args,
+                                        thor_config:  config
+        
+        execution.exec!
+      end # #start
+      
 
       # Allows to use private methods from parent in child classes as commands.
       #
@@ -592,182 +652,184 @@ class Thor
         raise InvocationError, msg
       end
 
-    protected
+      protected
+      # ============================================================================
 
-      # Prints the class options per group. If an option does not belong to
-      # any group, it's printed as Class option.
-      #
-      def class_options_help(shell, groups = {}) #:nodoc:
-        # Group options by group
-        class_options.each do |_, value|
-          groups[value.group] ||= []
-          groups[value.group] << value
-        end
+        # Prints the class options per group. If an option does not belong to
+        # any group, it's printed as Class option.
+        #
+        def class_options_help(shell, groups = {}) #:nodoc:
+          # Group options by group
+          class_options.each do |_, value|
+            groups[value.group] ||= []
+            groups[value.group] << value
+          end
 
-        # Deal with default group
-        global_options = groups.delete(nil) || []
-        print_options(shell, global_options)
+          # Deal with default group
+          global_options = groups.delete(nil) || []
+          print_options(shell, global_options)
 
-        # Print all others
-        groups.each do |group_name, options|
-          print_options(shell, options, group_name)
+          # Print all others
+          groups.each do |group_name, options|
+            print_options(shell, options, group_name)
+          end
         end
-      end
 
-      # Receives a set of options and print them.
-      def print_options(shell, options, group_name = nil)
-        return if options.empty?
+        # Receives a set of options and print them.
+        def print_options(shell, options, group_name = nil)
+          return if options.empty?
 
-        list = []
-        padding = options.map { |o| o.aliases.size }.max.to_i * 4
+          list = []
+          padding = options.map { |o| o.aliases.size }.max.to_i * 4
 
-        options.each do |option|
-          next if option.hide
-          item = [option.usage(padding)]
-          item.push(option.description ? "# #{option.description}" : "")
+          options.each do |option|
+            next if option.hide
+            item = [option.usage(padding)]
+            item.push(option.description ? "# #{option.description}" : "")
 
-          list << item
-          list << ["", "# Default: #{option.default}"] if option.show_default?
-          if option.enum
-            list << ["", "# Possible values: #{option.enum.join(', ')}"]
+            list << item
+            list << ["", "# Default: #{option.default}"] if option.show_default?
+            if option.enum
+              list << ["", "# Possible values: #{option.enum.join(', ')}"]
+            end
           end
+
+          shell.say(group_name ? "#{group_name} options:" : "Options:")
+          shell.print_table(list, :indent => 2)
+          shell.say ""
         end
 
-        shell.say(group_name ? "#{group_name} options:" : "Options:")
-        shell.print_table(list, :indent => 2)
-        shell.say ""
-      end
+        # Raises an error if the word given is a Thor reserved word.
+        def is_thor_reserved_word?(word, type) #:nodoc:
+          return false unless THOR_RESERVED_WORDS.include?(word.to_s)
+          raise "#{word.inspect} is a Thor reserved word and cannot be " \
+                "defined as #{type}"
+        end
 
-      # Raises an error if the word given is a Thor reserved word.
-      def is_thor_reserved_word?(word, type) #:nodoc:
-        return false unless THOR_RESERVED_WORDS.include?(word.to_s)
-        raise "#{word.inspect} is a Thor reserved word and cannot be  " \
-              "defined as #{type}"
-      end
+        # Build an option and adds it to the given scope.
+        #
+        # ==== Parameters
+        # 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(
+            name,
+            options.merge(:check_default_type => check_default_type?)
+          )
+        end
 
-      # Build an option and adds it to the given scope.
-      #
-      # ==== Parameters
-      # 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(
-          name,
-          options.merge(:check_default_type => check_default_type?)
-        )
-      end
+        # Receives a hash of options, parse them and add to the scope. This is a
+        # fast way to set a bunch of options:
+        #
+        #   build_options :foo => true, :bar => :required, :baz => :string
+        #
+        # ==== Parameters
+        # Hash[Symbol => Object]
+        def build_options(options, scope) #:nodoc:
+          options.each do |key, value|
+            scope[key] = Thor::Option.parse(key, value)
+          end
+        end
 
-      # Receives a hash of options, parse them and add to the scope. This is a
-      # fast way to set a bunch of options:
-      #
-      #   build_options :foo => true, :bar => :required, :baz => :string
-      #
-      # ==== Parameters
-      # Hash[Symbol => Object]
-      def build_options(options, scope) #:nodoc:
-        options.each do |key, value|
-          scope[key] = Thor::Option.parse(key, value)
+        # Finds a command with the given name. If the command belongs to the current
+        # class, just return it, otherwise dup it and add the fresh copy to the
+        # current command hash.
+        def find_and_refresh_command(name) #:nodoc:
+          if commands[name.to_s]
+            commands[name.to_s]
+          elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
+            commands[name.to_s] = command.clone
+          else
+            raise ArgumentError,
+              "You supplied :for => #{name.inspect}, but the command " \
+              "#{name.inspect} could not be found."
+          end
         end
-      end
+        alias_method :find_and_refresh_task, :find_and_refresh_command
 
-      # Finds a command with the given name. If the command belongs to the current
-      # class, just return it, otherwise dup it and add the fresh copy to the
-      # current command hash.
-      def find_and_refresh_command(name) #:nodoc:
-        if commands[name.to_s]
-          commands[name.to_s]
-        elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
-          commands[name.to_s] = command.clone
-        else
-          raise ArgumentError,
-            "You supplied :for => #{name.inspect}, but the command " \
-            "#{name.inspect} could not be found."
+        # Everytime someone inherits from a Thor class, register the klass
+        # and file into baseclass.
+        def inherited(klass)
+          Thor::Base.register_klass_file(klass)
+          klass.instance_variable_set(:@no_commands, false)
         end
-      end
-      alias_method :find_and_refresh_task, :find_and_refresh_command
 
-      # Everytime someone inherits from a Thor class, register the klass
-      # and file into baseclass.
-      def inherited(klass)
-        Thor::Base.register_klass_file(klass)
-        klass.instance_variable_set(:@no_commands, false)
-      end
+        # Fire this callback whenever a method is added. Added methods are
+        # tracked as commands by invoking the create_command method.
+        def method_added(meth)
+          meth = meth.to_s
 
-      # Fire this callback whenever a method is added. Added methods are
-      # tracked as commands by invoking the create_command method.
-      def method_added(meth)
-        meth = meth.to_s
+          if meth == "initialize"
+            initialize_added
+            return
+          end
 
-        if meth == "initialize"
-          initialize_added
-          return
-        end
+          # Return if it's not a public instance method
+          return unless public_method_defined?(meth.to_sym)
 
-        # Return if it's not a public instance method
-        return unless public_method_defined?(meth.to_sym)
+          @no_commands ||= false
+          return if @no_commands || !create_command(meth)
 
-        @no_commands ||= false
-        return if @no_commands || !create_command(meth)
+          is_thor_reserved_word?(meth, :command)
+          Thor::Base.register_klass_file(self)
+        end
 
-        is_thor_reserved_word?(meth, :command)
-        Thor::Base.register_klass_file(self)
-      end
+        # Retrieves a value from superclass. If it reaches the baseclass,
+        # returns default.
+        def from_superclass(method, default = nil)
+          if self == baseclass || !superclass.respond_to?(method, true)
+            default
+          else
+            value = superclass.send(method)
+
+            # Ruby implements `dup` on Object, but raises a `TypeError`
+            # if the method is called on immediates. As a result, we
+            # don't have a good way to check whether dup will succeed
+            # without calling it and rescuing the TypeError.
+            begin
+              value.dup
+            rescue TypeError
+              value
+            end
 
-      # Retrieves a value from superclass. If it reaches the baseclass,
-      # returns default.
-      def from_superclass(method, default = nil)
-        if self == baseclass || !superclass.respond_to?(method, true)
-          default
-        else
-          value = superclass.send(method)
-
-          # Ruby implements `dup` on Object, but raises a `TypeError`
-          # if the method is called on immediates. As a result, we
-          # don't have a good way to check whether dup will succeed
-          # without calling it and rescuing the TypeError.
-          begin
-            value.dup
-          rescue TypeError
-            value
           end
-
         end
-      end
 
-      # A flag that makes the process exit with status 1 if any error happens.
-      def exit_on_failure?
-        false
-      end
+        # A flag that makes the process exit with status 1 if any error happens.
+        def exit_on_failure?
+          false
+        end
 
-      #
-      # The basename of the program invoking the thor class.
-      #
-      def basename
-        File.basename($PROGRAM_NAME).split(" ").first
-      end
+        #
+        # The basename of the program invoking the thor class.
+        #
+        def basename
+          File.basename($PROGRAM_NAME).split(" ").first
+        end
 
-      # SIGNATURE: Sets the baseclass. This is where the superclass lookup
-      # finishes.
-      def baseclass #:nodoc:
-      end
+        # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+        # finishes.
+        def baseclass #:nodoc:
+        end
 
-      # SIGNATURE: Creates a new command if valid_command? is true. This method
-      # is called when a new method is added to the class.
-      def create_command(meth) #:nodoc:
-      end
-      alias_method :create_task, :create_command
+        # SIGNATURE: Creates a new command if valid_command? is true. This method
+        # is called when a new method is added to the class.
+        def create_command(meth) #:nodoc:
+        end
+        alias_method :create_task, :create_command
 
-      # SIGNATURE: Defines behavior when the initialize method is added to the
-      # class.
-      def initialize_added #:nodoc:
-      end
+        # SIGNATURE: Defines behavior when the initialize method is added to the
+        # class.
+        def initialize_added #:nodoc:
+        end
 
-      # SIGNATURE: The hook invoked by start.
-      def dispatch(command, given_args, given_opts, config) #:nodoc:
-        raise NotImplementedError
-      end
-      
-    end # self << class
+        # SIGNATURE: The hook invoked by start.
+        def dispatch(command, given_args, given_opts, config) #:nodoc:
+          raise NotImplementedError
+        end
+        
+      # end protected
+    end # ClassMethods
   end # module Base
 end # class Thor