bundler 1.5.1 → 1.5.2

data/lib/bundler/vendor/thor/parser/option.rb

@@ -4,7 +4,7 @@ class Thor
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
-    def initialize(name, options={})
+    def initialize(name, options = {})
       options[:required] = false unless options.key?(:required)
       super
       @lazy_default = options[:lazy_default]
@@ -40,7 +40,7 @@ class Thor
     #
     # By default all options are optional, unless :required is given.
     #
-    def self.parse(key, value)
+    def self.parse(key, value) # rubocop:disable MethodLength
       if key.is_a?(Array)
         name, *aliases = key
       else
@@ -51,21 +51,21 @@ class Thor
       default = value
 
       type = case value
-      when Symbol
-        default = nil
-        if VALID_TYPES.include?(value)
-          value
-        elsif required = (value == :required)
-          :string
-        end
-      when TrueClass, FalseClass
-        :boolean
-      when Numeric
-        :numeric
-      when Hash, Array, String
-        value.class.name.downcase.to_sym
-      end
-      self.new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
+             when Symbol
+               default = nil
+               if VALID_TYPES.include?(value)
+                 value
+               elsif required = (value == :required) # rubocop:disable AssignmentInCondition
+                 :string
+               end
+             when TrueClass, FalseClass
+               :boolean
+             when Numeric
+               :numeric
+             when Hash, Array, String
+               value.class.name.downcase.to_sym
+             end
+      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
     end
 
     def switch_name
@@ -76,17 +76,17 @@ class Thor
       @human_name ||= dasherized? ? undasherize(name) : name
     end
 
-    def usage(padding=0)
+    def usage(padding = 0)
       sample = if banner && !banner.to_s.empty?
-        "#{switch_name}=#{banner}"
-      else
-        switch_name
-      end
+                 "#{switch_name}=#{banner}"
+               else
+                 switch_name
+               end
 
       sample = "[#{sample}]" unless required?
 
       if aliases.empty?
-        (" " * padding) << sample
+        (' ' * padding) << sample
       else
         "#{aliases.join(', ')}, #{sample}"
       end
@@ -103,7 +103,7 @@ class Thor
   protected
 
     def validate!
-      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+      fail ArgumentError, 'An option cannot be boolean and required.' if boolean? && required?
     end
 
     def dasherized?
@@ -115,7 +115,7 @@ class Thor
     end
 
     def dasherize(str)
-      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+      (str.length > 1 ? '--' : '-') + str.gsub('_', '-')
     end
   end
 end

data/lib/bundler/vendor/thor/parser/options.rb

@@ -1,5 +1,5 @@
 class Thor
-  class Options < Arguments #:nodoc:
+  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
     LONG_RE     = /^(--\w+(?:-\w+)*)$/
     SHORT_RE    = /^(-[a-z])$/i
     EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
@@ -14,22 +14,22 @@ class Thor
         when true
           "--#{key}"
         when Array
-          "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+          "--#{key} #{value.map { |v| v.inspect }.join(' ')}"
         when Hash
-          "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
         when nil, false
-          ""
+          ''
         else
           "--#{key} #{value.inspect}"
         end
-      end.join(" ")
+      end.join(' ')
     end
 
     # Takes a hash of Thor::Option and a hash with defaults.
     #
     # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
     # an unknown option or a regular argument.
-    def initialize(hash_options={}, defaults={}, stop_on_unknown=false)
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false)
       @stop_on_unknown = stop_on_unknown
       options = hash_options.values
       super(options)
@@ -52,7 +52,7 @@ class Thor
       end
     end
 
-    def remaining
+    def remaining # rubocop:disable TrivialAccessors
       @extra
     end
 
@@ -69,7 +69,7 @@ class Thor
       end
     end
 
-    def parse(args)
+    def parse(args) # rubocop:disable MethodLength
       @pile = args.dup
       @parsing_options = true
 
@@ -119,100 +119,100 @@ class Thor
     def check_unknown!
       # an unknown option starts with - or -- and has no more --'s afterward.
       unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+      fail UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
     end
 
