thor 0.12.0 → 0.13.0

data/lib/thor/runner.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'thor/core_ext/file_binary_read'
 require 'open-uri'
 require 'yaml'
 require 'digest/md5'
@@ -32,7 +33,7 @@ class Thor::Runner < Thor #:nodoc:
   end
 
   desc "install NAME", "Install an optionally named Thor file into your system tasks"
-  method_options :as => :string, :relative => :boolean
+  method_options :as => :string, :relative => :boolean, :force => :boolean
   def install(name)
     initialize_thorfiles
 
@@ -55,7 +56,9 @@ class Thor::Runner < Thor #:nodoc:
     say "Your Thorfile contains:"
     say contents
 
-    return false if no?("Do you wish to continue [y/N]?")
+    unless options["force"]
+      return false if no?("Do you wish to continue [y/N]?")
+    end
 
     as = options["as"] || begin
       first_line = contents.split("\n")[0]
@@ -124,11 +127,7 @@ class Thor::Runner < Thor #:nodoc:
   method_options :internal => :boolean
   def installed
     initialize_thorfiles(nil, true)
-
-    klasses = Thor::Base.subclasses
-    klasses -= [Thor, Thor::Runner] unless options["internal"]
-
-    display_klasses(true, klasses)
+    display_klasses(true, options["internal"])
   end
 
   desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
@@ -144,11 +143,15 @@ class Thor::Runner < Thor #:nodoc:
       (options[:all] || k.group == group) && k.namespace =~ search
     end
 
-    display_klasses(false, klasses)
+    display_klasses(false, false, klasses)
   end
 
   private
 
+    def self.banner(task)
+      "thor " + task.formatted_usage(self, false)
+    end
+
     def thor_root
       Thor::Util.thor_root
     end
@@ -156,7 +159,7 @@ class Thor::Runner < Thor #:nodoc:
     def thor_yaml
       @thor_yaml ||= begin
         yaml_file = File.join(thor_root, "thor.yml")
-        yaml      = YAML.load_file(yaml_file) if File.exists?(yaml_file)
+        yaml = YAML.load_file(yaml_file) if File.exists?(yaml_file)
         yaml || {}
       end
     end
@@ -215,9 +218,6 @@ class Thor::Runner < Thor #:nodoc:
     # 5. c:\ <-- no Thorfiles found!
     #
     def thorfiles(relevant_to=nil, skip_lookup=false)
-      # TODO Remove this dealing with deprecated thor when :namespaces: is available as constants
-      save_yaml(thor_yaml) if Thor::Util.convert_constants_to_namespaces(thor_yaml)
-
       thorfiles = []
 
       unless skip_lookup
@@ -253,47 +253,54 @@ class Thor::Runner < Thor #:nodoc:
     # Display information about the given klasses. If with_module is given,
     # it shows a table with information extracted from the yaml file.
     #
-    def display_klasses(with_modules=false, klasses=Thor.subclasses)
-      klasses -= [Thor, Thor::Runner] unless with_modules
+    def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
+      klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
+
       raise Error, "No Thor tasks available" if klasses.empty?
+      show_modules if with_modules && !thor_yaml.empty?
 
-      if with_modules && !thor_yaml.empty?
-        info  = []
-        labels = ["Modules", "Namespaces"]
+      # Remove subclasses
+      klasses.dup.each do |klass|
+        klasses -= Thor::Util.thor_classes_in(klass)
+      end
 
-        info << labels
-        info << [ "-" * labels[0].size, "-" * labels[1].size ]
+      list = Hash.new { |h,k| h[k] = [] }
+      groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
-        thor_yaml.each do |name, hash|
-          info << [ name, hash[:namespaces].join(", ") ]
-        end
+      # Get classes which inherit from Thor
+      (klasses - groups).each { |k| list[k.namespace] += k.printable_tasks(false) }
 
-        print_table info
-        say ""
-      end
+      # Get classes which inherit from Thor::Base
+      groups.map! { |k| k.printable_tasks(false).first }
+      list["root"] = groups
 
-      unless klasses.empty?
-        klasses.dup.each do |klass|
-          klasses -= Thor::Util.thor_classes_in(klass)
-        end
+      # Order namespaces with default coming first
+      list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
+      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+    end
 
-        klasses.each { |k| display_tasks(k) }
-      else
-        say "\033[1;34mNo Thor tasks available\033[0m"
-      end
+    def display_tasks(namespace, list) #:nodoc:
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      say shell.set_color(namespace, :blue, true)
+      say "-" * namespace.size
+
+      print_table(list, :truncate => true)
+      say
     end
 
-    # Display tasks from the given Thor class.
-    #
-    def display_tasks(klass)
-      unless klass.tasks.empty?
-        base = klass.namespace
+    def show_modules #:nodoc:
+      info  = []
+      labels = ["Modules", "Namespaces"]
 
