josevalim-thor 0.10.7 → 0.10.8

data/lib/thor/actions.rb

@@ -304,5 +304,13 @@ class Thor
       end
     end
 
+    protected
+
+      # Update dump_config to dump also behavior and root.
+      #
+      def _dump_config #:nodoc:
+        super.merge!(:behavior => self.behavior, :root => @root_stack[0])
+      end
+
   end
 end

data/lib/thor/base.rb

@@ -7,7 +7,8 @@ require 'thor/task'
 require 'thor/util'
 
 class Thor
-  HELP_MAPPINGS = ["-h", "-?", "--help", "-D"]
+  HELP_MAPPINGS       = %w(-h -? --help -D)
+  RESERVED_TASK_NAMES = %w(all invoke shell options behavior root destination_root relative_root source_root)
 
   class Maxima < Struct.new(:usage, :options, :class_options)
   end
@@ -215,19 +216,6 @@ class Thor
         end
       end
 
-      # Retrieve a specific task from this Thor class. If the desired Task cannot
-      # be found, returns a dynamic Thor::Task that will map to the given method.
-      #
-      # ==== Parameters
-      # meth<Symbol>:: the name of the task to be retrieved
-      #
-      # ==== Returns
-      # Task
-      #
-      def [](meth)
-        all_tasks[meth.to_s] || Thor::Task.dynamic(meth)
-      end
-
       # All methods defined inside the given block are not added as tasks.
       #
       # So you can do:
@@ -384,6 +372,11 @@ class Thor
           end
 
           return if @no_tasks || !valid_task?(meth)
+
+          if RESERVED_TASK_NAMES.include?(meth)
+            raise ScriptError, "'#{meth}' is a Thor reserved word and cannot be defined as task"
+          end
+
           Thor::Base.register_klass_file(self)
           create_task(meth)
         end
@@ -456,20 +449,10 @@ class Thor
         end
 
         self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).freeze
-        self.shell   = config[:shell]
 
-        # Add base to shell if an accessor is provided.
-        self.shell.base = self if self.shell.respond_to?(:base)
-      end
-
-      # Common methods that are delegated to the shell.
-      #
-      SHELL_DELEGATED_METHODS.each do |method|
-        module_eval <<-METHOD, __FILE__, __LINE__
-          def #{method}(*args)
-            shell.#{method}(*args)
-          end
-        METHOD
+        # Configure shell and set base if not already
+        self.shell = config[:shell]
+        self.shell.base ||= self if self.shell.respond_to?(:base)
       end
 
       # Holds the shell for the given Thor instance. If no shell is given,
@@ -485,15 +468,133 @@ class Thor
         @shell = shell
       end
 
-      # Finds a task with the name given and invokes it with the given arguments.
-      # This is the default interface to invoke tasks. You can always run a task
-      # directly, but the invocation system will be implemented in a fashion
-      # that a same task cannot be invoked twice (a la rake).
+      # Common methods that are delegated to the shell.
       #
-      def invoke(name, *args)
-        self.class[name].run(self, *args)
+      SHELL_DELEGATED_METHODS.each do |method|
+        module_eval <<-METHOD, __FILE__, __LINE__
+          def #{method}(*args)
+            shell.#{method}(*args)
+          end
+        METHOD
       end
-    end
 
