bundler 1.5.1 → 1.5.2

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

@@ -2,7 +2,7 @@ class Thor
   class Command < Struct.new(:name, :description, :long_description, :usage, :options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
-    def initialize(name, description, long_description, usage, options=nil)
+    def initialize(name, description, long_description, usage, options = nil)
       super(name.to_s, description, long_description, usage, options || {})
     end
 
@@ -17,7 +17,7 @@ class Thor
 
     # By default, a command invokes a method in the thor class. You can change this
     # implementation to create custom commands.
-    def run(instance, args=[])
+    def run(instance, args = [])
       arity = nil
 
       if private_method?(instance)
@@ -31,11 +31,9 @@ class Thor
         instance.class.handle_no_command_error(name)
       end
     rescue ArgumentError => e
-      handle_argument_error?(instance, e, caller) ?
-        instance.class.handle_argument_error(self, e, args, arity) : (raise e)
+      handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
     rescue NoMethodError => e
-      handle_no_method_error?(instance, e, caller) ?
-        instance.class.handle_no_command_error(name) : (raise e)
+      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (fail e)
     end
 
     # Returns the formatted usage by injecting given required arguments
@@ -43,20 +41,20 @@ class Thor
     def formatted_usage(klass, namespace = true, subcommand = false)
       if namespace
         namespace = klass.namespace
-        formatted = "#{namespace.gsub(/^(default)/,'')}:"
+        formatted = "#{namespace.gsub(/^(default)/, '')}:"
       end
       formatted = "#{klass.namespace.split(':').last} " if subcommand
 
-      formatted ||= ""
+      formatted ||= ''
 
       # 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 }.compact.join(' ')
-        end
-      else
-        usage.to_s
-      end
+                     usage.to_s.gsub(/^#{name}/) do |match|
+                       match << ' ' << klass.arguments.map { |a| a.usage }.compact.join(' ')
+                     end
+                   else
+                     usage.to_s
+                   end
 
       # Add required options
       formatted << " #{required_options}"
@@ -72,7 +70,7 @@ class Thor
     end
 
     def required_options
-      @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
+      @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(' ')
     end
 
     # Given a target, checks if this class name is a public method.
@@ -90,15 +88,15 @@ class Thor
     end
 
     def sans_backtrace(backtrace, caller) #:nodoc:
-      saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) }
-      saned -= caller
+      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) }
+      saned - caller
     end
 
     def handle_argument_error?(instance, error, caller)
       not_debugging?(instance) && error.message =~ /wrong number of arguments/ && begin
         saned = sans_backtrace(error.backtrace, caller)
         # Ruby 1.9 always include the called method in the backtrace
-        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
+        saned.empty? || (saned.size == 1 && RUBY_VERSION >= '1.9')
       end
     end
 
@@ -107,7 +105,7 @@ class Thor
         error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
     end
   end
-  Task = Command
+  Task = Command # rubocop:disable ConstantName
 
   # A command that is hidden in help messages but still invocable.
   class HiddenCommand < Command
@@ -115,15 +113,15 @@ class Thor
       true
     end
   end
-  HiddenTask = HiddenCommand
+  HiddenTask = HiddenCommand # rubocop:disable ConstantName
 
   # A dynamic command that handles method missing scenarios.
   class DynamicCommand < Command
-    def initialize(name, options=nil)
-      super(name.to_s, "A dynamically-generated command", name.to_s, name.to_s, options)
+    def initialize(name, options = nil)
+      super(name.to_s, 'A dynamically-generated command', name.to_s, name.to_s, options)
     end
 
-    def run(instance, args=[])
+    def run(instance, args = [])
       if (instance.methods & [name.to_s, name.to_sym]).empty?
         super
       else
@@ -131,6 +129,5 @@ class Thor
       end
     end
   end
-  DynamicTask = DynamicCommand
-
+  DynamicTask = DynamicCommand # rubocop:disable ConstantName
 end

data/lib/bundler/vendor/thor/core_ext/hash_with_indifferent_access.rb

@@ -1,6 +1,5 @@
 class Thor
   module CoreExt #:nodoc:
-
     # A hash with indifferent access and magic predicates.
     #
     #   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
@@ -10,8 +9,7 @@ class Thor
     #   hash.foo?   #=> true
     #
     class HashWithIndifferentAccess < ::Hash #:nodoc:
-
-      def initialize(hash={})
+      def initialize(hash = {})
         super()
         hash.each do |key, value|
           self[convert_key(key)] = value
@@ -31,7 +29,7 @@ class Thor
       end
 
       def values_at(*indices)
-        indices.collect { |key| self[convert_key(key)] }
+        indices.map { |key| self[convert_key(key)] }
       end
 
       def merge(other)
@@ -50,31 +48,30 @@ class Thor
         Hash.new(default).merge!(self)
       end
 
-      protected
+    protected
 
-        def convert_key(key)
-          key.is_a?(Symbol) ? key.to_s : key
-        end
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
 