-        color = base == "default" ? :magenta : :blue
-        say shell.set_color(base, color, true)
-        say "-" * base.length
+      info << labels
+      info << [ "-" * labels[0].size, "-" * labels[1].size ]
 
-        klass.help(shell, :short => true, :ident => 0, :namespace => true)
+      thor_yaml.each do |name, hash|
+        info << [ name, hash[:namespaces].join(", ") ]
       end
+
+      print_table info
+      say ""
     end
 end

data/lib/thor/shell/basic.rb

@@ -75,30 +75,6 @@ class Thor
         !yes?(statement, color)
       end
 
-      # Prints a list of items.
-      #
-      # ==== Parameters
-      # list<Array[String, String, ...]>
-      #
-      # ==== Options
-      # mode:: Can be :rows or :inline. Defaults to :rows.
-      # ident:: Ident each item with the value given.
-      #
-      def print_list(list, options={})
-        return if list.empty?
-
-        ident   = " " * (options[:ident] || 0)
-        content = case options[:mode]
-          when :inline
-            last = list.pop
-            "#{list.join(", ")}, and #{last}"
-          else # rows
-            ident + list.join("\n#{ident}")
-        end
-
-        $stdout.puts content
-      end
-
       # Prints a table.
       #
       # ==== Parameters
@@ -110,20 +86,26 @@ class Thor
       def print_table(table, options={})
         return if table.empty?
 
-        formats = []
+        formats, ident = [], options[:ident].to_i
+        options[:truncate] = terminal_width if options[:truncate] == true
+
         0.upto(table.first.length - 2) do |i|
           maxima = table.max{ |a,b| a[i].size <=> b[i].size }[i].size
           formats << "%-#{maxima + 2}s"
         end
 
-        formats[0] = formats[0].insert(0, " " * options[:ident]) if options[:ident]
+        formats[0] = formats[0].insert(0, " " * ident)
         formats << "%s"
 
         table.each do |row|
+          sentence = ""
+
           row.each_with_index do |column, i|
-            $stdout.print formats[i] % column.to_s
+            sentence << formats[i] % column.to_s
           end
-          $stdout.puts
+
+          sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+          $stdout.puts sentence  
         end
       end
 
@@ -143,7 +125,7 @@ class Thor
           answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
 
           case answer
-            when is?(:yes), is?(:force)
+            when is?(:yes), is?(:force), ""
               return true
             when is?(:no), is?(:skip)
               return false
@@ -214,6 +196,44 @@ HELP
           base && base.options[:quiet]
         end
 
+        # This code was copied from Rake, available under MIT-LICENSE
+        # Copyright (c) 2003, 2004 Jim Weirich
+        def terminal_width
+          if ENV['THOR_COLUMNS']
+            result = ENV['THOR_COLUMNS'].to_i
+          else
+            result = unix? ? dynamic_width : 80
+          end
+          (result < 10) ? 80 : result
+        rescue
+          80
+        end
+
+        # Calculate the dynamic width of the terminal
+        def dynamic_width
+          @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
+        end
+
+        def dynamic_width_stty
+          %x{stty size 2>/dev/null}.split[1].to_i
+        end
+
+        def dynamic_width_tput
+          %x{tput cols 2>/dev/null}.to_i
+        end
+
+        def unix?
+          RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+        end
+
+        def truncate(string, width)
+          if string.length <= width
+            string
+          else
+            ( string[0, width-3] || "" ) + "..."
+          end
+        end
+
     end
   end
 end

data/lib/thor/shell/color.rb

@@ -63,7 +63,7 @@ class Thor
         #
         def show_diff(destination, content) #:nodoc:
           if diff_lcs_loaded? && ENV['THOR_DIFF'].nil? && ENV['RAILS_DIFF'].nil?
-            actual  = File.read(destination).to_s.split("\n")
+            actual  = File.binread(destination).to_s.split("\n")
             content = content.to_s.split("\n")
 
             Diff::LCS.sdiff(actual, content).each do |diff|

data/lib/thor/shell.rb

@@ -22,7 +22,7 @@ class Thor
   end
 
   module Shell
-    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
+    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_table]
 
     # Add shell to initialize config values.
     #

data/lib/thor/task.rb

@@ -1,11 +1,11 @@
 class Thor
   class Task < Struct.new(:name, :description, :usage, :options)
+    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
     # 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,72 +25,61 @@ 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  = backtrace.reject { |frame| frame =~ FILE_REGEXP }
         saned -= caller
       end
 
@@ -102,7 +91,7 @@ class Thor
             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.13.0".freeze
 end

data/lib/thor.rb

@@ -1,7 +1,6 @@
 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 +77,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 +100,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 +138,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 +190,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 +235,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