-    protected
-
-      # Check if the current value in peek is a registered switch.
-      #
-      # Two booleans are returned.  The first is true if the current value
-      # starts with a hyphen; the second is true if it is a registered switch.
-      def current_is_switch?
-        case peek
-        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-          [true, switch?($1)]
-        when SHORT_SQ_RE
-          [true, $1.split('').any? { |f| switch?("-#{f}") }]
-        else
-          [false, false]
-        end
-      end
+  protected
 
-      def current_is_switch_formatted?
-        case peek
-        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
-          true
-        else
-          false
-        end
+    # Check if the current value in peek is a registered switch.
+    #
+    # Two booleans are returned.  The first is true if the current value
+    # starts with a hyphen; the second is true if it is a registered switch.
+    def current_is_switch?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        [true, switch?($1)]
+      when SHORT_SQ_RE
+        [true, $1.split('').any? { |f| switch?("-#{f}") }]
+      else
+        [false, false]
       end
+    end
 
-      def current_is_value?
-        peek && (!parsing_options? || super)
+    def current_is_switch_formatted?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+        true
+      else
+        false
       end
+    end
 
-      def switch?(arg)
-        switch_option(normalize_switch(arg))
-      end
+    def current_is_value?
+      peek && (!parsing_options? || super)
+    end
 
-      def switch_option(arg)
-        if match = no_or_skip?(arg)
-          @switches[arg] || @switches["--#{match}"]
-        else
-          @switches[arg]
-        end
-      end
+    def switch?(arg)
+      switch_option(normalize_switch(arg))
+    end
 
-      # Check if the given argument is actually a shortcut.
-      #
-      def normalize_switch(arg)
-        (@shorts[arg] || arg).tr('_', '-')
+    def switch_option(arg)
+      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
+        @switches[arg] || @switches["--#{match}"]
+      else
+        @switches[arg]
       end
+    end
 
-      def parsing_options?
-        peek
-        @parsing_options
-      end
+    # Check if the given argument is actually a shortcut.
+    #
+    def normalize_switch(arg)
+      (@shorts[arg] || arg).tr('_', '-')
+    end
 
-      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
-      #
-      def parse_boolean(switch)
-        if current_is_value?
-          if ["true", "TRUE", "t", "T", true].include?(peek)
-            shift
-            true
-          elsif ["false", "FALSE", "f", "F", false].include?(peek)
-            shift
-            false
-          else
-            true
-          end
+    def parsing_options?
+      peek
+      @parsing_options
+    end
+
+    # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+    #
+    def parse_boolean(switch)
+      if current_is_value?
+        if ['true', 'TRUE', 't', 'T', true].include?(peek)
+          shift
+          true
+        elsif ['false', 'FALSE', 'f', 'F', false].include?(peek)
+          shift
+          false
         else
-          @switches.key?(switch) || !no_or_skip?(switch)
+          true
         end
+      else
+        @switches.key?(switch) || !no_or_skip?(switch)
       end
+    end
 
-      # Parse the value at the peek analyzing if it requires an input or not.
-      #
-      def parse_peek(switch, option)
-        if parsing_options? && (current_is_switch_formatted? || last?)
-          if option.boolean?
-            # No problem for boolean types
-          elsif no_or_skip?(switch)
-            return nil # User set value to nil
-          elsif option.string? && !option.required?
-            # Return the default if there is one, else the human name
-            return option.lazy_default || option.default || option.human_name
-          elsif option.lazy_default
-            return option.lazy_default
-          else
-            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
-          end
+    # Parse the value at the peek analyzing if it requires an input or not.
+    #
+    def parse_peek(switch, option)
+      if parsing_options? && (current_is_switch_formatted? || last?)
+        if option.boolean?
+          # No problem for boolean types
+        elsif no_or_skip?(switch)
+          return nil # User set value to nil
+        elsif option.string? && !option.required?
+          # Return the default if there is one, else the human name
+          return option.lazy_default || option.default || option.human_name
+        elsif option.lazy_default
+          return option.lazy_default
+        else
+          fail MalformattedArgumentError, "No value provided for option '#{switch}'"
         end
-
-        @non_assigned_required.delete(option)
-        send(:"parse_#{option.type}", switch)
       end