-        # Magic predicates. For instance:
-        #
-        #   options.force?                  # => !!options['force']
-        #   options.shebang                 # => "/usr/lib/local/ruby"
-        #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
-        #
-        def method_missing(method, *args, &block)
-          method = method.to_s
-          if method =~ /^(\w+)\?$/
-            if args.empty?
-              !!self[$1]
-            else
-              self[$1] == args.first
-            end
+      # Magic predicates. For instance:
+      #
+      #   options.force?                  # => !!options['force']
+      #   options.shebang                 # => "/usr/lib/local/ruby"
+      #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+      #
+      def method_missing(method, *args, &block)
+        method = method.to_s
+        if method =~ /^(\w+)\?$/
+          if args.empty?
+            !!self[$1]
           else
-            self[method]
+            self[$1] == args.first
           end
+        else
+          self[method]
         end
-
+      end
     end
   end
 end

data/lib/bundler/vendor/thor/core_ext/io_binary_read.rb

@@ -1,12 +1,10 @@
 class IO #:nodoc:
   class << self
-
     def binread(file, *args)
-      raise ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
+      fail ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
       File.open(file, 'rb') do |f|
         f.read(*args)
       end
     end unless method_defined? :binread
-
   end
 end

data/lib/bundler/vendor/thor/core_ext/ordered_hash.rb

@@ -1,6 +1,5 @@
 class Thor
   module CoreExt #:nodoc:
-
     if RUBY_VERSION >= '1.9'
       class OrderedHash < ::Hash
       end
@@ -24,12 +23,12 @@ class Thor
         end
 
         def []=(key, value)
-          if node = @hash[key]
+          if node = @hash[key] # rubocop:disable AssignmentInCondition
             node.value = value
           else
             node = Node.new(key, value)
 
-            if @first.nil?
+            if !defined?(@first) || @first.nil?
               @first = @last = node
             else
               node.prev = @last
@@ -43,7 +42,7 @@ class Thor
         end
 
         def delete(key)
-          if node = @hash[key]
+          if node = @hash[key] # rubocop:disable AssignmentInCondition
             prev_node = node.prev
             next_node = node.next
 
@@ -61,25 +60,25 @@ class Thor
         end
 
         def keys
-          self.map { |k, v| k }
+          map { |k, v| k }
         end
 
         def values
-          self.map { |k, v| v }
+          map { |k, v| v }
         end
 
         def each
-          return unless @first
+          return unless defined?(@first) && @first
           yield [@first.key, @first.value]
           node = @first
-          yield [node.key, node.value] while node = node.next
+          yield [node.key, node.value] while node = node.next # rubocop:disable AssignmentInCondition
           self
         end
 
         def merge(other)
           hash = self.class.new
 
-          self.each do |key, value|
+          each do |key, value|
             hash[key] = value
           end
 
@@ -95,6 +94,5 @@ class Thor
         end
       end
     end
-
   end
 end

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

@@ -11,11 +11,11 @@ class Thor
   # Raised when a command was not found.
   class UndefinedCommandError < Error
   end
-  UndefinedTaskError = UndefinedCommandError
+  UndefinedTaskError = UndefinedCommandError # rubocop:disable ConstantName
 
   class AmbiguousCommandError < Error
   end
-  AmbiguousTaskError = AmbiguousCommandError
+  AmbiguousTaskError = AmbiguousCommandError # rubocop:disable ConstantName
 
   # Raised when a command was found, but not invoked properly.
   class InvocationError < Error

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

@@ -4,7 +4,7 @@ require 'thor/base'
 # is that it invokes all commands at once. It also include some methods that allows
 # invocations to be done at the class method, which are not available to Thor
 # commands.
-class Thor::Group
+class Thor::Group # rubocop:disable ClassLength
   class << self
     # The description for this Thor::Group. If none is provided, but a source root
     # exists, tries to find the USAGE one folder above it, otherwise searches
@@ -13,12 +13,11 @@ class Thor::Group
     # ==== Parameters
     # description<String>:: The description for this Thor::Group.
     #
-    def desc(description=nil)
-      @desc = case description
-      when nil
-        @desc || from_superclass(:desc, nil)
+    def desc(description = nil)
+      if description
+        @desc = description
       else
-        description
+        @desc ||= from_superclass(:desc, nil)
       end
     end
 
@@ -28,11 +27,11 @@ class Thor::Group
     # short:: When true, shows only usage.
     #
     def help(shell)
-      shell.say "Usage:"
+      shell.say 'Usage:'
       shell.say "  #{banner}\n"
       shell.say
       class_options_help(shell)
-      shell.say self.desc if self.desc
+      shell.say desc if desc
     end
 
     # Stores invocations for this class merging with superclass values.
@@ -54,7 +53,7 @@ class Thor::Group
     # The namespace/class given will have its options showed on the help
     # usage. Check invoke_from_option for more information.
     #