+      # Receives a name and invokes it. The name can be either a namespaced name,
+      # a current class task or even a class. Arguments are given in an array and
+      # options given are merged with the invoker options.
+      #
+      # ==== Examples
+      #
+      #   class A < Thor
+      #     def foo
+      #       invoke :bar
+      #       invoke "b:lib", ["merb", "rails"]
+      #     end
+      #
+      #     def bar
+      #       invoke "b:lib", ["merb", "rails"]
+      #       # magic
+      #     end
+      #   end
+      #
+      #   class B < Thor
+      #     argument :preferred_framework, :type => :string
+      #
+      #     def lib(second_framework)
+      #       # magic
+      #     end
+      #   end
+      #
+      # You can notice that the method "foo" above invokes two tasks: "bar",
+      # which belongs to the same class and "lib" that belongs to the class B.
+      #
+      # By using an invocation system you ensure that a task is invoked only once.
+      # In the example above, invoking foo will invoke "b:lib" just once, even if
+      # it's invoked later by "bar" method.
+      #
+      # When invoking another class, there are a few things to keep in mind:
+      #
+      #   1) Class arguments are parsed first. In the example above, preferred
+      #      framework is going to consume "merb" and second framework is going
+      #      to be set to "rails".
+      #
+      #   2) All options and configurations are sent to the invoked class.
+      #      So the invoked class is going to use the same shell instance, will
+      #      have the same behavior (:invoke or :revoke) and so on.
+      #
+      # Invoking a Thor::Group happens in the same away as above:
+      #
+      #   class C < Thor::Group
+      #     def one
+      #     end
+      #   end
+      #
+      # Is invoked as:
+      #
+      #   invoke "c"
+      #
+      # Or even as:
+      #
+      #   invoke C
+      #
+      def invoke(name, method_args=[], options={})
+        @_invocations ||= Hash.new { |h,k| h[k] = [] }
+        instance, task = _setup_for_invoke(name, method_args, options)
+
+        current = @_invocations[instance.class]
+        return if current.include?("all")
+
+        if task
+          task = self.class.all_tasks[task.to_s] || Task.dynamic(task) unless task.is_a?(Thor::Task)
+          return if current.include?(task.name)
+
+          current << task.name
+          task.run(instance, method_args)
+        else
+          current << "all"
+          instance.class.all_tasks.collect { |_, task| task.run(instance) }
+        end
+      end
+
+      protected
+
+        # This is the method responsable for retrieving and setting up an
+        # instance to be used in invoke.
+        #
+        def _setup_for_invoke(name, method_args, options) #:nodoc:
+          case name
+            when NilClass, Thor::Task
+              # Do nothing, we already have what we want
+            when Class
+              klass = name
+            else
+              name = name.to_s
+              unless self.class.all_tasks[name]
+                klass, task = Thor::Util.namespace_to_thor_class(name) rescue Thor::Error
+              end
+          end
+
+          if klass.nil?
+            return self, name
+          elsif klass <= Thor::Base
+            size       = klass.arguments.size
+            class_args = method_args.slice!(0, size)
+            instance   = klass.new(class_args, self.options.merge(options), _dump_config)
+
+            task ||= klass.default_task if klass <= Thor
+            instance.instance_variable_set("@_invocations", @_invocations)
+
+            return instance, task
+          else
+            raise ScriptError, "Expected Thor class, got #{klass}"
+          end
+        end
+
+        # Dump the configuration values for this current class.
+        #
+        def _dump_config #:nodoc:
+          { :shell => self.shell }
+        end
+
+    end
   end
 end

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -11,15 +11,10 @@ class Thor
     #
     class HashWithIndifferentAccess < ::Hash
 
-      def initialize(hash)
+      def initialize(hash={})
         super()
-
         hash.each do |key, value|
-          if key.is_a?(Symbol)
-            self[key.to_s] = value
-          else
-            self[key] = value
-          end
+          self[convert_key(key)] = value
         end
       end
 
@@ -27,6 +22,10 @@ class Thor
         super(convert_key(key))
       end
 
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
       def delete(key)
         super(convert_key(key))
       end
@@ -35,6 +34,17 @@ class Thor
         indices.collect { |key| self[convert_key(key)] }
       end
 
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
       protected
 
         def convert_key(key)

data/lib/thor/core_ext/ordered_hash.rb

@@ -110,11 +110,7 @@ class Thor #:nodoc:
       end
 
       def merge(other)