+
+      @non_assigned_required.delete(option)
+      send(:"parse_#{option.type}", switch)
+    end
   end
 end

data/lib/bundler/vendor/thor/rake_compat.rb

@@ -12,7 +12,7 @@ class Thor
   #     include Thor::RakeCompat
   #
   #     RSpec::Core::RakeTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', "./.rspec"]
+  #       t.spec_opts = ['--options', './.rspec']
   #       t.spec_files = FileList['spec/**/*_spec.rb']
   #     end
   #   end
@@ -28,23 +28,23 @@ class Thor
       # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
       rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
       Rake.application.instance_variable_set(:@rakefile, rakefile)
-      self.rake_classes << base
+      rake_classes << base
     end
   end
 end
 
 # override task on (main), for compatibility with Rake 0.9
-self.instance_eval do
+instance_eval do
   alias rake_namespace namespace
 
   def task(*)
     task = super
 
-    if klass = Thor::RakeCompat.rake_classes.last
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
       non_namespaced_name = task.name.split(':').last
 
       description = non_namespaced_name
-      description << task.arg_names.map{ |n| n.to_s.upcase }.join(' ')
+      description << task.arg_names.map { |n| n.to_s.upcase }.join(' ')
       description.strip!
 
       klass.desc description, Rake.application.last_description || non_namespaced_name
@@ -58,7 +58,7 @@ self.instance_eval do
   end
 
   def namespace(name)
-    if klass = Thor::RakeCompat.rake_classes.last
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
       const_name = Thor::Util.camel_case(name.to_s).to_sym
       klass.const_set(const_name, Class.new(Thor))
       new_klass = klass.const_get(const_name)
@@ -69,4 +69,3 @@ self.instance_eval do
     Thor::RakeCompat.rake_classes.pop
   end
 end
-

data/lib/bundler/vendor/thor/runner.rb

@@ -8,8 +8,8 @@ require 'yaml'
 require 'digest/md5'
 require 'pathname'
 
-class Thor::Runner < Thor #:nodoc:
-  map "-T" => :list, "-i" => :install, "-u" => :update, "-v" => :version
+class Thor::Runner < Thor #:nodoc: # rubocop:disable ClassLength
+  map '-T' => :list, '-i' => :install, '-u' => :update, '-v' => :version
 
   # Override Thor#help so it can give information about any class and any method.
   #
@@ -18,7 +18,7 @@ class Thor::Runner < Thor #:nodoc:
       initialize_thorfiles(meth)
       klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
       self.class.handle_no_command_error(command, false) if klass.nil?
-      klass.start(["-h", command].compact, :shell => self.shell)
+      klass.start(['-h', command].compact, :shell => shell)
     else
       super
     end
@@ -33,38 +33,38 @@ class Thor::Runner < Thor #:nodoc:
     klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
     self.class.handle_no_command_error(command, false) if klass.nil?
     args.unshift(command) if command
-    klass.start(args, :shell => self.shell)
+    klass.start(args, :shell => shell)
   end
 
-  desc "install NAME", "Install an optionally named Thor file into your system commands"
+  desc 'install NAME', 'Install an optionally named Thor file into your system commands'
   method_options :as => :string, :relative => :boolean, :force => :boolean
-  def install(name)
+  def install(name) # rubocop:disable MethodLength
     initialize_thorfiles
 
     # If a directory name is provided as the argument, look for a 'main.thor'
     # command in said directory.
     begin
       if File.directory?(File.expand_path(name))
-        base, package = File.join(name, "main.thor"), :directory
-        contents      = open(base) {|input| input.read }
+        base, package = File.join(name, 'main.thor'), :directory
+        contents      = open(base) { |input| input.read }
       else
         base, package = name, :file
-        contents      = open(name) {|input| input.read }
+        contents      = open(name) { |input| input.read }
       end
     rescue OpenURI::HTTPError
       raise Error, "Error opening URI '#{name}'"
     rescue Errno::ENOENT
-      raise Error, "Error opening file '#{name}'"
+      fail Error, "Error opening file '#{name}'"
     end
 
-    say "Your Thorfile contains:"
+    say 'Your Thorfile contains:'
     say contents
 