-    def invoke(*names, &block)
+    def invoke(*names, &block) # rubocop:disable MethodLength
       options = names.last.is_a?(Hash) ? names.pop : {}
       verbose = options.fetch(:verbose, true)
 
@@ -108,14 +107,14 @@ class Thor::Group
     # invoked. The block receives two parameters, an instance of the current
     # class and the klass to be invoked.
     #
-    def invoke_from_option(*names, &block)
+    def invoke_from_option(*names, &block) # rubocop:disable MethodLength
       options = names.last.is_a?(Hash) ? names.pop : {}
       verbose = options.fetch(:verbose, :white)
 
       names.each do |name|
         unless class_options.key?(name)
-          raise ArgumentError, "You have to define the option #{name.inspect} " <<
-                               "before setting invoke_from_option."
+          fail ArgumentError, "You have to define the option #{name.inspect} " <<
+                               'before setting invoke_from_option.'
         end
 
         invocations[name] = true
@@ -159,7 +158,7 @@ class Thor::Group
     # Overwrite class options help to allow invoked generators options to be
     # shown recursively when invoking a generator.
     #
-    def class_options_help(shell, groups={}) #:nodoc:
+    def class_options_help(shell, groups = {}) #:nodoc:
       get_options_from_invocations(groups, class_options) do |klass|
         klass.send(:get_options_from_invocations, groups, class_options)
       end
@@ -170,14 +169,14 @@ class Thor::Group
     # options are added to group_options hash. Options that already exists
     # in base_options are not added twice.
     #
-    def get_options_from_invocations(group_options, base_options) #:nodoc:
+    def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
       invocations.each do |name, from_option|
         value = if from_option
-          option = class_options[name]
-          option.type == :boolean ? name : option.default
-        else
-          name
-        end
+                  option = class_options[name]
+                  option.type == :boolean ? name : option.default
+                else
+                  name
+                end
         next unless value
 
         klass, _ = prepare_for_invocation(name, value)
@@ -200,70 +199,70 @@ class Thor::Group
     def printable_commands(*)
       item = []
       item << banner
-      item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
+      item << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : '')
       [item]
     end
-    alias printable_tasks printable_commands
+    alias_method :printable_tasks, :printable_commands
 
     def handle_argument_error(command, error, args, arity) #:nodoc:
       msg = "#{basename} #{command.name} takes #{arity} argument"
-      msg << "s" if arity > 1
-      msg << ", but it should not."
-      raise error, msg
+      msg << 's' if arity > 1
+      msg << ', but it should not.'
+      fail error, msg
     end
 
-    protected
+  protected
 
-      # The method responsible for dispatching given the args.
-      def dispatch(command, given_args, given_opts, config) #:nodoc:
-        if Thor::HELP_MAPPINGS.include?(given_args.first)
-          help(config[:shell])
-          return
-        end
+    # The method responsible for dispatching given the args.
+    def dispatch(command, given_args, given_opts, config) #:nodoc:
+      if Thor::HELP_MAPPINGS.include?(given_args.first)
+        help(config[:shell])
+        return
+      end
 
-        args, opts = Thor::Options.split(given_args)
-        opts = given_opts || opts
+      args, opts = Thor::Options.split(given_args)
+      opts = given_opts || opts
 
-        instance = new(args, opts, config)
-        yield instance if block_given?
+      instance = new(args, opts, config)
+      yield instance if block_given?
 
-        if command
-          instance.invoke_command(all_commands[command])
-        else
-          instance.invoke_all
-        end
+      if command
+        instance.invoke_command(all_commands[command])
+      else
+        instance.invoke_all
       end
+    end
 
-      # The banner for this class. You can customize it if you are invoking the
-      # thor class by another ways which is not the Thor::Runner.
-      def banner
-        "#{basename} #{self_command.formatted_usage(self, false)}"
-      end
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner.
+    def banner
+      "#{basename} #{self_command.formatted_usage(self, false)}"
+    end
 
-      # Represents the whole class as a command.
-      def self_command #:nodoc:
-        Thor::DynamicCommand.new(self.namespace, class_options)
-      end
-      alias self_task self_command
+    # Represents the whole class as a command.
+    def self_command #:nodoc:
+      Thor::DynamicCommand.new(namespace, class_options)
+    end
+    alias_method :self_task, :self_command
 
-      def baseclass #:nodoc:
-        Thor::Group
-      end
+    def baseclass #:nodoc:
+      Thor::Group
+    end
 
-      def create_command(meth) #:nodoc:
-        commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
-        true
-      end
-      alias create_task create_command
+    def create_command(meth) #:nodoc:
+      commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
+      true
+    end
+    alias_method :create_task, :create_command
   end
 
   include Thor::Base
 
-  protected
+protected
 
   # Shortcut to invoke with padding and block handling. Use internally by
   # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, command=nil, *args, &block) #:nodoc:
+  def _invoke_for_class_method(klass, command = nil, *args, &block) #:nodoc:
     with_padding do
       if block
         case block.arity