-        new = clone
-        other.each do |key, value|
-          new[key] = value
-        end
-        new
+        dup.merge!(other)
       end
 
       def merge!(other)

data/lib/thor/group.rb

@@ -22,6 +22,71 @@ class Thor::Group
       end
     end
 
+    # Sets the condition for some task to be executed in the class level. Why
+    # is this important? Setting the conditions in the class level allows to
+    # an inherited class change the conditions and customize the Thor::Group as
+    # it wishes.
+    #
+    # The conditions given are retrieved from the options hash. Let's suppose
+    # that a task is only executed if --test-framework is rspec. You could do
+    # this:
+    #
+    #   class_option :test_framework, :type => :string
+    #
+    #   conditions :test_framework => :rspec
+    #   def create_rspec_files
+    #     # magic
+    #   end
+    #
+    # Later someone creates a framework on top of rspec and need rspec files to
+    # generated as well. He could then change the conditions:
+    #
+    #   conditions :test_framework => [ :rspec, :remarkable ], :for => :create_rspec_files
+    #
+    # He could also use remove_conditions and remove previous set conditions:
+    #
+    #   remove_conditions :test_framework, :for => :create_rspec_files
+    #
+    # Conditions only work with the class option to be comparead to is a boolean,
+    # string or numeric (no array or hash comparisions).
+    #
+    # ==== Parameters
+    # conditions<Hash>:: the conditions for the task. The key is the option name
+    #                    and the value is the condition to be checked. If the
+    #                    condition is an array, it checkes if the current value
+    #                    is included in the array. If a regexp, checks if the
+    #                    value matches, all other values are simply compared (==).
+    #
+    def conditions(conditions=nil)
+      subject = if conditions && conditions[:for]
+        find_and_refresh_task(conditions.delete(:for)).conditions
+      else
+        @conditions ||= {}
+      end
+
+      subject.merge!(conditions) if conditions
+      subject
+    end
+
+    # Remove a previous specified condition. Check <tt>conditions</tt> above for
+    # a complete example.
+    #
+    # ==== Parameters
+    # conditions<Array>:: An array of conditions to be removed.
+    # for<Hash>:: A hash with :for as key indicating the task to remove the conditions from.
+    #
+    # ==== Examples
+    #
+    #   remove_conditions :test_framework, :orm, :for => :create_app_skeleton
+    #
+    def remove_conditions(*conditions)
+      subject = find_and_refresh_task(conditions.pop[:for]).conditions
+      conditions.each do |condition|
+        subject.delete(condition)
+      end
+      subject
+    end
+
     # Start in Thor::Group works differently. It invokes all tasks inside the
     # class and does not have to parse task options.
     #
@@ -34,7 +99,7 @@ class Thor::Group
         opts = Thor::Options.new(class_options)
         opts.parse(args)
 
-        new(opts.arguments, opts.options, config).invoke_all
+        new(opts.arguments, opts.options, config).invoke(:all)
       end
     rescue Thor::Error => e
       config[:shell].error e.message
@@ -75,15 +140,21 @@ class Thor::Group
       end
 
       def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil)
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, @conditions)
+        @conditions = nil
       end
   end
 
-  # Invokes all tasks in the instance.
-  #
-  def invoke_all
-    self.class.all_tasks.map { |_, task| task.run(self) }
-  end
-
   include Thor::Base
+
+  protected
+
+    # Overwrite _setup_for_invoke to force invocation of all tasks when :all is
+    # supplied.
+    #
+    def _setup_for_invoke(name, method_args, options)
+      name = nil if name.to_s == "all"
+      super(name, method_args, options)
+    end
+
 end

data/lib/thor/task.rb

@@ -1,30 +1,31 @@
 class Thor
-  class Task < Struct.new(:name, :description, :usage, :options)
+  class Task < Struct.new(:name, :description, :usage, :options, :conditions)
 
     # Creates a dynamic task. Dynamic tasks are created on demand to allow method
     # missing calls (since a method missing does not have a task object for it).
     #
     def self.dynamic(name)