-    unless options["force"]
-      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
+    as = options['as'] || begin
       first_line = contents.split("\n")[0]
       (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
     end
@@ -75,11 +75,11 @@ class Thor::Runner < Thor #:nodoc:
       as = basename if as.empty?
     end
 
-    location = if options[:relative] || name =~ /^https?:\/\//
-      name
-    else
-      File.expand_path(name)
-    end
+    location = if options[:relative] || name =~ %r{^https?://}
+                 name
+               else
+                 File.expand_path(name)
+               end
 
     thor_yaml[as] = {
       :filename   => Digest::MD5.hexdigest(name + as),
@@ -88,11 +88,11 @@ class Thor::Runner < Thor #:nodoc:
     }
 
     save_yaml(thor_yaml)
-    say "Storing thor file in your system repository"
+    say 'Storing thor file in your system repository'
     destination = File.join(thor_root, thor_yaml[as][:filename])
 
     if package == :file
-      File.open(destination, "w") { |f| f.puts contents }
+      File.open(destination, 'w') { |f| f.puts contents }
     else
       FileUtils.cp_r(name, destination)
     end
@@ -100,32 +100,32 @@ class Thor::Runner < Thor #:nodoc:
     thor_yaml[as][:filename] # Indicate success
   end
 
-  desc "version", "Show Thor version"
+  desc 'version', 'Show Thor version'
   def version
     require 'thor/version'
     say "Thor #{Thor::VERSION}"
   end
 
-  desc "uninstall NAME", "Uninstall a named Thor module"
+  desc 'uninstall NAME', 'Uninstall a named Thor module'
   def uninstall(name)
-    raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
+    fail Error, "Can't find module '#{name}'" unless thor_yaml[name]
     say "Uninstalling #{name}."
     FileUtils.rm_rf(File.join(thor_root, "#{thor_yaml[name][:filename]}"))
 
     thor_yaml.delete(name)
     save_yaml(thor_yaml)
 
-    puts "Done."
+    puts 'Done.'
   end
 
-  desc "update NAME", "Update a Thor file from its original location"
+  desc 'update NAME', 'Update a Thor file from its original location'
   def update(name)
-    raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
+    fail Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
 
     say "Updating '#{name}' from #{thor_yaml[name][:location]}"
 
     old_filename = thor_yaml[name][:filename]
-    self.options = self.options.merge("as" => name)
+    self.options = options.merge('as' => name)
 
     if File.directory? File.expand_path(name)
       FileUtils.rm_rf(File.join(thor_root, old_filename))
@@ -143,21 +143,21 @@ class Thor::Runner < Thor #:nodoc:
     end
   end
 
-  desc "installed", "List the installed Thor modules and commands"
+  desc 'installed', 'List the installed Thor modules and commands'
   method_options :internal => :boolean
   def installed
     initialize_thorfiles(nil, true)
-    display_klasses(true, options["internal"])
+    display_klasses(true, options['internal'])
   end
 
-  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
+  desc 'list [SEARCH]', 'List the available thor commands (--substring means .*SEARCH)'
   method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
-  def list(search="")
+  def list(search = '')
     initialize_thorfiles
 
-    search = ".*#{search}" if options["substring"]
+    search = ".*#{search}" if options['substring']
     search = /^#{search}.*/i
-    group  = options[:group] || "standard"
+    group  = options[:group] || 'standard'
 
     klasses = Thor::Base.subclasses.select do |k|
       (options[:all] || k.group == group) && k.namespace =~ search
@@ -166,157 +166,157 @@ class Thor::Runner < Thor #:nodoc:
     display_klasses(false, false, klasses)
   end
 
-  private
+private
 
-    def self.banner(command, all = false, subcommand = false)
-      "thor " + command.formatted_usage(self, all, subcommand)
-    end
+  def self.banner(command, all = false, subcommand = false)
+    'thor ' + command.formatted_usage(self, all, subcommand)
+  end
+
+  def thor_root
+    Thor::Util.thor_root
+  end
 
-    def thor_root
-      Thor::Util.thor_root
+  def thor_yaml
+    @thor_yaml ||= begin
+      yaml_file = File.join(thor_root, 'thor.yml')
+      yaml = YAML.load_file(yaml_file) if File.exist?(yaml_file)
+      yaml || {}
     end
+  end
 
-    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 || {}
-      end
+  # Save the yaml file. If none exists in thor root, creates one.
+  #
+  def save_yaml(yaml)
+    yaml_file = File.join(thor_root, 'thor.yml')
+
+    unless File.exist?(yaml_file)
+      FileUtils.mkdir_p(thor_root)
+      yaml_file = File.join(thor_root, 'thor.yml')
+      FileUtils.touch(yaml_file)
     end
 
-    # Save the yaml file. If none exists in thor root, creates one.
-    #
-    def save_yaml(yaml)
-      yaml_file = File.join(thor_root, "thor.yml")
+    File.open(yaml_file, 'w') { |f| f.puts yaml.to_yaml }
+  end
 
-      unless File.exists?(yaml_file)
-        FileUtils.mkdir_p(thor_root)
-        yaml_file = File.join(thor_root, "thor.yml")
-        FileUtils.touch(yaml_file)
-      end
+  def self.exit_on_failure?
+    true
+  end
 
-      File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
+  # Load the Thorfiles. If relevant_to is supplied, looks for specific files
+  # in the thor_root instead of loading them all.
+  #
+  # By default, it also traverses the current path until find Thor files, as
+  # described in thorfiles. This look up can be skipped by supplying
+  # skip_lookup true.
+  #
+  def initialize_thorfiles(relevant_to = nil, skip_lookup = false)
+    thorfiles(relevant_to, skip_lookup).each do |f|
+      Thor::Util.load_thorfile(f, nil, options[:debug]) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
     end
+  end
 
-    def self.exit_on_failure?
-      true
-    end
+  # Finds Thorfiles by traversing from your current directory down to the root
+  # directory of your system. If at any time we find a Thor file, we stop.
+  #
+  # We also ensure that system-wide Thorfiles are loaded first, so local
+  # Thorfiles can override them.
+  #
+  # ==== Example
+  #
+  # If we start at /Users/wycats/dev/thor ...
+  #
+  # 1. /Users/wycats/dev/thor
+  # 2. /Users/wycats/dev
+  # 3. /Users/wycats <-- we find a Thorfile here, so we stop
+  #
+  # Suppose we start at c:\Documents and Settings\james\dev\thor ...
+  #
+  # 1. c:\Documents and Settings\james\dev\thor
+  # 2. c:\Documents and Settings\james\dev
+  # 3. c:\Documents and Settings\james
+  # 4. c:\Documents and Settings
+  # 5. c:\ <-- no Thorfiles found!
+  #
+  def thorfiles(relevant_to = nil, skip_lookup = false)
+    thorfiles = []
 
-    # Load the Thorfiles. If relevant_to is supplied, looks for specific files
-    # in the thor_root instead of loading them all.
-    #
-    # By default, it also traverses the current path until find Thor files, as
-    # described in thorfiles. This look up can be skipped by supplying
-    # skip_lookup true.
-    #
-    def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
-      thorfiles(relevant_to, skip_lookup).each do |f|
-        Thor::Util.load_thorfile(f, nil, options[:debug]) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
+    unless skip_lookup
+      Pathname.pwd.ascend do |path|
+        thorfiles = Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
+        break unless thorfiles.empty?
       end
     end
 
-    # Finds Thorfiles by traversing from your current directory down to the root
-    # directory of your system. If at any time we find a Thor file, we stop.
-    #
-    # We also ensure that system-wide Thorfiles are loaded first, so local
-    # Thorfiles can override them.
-    #
-    # ==== Example
-    #
-    # If we start at /Users/wycats/dev/thor ...
-    #
-    # 1. /Users/wycats/dev/thor
-    # 2. /Users/wycats/dev
-    # 3. /Users/wycats <-- we find a Thorfile here, so we stop
-    #
-    # Suppose we start at c:\Documents and Settings\james\dev\thor ...
-    #
-    # 1. c:\Documents and Settings\james\dev\thor
-    # 2. c:\Documents and Settings\james\dev
-    # 3. c:\Documents and Settings\james
-    # 4. c:\Documents and Settings
-    # 5. c:\ <-- no Thorfiles found!
-    #
-    def thorfiles(relevant_to=nil, skip_lookup=false)
-      thorfiles = []
-
-      unless skip_lookup
-        Pathname.pwd.ascend do |path|
-          thorfiles = Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
-          break unless thorfiles.empty?
-        end
-      end
-
-      files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Thor::Util.thor_root_glob)
-      files += thorfiles
-      files -= ["#{thor_root}/thor.yml"]
+    files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Thor::Util.thor_root_glob)
+    files += thorfiles
+    files -= ["#{thor_root}/thor.yml"]
 
