thor 0.12.0 → 0.12.3

data/lib/thor/task.rb

@@ -1,11 +1,11 @@
 class Thor
   class Task < Struct.new(:name, :description, :usage, :options)
+    FILE_REGEXP = /^#{Regexp.escape(File.expand_path(__FILE__))}:[\w:]+ `run'$/
 
     # A dynamic task that handles method missing scenarios.
-    #
     class Dynamic < Task
-      def initialize(name)
-        super(name.to_s, "A dynamically-generated task", name.to_s)
+      def initialize(name, options=nil)
+        super(name.to_s, "A dynamically-generated task", name.to_s, options)
       end
 
       def run(instance, args=[])
@@ -25,84 +25,73 @@ class Thor
       self.options = other.options.dup if other.options
     end
 
-    def short_description
-      description.split("\n").first if description
-    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=[])
       raise UndefinedTaskError, "the '#{name}' task of #{instance.class} is private" unless public_method?(instance)
       instance.send(name, *args)
     rescue ArgumentError => e
+      raise e if instance.class.respond_to?(:debugging) && instance.class.debugging
       parse_argument_error(instance, e, caller)
     rescue NoMethodError => e
+      raise e if instance.class.respond_to?(:debugging) && instance.class.debugging
       parse_no_method_error(instance, e)
     end
 
-    # Returns the formatted usage. If a class is given, the class arguments are
-    # injected in the usage.
-    #
-    def formatted_usage(klass=nil, namespace=false, show_options=true)
-      formatted = if namespace.is_a?(String)
-        "#{namespace}:"
-      elsif klass && namespace
-        "#{klass.namespace.gsub(/^default/,'')}:"
+    # Returns the formatted usage by injecting given required arguments 
+    # and required options into the given usage.
+    def formatted_usage(klass, namespace=true)
+      namespace = klass.namespace unless namespace == false
+
+      # Add namespace
+      formatted = if namespace
+        "#{namespace.gsub(/^(default|thor:runner:)/,'')}:"
       else
         ""
       end
 