-      new(name, "A dynamically-generated task", name.to_s, nil)
+      new(name, "A dynamically-generated task", name.to_s)
     end
 
-    def initialize(name, description, usage, options)
-      super(name, description, usage, options || {})
+    def initialize(name, description, usage, options=nil, conditions=nil)
+      super(name.to_s, description, usage, options || {}, conditions || {})
     end
 
     # Dup the options hash on clone.
     #
     def initialize_copy(other)
       super(other)
-      self.options = other.options.dup if other.options
+      self.options    = other.options.dup    if other.options
+      self.conditions = other.conditions.dup if other.conditions
     end
 
     # By default, a task invokes a method in the thor class. You can change this
     # implementation to create custom tasks.
     #
-    def run(instance, *args)
+    def run(instance, args=[])
       raise UndefinedTaskError, "the '#{name}' task of #{instance.class} is private" unless public_method?(instance)
-      instance.send(name, *args)
+      instance.send(name, *args) if valid_conditions?(instance)
     rescue ArgumentError => e
       backtrace = sans_backtrace(e.backtrace, caller)
 
@@ -86,7 +87,30 @@ class Thor
       # Given a target, checks if this class name is not a private/protected method.
       #
       def public_method?(instance)
-        !(instance.private_methods + instance.protected_methods).include?(name.to_s)
+        collection = instance.private_methods + instance.protected_methods
+        !(collection).include?(name.to_s) && !(collection).include?(name.to_sym) # For Ruby 1.9
+      end
+
+      # Check if the task conditions are met before invoking.
+      #
+      def valid_conditions?(instance)
+        return true if conditions.empty?
+
+        conditions.each do |key, expected|
+          actual   = stringify!(instance.options[key])
+          expected = stringify!(expected)
+
+          return false if case expected
+            when Regexp
+              actual !~ expected
+            when Array
+              !expected.include?(actual)
+            else
+              actual != expected
+          end
+        end
+
+        true
       end
 
       # Clean everything that comes from the Thor gempath and remove the caller.
@@ -97,5 +121,18 @@ class Thor
         saned -= caller
       end
 
+      # Receives an object and convert any symbol to string.
+      #
+      def stringify!(duck)
+        case duck
+          when Array
+            duck.map!{ |i| i.is_a?(Symbol) ? i.to_s : i }
+          when Symbol
+            duck.to_s
+          else
+            duck
+        end
+      end
+
   end
 end

data/lib/thor.rb

@@ -127,14 +127,14 @@ class Thor
       config[:shell] ||= Thor::Base.shell.new
 
       meth = normalize_task_name(args.shift)
-      task = self[meth]
+      task = all_tasks[meth] || Task.dynamic(meth)
 
       options = class_options.merge(task.options)
       opts = Thor::Options.new(options)
       opts.parse(args)
 
       instance = new(opts.arguments, opts.options, config)
-      instance.invoke(task.name, *opts.trailing)
+      instance.invoke(task, opts.trailing)
     rescue Thor::Error => e
       config[:shell].error e.message
     end
@@ -153,7 +153,7 @@ class Thor
       meth, options = nil, meth if meth.is_a?(Hash)
 
       if meth
-        task = self.all_tasks[meth]
+        task = all_tasks[meth]
         raise UndefinedTaskError, "task '#{meth}' could not be found in namespace '#{self.namespace}'" unless task
 
         shell.say "Usage:"
@@ -198,7 +198,7 @@ class Thor
       end
 
       def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options)
+        tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options, nil)
         @usage, @desc, @method_options = nil
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: josevalim-thor
 version: !ruby/object:Gem::Version 
-  version: 0.10.7
+  version: 0.10.8
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -07:00
+date: 2009-06-20 00:00:00 -07:00
 default_executable: 
 dependencies: []