-      files.map! do |file|
-        File.directory?(file) ? File.join(file, "main.thor") : file
-      end
+    files.map! do |file|
+      File.directory?(file) ? File.join(file, 'main.thor') : file
     end
+  end
 
-    # Load Thorfiles relevant to the given method. If you provide "foo:bar" it
-    # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
-    # namespaces registered.
-    #
-    def thorfiles_relevant_to(meth)
-      lookup = [ meth, meth.split(":")[0...-1].join(":") ]
-
-      files = thor_yaml.select do |k, v|
-        v[:namespaces] && !(v[:namespaces] & lookup).empty?
-      end
+  # Load Thorfiles relevant to the given method. If you provide "foo:bar" it
+  # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
+  # namespaces registered.
+  #
+  def thorfiles_relevant_to(meth)
+    lookup = [meth, meth.split(':')[0...-1].join(':')]
 
-      files.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
+    files = thor_yaml.select do |k, v|
+      v[:namespaces] && !(v[:namespaces] & lookup).empty?
     end
 
-    # 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, show_internal=false, klasses=Thor::Base.subclasses)
-      klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
+    files.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
+  end
 
-      raise Error, "No Thor commands available" if klasses.empty?
-      show_modules if with_modules && !thor_yaml.empty?
+  # 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, show_internal = false, klasses = Thor::Base.subclasses)
+    klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
 