-      formatted << formatted_arguments(klass)
-      formatted << " #{formatted_options}" if show_options
-      formatted.strip!
-      formatted
-    end
-
-    # Injects the class arguments into the task usage.
-    #
-    def formatted_arguments(klass)
-      if klass && !klass.arguments.empty?
+      # Add usage with required arguments
+      formatted << if klass && !klass.arguments.empty?
         usage.to_s.gsub(/^#{name}/) do |match|
-          match << " " << klass.arguments.map{ |a| a.usage }.join(' ')
+          match << " " << klass.arguments.map{ |a| a.usage }.compact.join(' ')
         end
       else
         usage.to_s
       end
-    end
 
-    # Returns the options usage for this task.
-    #
-    def formatted_options
-      @formatted_options ||= options.map{ |_, o| o.usage }.sort.join(" ")
+      # Add required options
+      formatted << " #{required_options}"
+
+      # Strip and go!
+      formatted.strip
     end
 
     protected
 
+      def required_options
+        @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
+      end
+
       # Given a target, checks if this class name is not a private/protected method.
-      #
       def public_method?(instance) #:nodoc:
         collection = instance.private_methods + instance.protected_methods
         (collection & [name.to_s, name.to_sym]).empty?
       end
 
-      # Clean everything that comes from the Thor gempath and remove the caller.
-      #
-      def sans_backtrace(backtrace, caller) #:nodoc:
-        dirname = /^#{Regexp.escape(File.dirname(__FILE__))}/
-        saned  = backtrace.reject { |frame| frame =~ dirname }
-        saned -= caller
+      # For Ruby <= 1.8.7, we have to match the method name that we are trying to call.
+      # In Ruby >= 1.9.1, we have to match the method run in this file.
+      def backtrace_match?(backtrace) #:nodoc:
+        method_name = /`#{Regexp.escape(name.split(':').last)}'/
+        backtrace =~ method_name || backtrace =~ FILE_REGEXP
       end
 
       def parse_argument_error(instance, e, caller) #:nodoc:
-        backtrace = sans_backtrace(e.backtrace, caller)
-
-        if backtrace.empty? && e.message =~ /wrong number of arguments/
+        if e.message =~ /wrong number of arguments/ && backtrace_match?(e.backtrace.first.to_s)
           if instance.is_a?(Thor::Group)
             raise e, "'#{name}' was called incorrectly. Are you sure it has arity equals to 0?"
           else
             raise InvocationError, "'#{name}' was called incorrectly. Call as " <<
-                                   "'#{formatted_usage(instance.class, true)}'"
+                                   "'#{formatted_usage(instance.class)}'"
           end
         else
           raise e

data/lib/thor/util.rb

@@ -76,8 +76,10 @@ class Thor
     # Returns the thor classes declared inside the given class.
     #
     def self.thor_classes_in(klass)
+      stringfied_constants = klass.constants.map { |c| c.to_s }
       Thor::Base.subclasses.select do |subclass|
-        klass.constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+        next unless subclass.name
+        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
       end
     end
 
@@ -155,7 +157,7 @@ class Thor
     # inside the sandbox to avoid namespacing conflicts.
     #
     def self.load_thorfile(path, content=nil)
-      content ||= File.read(path)
+      content ||= File.binread(path)
 
       begin
         Thor::Sandbox.class_eval(content, path)
@@ -164,26 +166,6 @@ class Thor
       end
     end
 
-    # Receives a yaml (hash) and updates all constants entries to namespace.
-    # This was added to deal with deprecated versions of Thor.
-    #
-    # TODO Deprecate this method in the future.
-    #
-    # ==== Returns
-    # TrueClass|FalseClass:: Returns true if any change to the yaml file was made.
-    #
-    def self.convert_constants_to_namespaces(yaml)
-      yaml_changed = false
-
-      yaml.each do |k, v|
-        next unless v[:constants] && v[:namespaces].nil?
-        yaml_changed = true
-        yaml[k][:namespaces] = v[:constants].map{|c| Thor::Util.namespace_from_thor_class(c)}
-      end
-
-      yaml_changed
-    end
-
     def self.user_home
       @@user_home ||= if ENV["HOME"]
         ENV["HOME"]

data/lib/thor/version.rb

@@ -1,3 +1,3 @@
 class Thor
-  VERSION = "0.12.0".freeze
+  VERSION = "0.12.3".freeze
 end

data/lib/thor.rb

@@ -2,6 +2,7 @@ require 'thor/base'
 require 'thor/group'
 require 'thor/actions'
 
+# TODO: Update thor to allow for git-style CLI (git bisect run)
 class Thor
   class << self
     # Sets the default task when thor is executed without an explicit task to be called.
@@ -78,14 +79,14 @@ class Thor
       @method_options
     end
 
-    # Adds an option to the set of class options. If :for is given as option,
+    # Adds an option to the set of method options. If :for is given as option,
     # it allows you to change the options from a previous defined task.
     #
     #   def previous_task
     #     # magic
     #   end
     #
-    #   method_options :foo => :bar, :for => :previous_task
+    #   method_option :foo => :bar, :for => :previous_task
     #
     #   def next_task
     #     # magic
@@ -101,7 +102,6 @@ class Thor
     # :default  - Default value for this argument. It cannot be required and have default values.
     # :aliases  - Aliases for this option.
     # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
-    # :group    - The group for this options. Use by class options to output options in different levels.
     # :banner   - String to show on usage notes.
     #
     def method_option(name, options={})
@@ -140,49 +140,48 @@ class Thor
       end
     end
 
-    # Prints help information. If a task name is given, it shows information
-    # only about the specific task.
+    # Prints help information for the given task.
     #
     # ==== Parameters
-    # meth<String>:: An optional task name to print usage information about.
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      task = all_tasks[task_name]
+      raise UndefinedTaskError, "task '#{task_name}' could not be found in namespace '#{self.namespace}'" unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      shell.say task.description
+    end
+
+    # Prints help information for this class.
     #
-    # ==== Options
-    # namespace:: When true, shows the namespace in the output before the usage.
-    # skip_inherited:: When true, does not show tasks from superclass.
+    # ==== Parameters
+    # shell<Thor::Shell>
     #
-    def help(shell, meth=nil, options={})
-      meth, options = nil, meth if meth.is_a?(Hash)
-
-      if meth
-        task = all_tasks[meth]
-        raise UndefinedTaskError, "task '#{meth}' could not be found in namespace '#{self.namespace}'" unless task
-
-        shell.say "Usage:"
-        shell.say "  #{banner(task, options[:namespace], false)}"
-        shell.say
-        class_options_help(shell, "Class", :Method => task.options.map { |_, o| o })
-        shell.say task.description
-      else
-        list = (options[:short] ? tasks : all_tasks).map do |_, task|
-          item = [ banner(task, options[:namespace]) ]
-          item << "# #{task.short_description}" if task.short_description
-          item << " "
-        end
-
-        options[:ident] ||= 2
-        if options[:short]
-          shell.print_list(list, :ident => options[:ident])
-        else
-          shell.say "Tasks:"
-          shell.print_list(list, :ident => options[:ident])
-        end
+    def help(shell)
+      list = printable_tasks
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
 
-        Thor::Util.thor_classes_in(self).each do |subclass|
-          namespace = options[:namespace] == true || subclass.namespace.gsub(/^#{self.namespace}:/, '')
-          subclass.help(shell, options.merge(:short => true, :namespace => namespace))
-        end
+      shell.say "Tasks:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
 
-        class_options_help(shell, "Class") unless options[:short]
+    # Returns tasks ready to be printed.
+    def printable_tasks(all=true)
+      (all ? all_tasks : tasks).map do |_, task|
+        item = []
+        item << banner(task)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
       end
     end
 
@@ -193,8 +192,9 @@ class Thor
       # the task that is going to be invoked and a boolean which indicates if
       # the namespace should be displayed as arguments.
       #
-      def banner(task, namespace=true, show_options=true)
-        task.formatted_usage(self, namespace, show_options)
+      def banner(task)
+        base = $thor_runner ? "thor" : File.basename($0.split(" ").first)
+        "#{base} #{task.formatted_usage(self, base == "thor")}"
       end
 
       def baseclass #:nodoc:
@@ -237,6 +237,6 @@ class Thor
 
   desc "help [TASK]", "Describe available tasks or one specific task"
   def help(task=nil)
-    self.class.help(shell, task, :namespace => task && task.include?(?:))
+    task ? self.class.task_help(shell, task) : self.class.help(shell)
   end
 end

data/spec/actions/create_file_spec.rb

@@ -8,7 +8,7 @@ describe Thor::Actions::CreateFile do
 
   def create_file(destination=nil, config={}, options={})
     @base = MyCounter.new([1,2], options, { :destination_root => destination_root })
-    stub(@base).file_name { 'rdoc' }
+    @base.stub!(:file_name).and_return('rdoc')
 
     @action = Thor::Actions::CreateFile.new(@base, destination, "CONFIGURATION",
                                             { :verbose => !@silence }.merge(config))
@@ -103,7 +103,7 @@ describe Thor::Actions::CreateFile do
 
         it "shows conflict status to ther user" do
           create_file("doc/config.rb").must_not be_identical
-          mock($stdin).gets{ 's' }
+          $stdin.should_receive(:gets).and_return('s')
           file = File.join(destination_root, 'doc/config.rb')
 
           content = invoke!
@@ -114,21 +114,21 @@ describe Thor::Actions::CreateFile do
 
         it "creates the file if the file collision menu returns true" do
           create_file("doc/config.rb")
-          mock($stdin).gets{ 'y' }
+          $stdin.should_receive(:gets).and_return('y')
           invoke!.must =~ /force  doc\/config\.rb/
         end
 
         it "skips the file if the file collision menu returns false" do
           create_file("doc/config.rb")
-          mock($stdin).gets{ 'n' }
+          $stdin.should_receive(:gets).and_return('n')
           invoke!.must =~ /skip  doc\/config\.rb/
         end
 
         it "executes the block given to show file content" do
           create_file("doc/config.rb")
-          mock($stdin).gets{ 'd' }
-          mock($stdin).gets{ 'n' }
-          mock(@base.shell).system(/diff -u/)
+          $stdin.should_receive(:gets).and_return('d')
+          $stdin.should_receive(:gets).and_return('n')
+          @base.shell.should_receive(:system).with(/diff -u/)
           invoke!
         end
       end

data/spec/actions/directory_spec.rb

@@ -4,7 +4,7 @@ require 'thor/actions'
 describe Thor::Actions::Directory do
   before(:each) do
     ::FileUtils.rm_rf(destination_root)
-    stub(invoker).file_name{ "rdoc" }
+    invoker.stub!(:file_name).and_return("rdoc")
   end
 
   def invoker
@@ -110,10 +110,11 @@ describe Thor::Actions::Directory do
     end
 
     it "yields a block" do
-      invoke!("doc") do |f|
-        %(doc/README doc/config.rb doc/rdoc.rb).must include(f)
-        %(doc/components/).must_not include(f)
+      checked = false
+      invoke!("doc") do |content|
+        checked ||= !!(content =~ /FOO/)
       end
+      checked.must be_true
     end
   end
 

data/spec/actions/file_manipulation_spec.rb

@@ -29,23 +29,23 @@ describe Thor::Actions do
 
   describe "#chmod" do
     it "executes the command given" do
-      mock(FileUtils).chmod_R(0755, file)
+      FileUtils.should_receive(:chmod_R).with(0755, file)
       action :chmod, "foo", 0755
     end
 
     it "does not execute the command if pretending given" do
-      dont_allow(FileUtils).chmod_R(0755, file)
+      FileUtils.should_not_receive(:chmod_R)
       runner(:pretend => true)
       action :chmod, "foo", 0755
     end
 
     it "logs status" do
-      mock(FileUtils).chmod_R(0755, file)
+      FileUtils.should_receive(:chmod_R).with(0755, file)
       action(:chmod, "foo", 0755).must == "       chmod  foo\n"
     end
 
     it "does not log status if required" do
-      mock(FileUtils).chmod_R(0755, file)
+      FileUtils.should_receive(:chmod_R).with(0755, file)
       action(:chmod, "foo", 0755, :verbose => false).must be_empty
     end
   end
@@ -65,13 +65,19 @@ describe Thor::Actions do
       runner.inside("doc") do
         action :copy_file, "README"
       end
-
       exists_and_identical?("doc/README", "doc/README")
     end
 
     it "logs status" do
       action(:copy_file, "task.thor").must == "      create  task.thor\n"
     end
+
+    it "accepts a block to change output" do
+      action :copy_file, "task.thor" do |content|
+        "OMG" + content
+      end
+      File.read(File.join(destination_root, "task.thor")).must =~ /^OMG/
+    end
   end
 
   describe "#get" do
@@ -117,7 +123,7 @@ describe Thor::Actions do
     end
 
     it "converts enconded instructions" do
-      mock(runner).file_name{ "rdoc" }
+      runner.should_receive(:file_name).and_return("rdoc")
       action :template, "doc/%file_name%.rb.tt"
       file = File.join(destination_root, "doc/rdoc.rb.tt")
       File.exists?(file).must be_true
@@ -126,6 +132,13 @@ describe Thor::Actions do
     it "logs status" do
       capture(:stdout){ runner.template("doc/config.rb") }.must == "      create  doc/config.rb\n"
     end
+
+    it "accepts a block to change output" do
+      action :template, "doc/config.rb" do |content|
+        "OMG" + content
+      end
+      File.read(File.join(destination_root, "doc/config.rb")).must =~ /^OMG/
+    end
   end
 
   describe "when changing existent files" do
@@ -166,18 +179,18 @@ describe Thor::Actions do
     describe "#gsub_file" do
       it "replaces the content in the file" do
         action :gsub_file, "doc/README", "__start__", "START"
-        File.open(file).read.must == "START\nREADME\n__end__\n"
+        File.binread(file).must == "START\nREADME\n__end__\n"
       end
 
       it "does not replace if pretending" do
         runner(:pretend => true)
         action :gsub_file, "doc/README", "__start__", "START"
-        File.open(file).read.must == "__start__\nREADME\n__end__\n"
+        File.binread(file).must == "__start__\nREADME\n__end__\n"
       end
 
       it "accepts a block" do
         action(:gsub_file, "doc/README", "__start__"){ |match| match.gsub('__', '').upcase  }
-        File.open(file).read.must == "START\nREADME\n__end__\n"
+        File.binread(file).must == "START\nREADME\n__end__\n"
       end
 
       it "logs status" do
@@ -192,12 +205,12 @@ describe Thor::Actions do
     describe "#append_file" do
       it "appends content to the file" do
         action :append_file, "doc/README", "END\n"
-        File.open(file).read.must == "__start__\nREADME\n__end__\nEND\n"
+        File.binread(file).must == "__start__\nREADME\n__end__\nEND\n"
       end
 
       it "accepts a block" do
         action(:append_file, "doc/README"){ "END\n" }
-        File.open(file).read.must == "__start__\nREADME\n__end__\nEND\n"
+        File.binread(file).must == "__start__\nREADME\n__end__\nEND\n"
       end
 
       it "logs status" do
@@ -208,12 +221,12 @@ describe Thor::Actions do
     describe "#prepend_file" do
       it "prepends content to the file" do
         action :prepend_file, "doc/README", "START\n"
-        File.open(file).read.must == "START\n__start__\nREADME\n__end__\n"
+        File.binread(file).must == "START\n__start__\nREADME\n__end__\n"
       end
 
       it "accepts a block" do
         action(:prepend_file, "doc/README"){ "START\n" }
-        File.open(file).read.must == "START\n__start__\nREADME\n__end__\n"
+        File.binread(file).must == "START\n__start__\nREADME\n__end__\n"
       end
 
       it "logs status" do
@@ -228,12 +241,12 @@ describe Thor::Actions do
 
       it "appends content to a class" do
         action :inject_into_class, "application.rb", Application, "  filter_parameters :password\n"
-        File.open(file).read.must == "class Application < Base\n  filter_parameters :password\nend\n"
+        File.binread(file).must == "class Application < Base\n  filter_parameters :password\nend\n"
       end
 
       it "accepts a block" do
         action(:inject_into_class, "application.rb", Application){ "  filter_parameters :password\n" }
-        File.open(file).read.must == "class Application < Base\n  filter_parameters :password\nend\n"
+        File.binread(file).must == "class Application < Base\n  filter_parameters :password\nend\n"
       end
 
       it "logs status" do
@@ -242,7 +255,7 @@ describe Thor::Actions do
 
       it "does not append if class name does not match" do
         action :inject_into_class, "application.rb", "App", "  filter_parameters :password\n"
-        File.open(file).read.must == "class Application < Base\nend\n"
+        File.binread(file).must == "class Application < Base\nend\n"
       end
     end
   end

data/spec/actions_spec.rb

@@ -55,9 +55,10 @@ describe Thor::Actions do
       end
 
       it "does not use the current directory if one is given" do
+        root = File.expand_path("/")
         base = MyCounter.new([1])
-        base.destination_root = "/"
-        base.destination_root.must == "/"
+        base.destination_root = root
+        base.destination_root.must == root
       end
 
       it "uses the current directory if none is given" do
@@ -194,7 +195,7 @@ describe Thor::Actions do
       @template.instance_eval "def read; self; end" # Make the string respond to read
 
       @file = "http://gist.github.com/103208.txt"
-      mock(runner).open(@file){ @template }
+      runner.should_receive(:open).and_return(@template)
     end
 
     it "opens a file and executes its content in the instance binding" do
@@ -219,7 +220,7 @@ describe Thor::Actions do
 
   describe "#run" do
     before(:each) do
-      mock(runner).system("ls")
+      runner.should_receive(:system).with("ls")
     end
 
     it "executes the command given" do
@@ -235,15 +236,15 @@ describe Thor::Actions do
     end
 
     it "accepts a color as status" do
-      mock(runner.shell).say_status(:run, 'ls from "."', :yellow)
+      runner.shell.should_receive(:say_status).with(:run, 'ls from "."', :yellow)
       action :run, "ls", :verbose => :yellow
     end
   end
 
   describe "#run_ruby_script" do
     before(:each) do
-      stub(Thor::Util).ruby_command{ "/opt/jruby" }
-      mock(runner).system("/opt/jruby script.rb")
+      Thor::Util.stub!(:ruby_command).and_return("/opt/jruby")
+      runner.should_receive(:system).with("/opt/jruby script.rb")
     end
 
     it "executes the ruby script" do
@@ -261,30 +262,30 @@ describe Thor::Actions do
 
   describe "#thor" do
     it "executes the thor command" do
-      mock(runner).system("thor list")
+      runner.should_receive(:system).with("thor list")
       action :thor, :list, :verbose => true
     end
 
     it "converts extra arguments to command arguments" do
-      mock(runner).system("thor list foo bar")
+      runner.should_receive(:system).with("thor list foo bar")
       action :thor, :list, "foo", "bar"
     end
 
     it "converts options hash to switches" do
-      mock(runner).system("thor list foo bar --foo")
+      runner.should_receive(:system).with("thor list foo bar --foo")
       action :thor, :list, "foo", "bar", :foo => true
 
-      mock(runner).system("thor list --foo 1 2 3")
+      runner.should_receive(:system).with("thor list --foo 1 2 3")
       action :thor, :list, :foo => [1,2,3]
     end
 
     it "logs status" do
-      mock(runner).system("thor list")
+      runner.should_receive(:system).with("thor list")
       action(:thor, :list).must == "         run  thor list from \".\"\n"
     end
 
     it "does not log status if required" do
-      mock(runner).system("thor list --foo 1 2 3")
+      runner.should_receive(:system).with("thor list --foo 1 2 3")
       action(:thor, :list, :foo => [1,2,3], :verbose => false).must be_empty
     end
   end

data/spec/base_spec.rb

@@ -134,7 +134,7 @@ describe Thor::Base do
     it "allows extra options to be given" do
       hash = { "Foo" => B.class_options.values }
 
-      content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, nil, hash) }
+      content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
       content.must =~ /Foo options\:/
       content.must =~ /--last-name=LAST_NAME/
     end

data/spec/fixtures/bundle/main.thor

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'execute')

data/spec/fixtures/doc/%file_name%.rb.tt

@@ -0,0 +1 @@
+FOO = <%= "FOO" %>

data/spec/fixtures/doc/README

@@ -0,0 +1,3 @@
+__start__
+README
+__end__