-      list = Hash.new { |h,k| h[k] = [] }
-      groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
+    fail Error, 'No Thor commands available' if klasses.empty?
+    show_modules if with_modules && !thor_yaml.empty?
 
-      # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
+    list = Hash.new { |h, k| h[k] = [] }
+    groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
-      # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_commands(false).first }
-      list["root"] = groups
+    # Get classes which inherit from Thor
+    (klasses - groups).each { |k| list[k.namespace.split(':').first] += k.printable_commands(false) }
 
-      # Order namespaces with default coming first
-      list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
-    end
+    # Get classes which inherit from Thor::Base
+    groups.map! { |k| k.printable_commands(false).first }
+    list['root'] = groups
 
-    def display_commands(namespace, list) #:nodoc:
-      list.sort!{ |a,b| a[0] <=> b[0] }
+    # Order namespaces with default coming first
+    list = list.sort { |a, b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
+    list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
+  end
 
-      say shell.set_color(namespace, :blue, true)
-      say "-" * namespace.size
+  def display_commands(namespace, list) #:nodoc:
+    list.sort! { |a, b| a[0] <=> b[0] }
 
-      print_table(list, :truncate => true)
-      say
-    end
-    alias display_tasks display_commands
+    say shell.set_color(namespace, :blue, true)
+    say '-' * namespace.size
 
-    def show_modules #:nodoc:
-      info  = []
-      labels = ["Modules", "Namespaces"]
+    print_table(list, :truncate => true)
+    say
+  end
+  alias_method :display_tasks, :display_commands
 
-      info << labels
-      info << [ "-" * labels[0].size, "-" * labels[1].size ]
+  def show_modules #:nodoc:
+    info  = []
+    labels = %w[Modules Namespaces]
 
-      thor_yaml.each do |name, hash|
-        info << [ name, hash[:namespaces].join(", ") ]
-      end
+    info << labels
+    info << ['-' * labels[0].size, '-' * labels[1].size]
 
-      print_table info
-      say ""
+    thor_yaml.each do |name, hash|
+      info << [name, hash[:namespaces].join(', ')]
     end
+
+    print_table info
+    say ''
+  end
 end