bundler 2.0.2

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

@@ -0,0 +1,135 @@
+class Bundler::Thor
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
+    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
+
+    def initialize(name, description, long_description, usage, options = nil)
+      super(name.to_s, description, long_description, usage, options || {})
+    end
+
+    def initialize_copy(other) #:nodoc:
+      super(other)
+      self.options = other.options.dup if other.options
+    end
+
+    def hidden?
+      false
+    end
+
+    # By default, a command invokes a method in the thor class. You can change this
+    # implementation to create custom commands.
+    def run(instance, args = [])
+      arity = nil
+
+      if private_method?(instance)
+        instance.class.handle_no_command_error(name)
+      elsif public_method?(instance)
+        arity = instance.method(name).arity
+        instance.__send__(name, *args)
+      elsif local_method?(instance, :method_missing)
+        instance.__send__(:method_missing, name.to_sym, *args)
+      else
+        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)
+    rescue NoMethodError => e
+      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
+    end
+
+    # Returns the formatted usage by injecting given required arguments
+    # and required options into the given usage.
+    def formatted_usage(klass, namespace = true, subcommand = false)
+      if ancestor_name
+        formatted = "#{ancestor_name} ".dup # add space
+      elsif namespace
+        namespace = klass.namespace
+        formatted = "#{namespace.gsub(/^(default)/, '')}:".dup
+      end
+      formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand
+
+      formatted ||= "".dup
+
+      # Add usage with required arguments
+      formatted << if klass && !klass.arguments.empty?
+                     usage.to_s.gsub(/^#{name}/) do |match|
+                       match << " " << klass.arguments.map(&:usage).compact.join(" ")
+                     end
+                   else
+                     usage.to_s
+                   end
+
+      # Add required options
+      formatted << " #{required_options}"
+
+      # Strip and go!
+      formatted.strip
+    end
+
+  protected
+
+    def not_debugging?(instance)
+      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+    end
+
+    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 a public method.
+    def public_method?(instance) #:nodoc:
+      !(instance.public_methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def private_method?(instance)
+      !(instance.private_methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def local_method?(instance, name)
+      methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
+      !(methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def sans_backtrace(backtrace, caller) #:nodoc:
+      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) }
+      saned - caller
+    end
+
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && 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")
+      end
+    end
+
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) &&
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    end
+  end
+  Task = Command
+
+  # A command that is hidden in help messages but still invocable.
+  class HiddenCommand < Command
+    def hidden?
+      true
+    end
+  end
+  HiddenTask = HiddenCommand
+
+  # 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)
+    end
+
+    def run(instance, args = [])
+      if (instance.methods & [name.to_s, name.to_sym]).empty?
+        super
+      else
+        instance.class.handle_no_command_error(name)
+      end
+    end
+  end
+  DynamicTask = DynamicCommand
+end

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

@@ -0,0 +1,97 @@
+class Bundler::Thor
+  module CoreExt #:nodoc:
+    # A hash with indifferent access and magic predicates.
+    #
+    #   hash = Bundler::Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #   hash.foo?   #=> true
+    #
+    class HashWithIndifferentAccess < ::Hash #:nodoc:
+      def initialize(hash = {})
+        super()
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def fetch(key, *args)
+        super(convert_key(key), *args)
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.map { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def reverse_merge(other)
+        self.class.new(other).merge(self)
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge(other_hash))
+      end
+
+      def replace(other_hash)
+        super(other_hash)
+      end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge!(self)
+      end
+
+    protected
+
+      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)
+        method = method.to_s
+        if method =~ /^(\w+)\?$/
+          if args.empty?
+            !!self[$1]
+          else
+            self[$1] == args.first
+          end
+        else
+          self[method]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class IO #:nodoc:
+  class << self
+    unless method_defined? :binread
+      def binread(file, *args)
+        raise 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
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+class Bundler::Thor
+  module CoreExt
+    class OrderedHash < ::Hash
+      if RUBY_VERSION < "1.9"
+        def initialize(*args, &block)
+          super
+          @keys = []
+        end
+
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
+        end
+
+        def []=(key, value)
+          @keys << key unless key?(key)
+          super
+        end
+
+        def delete(key)
+          if key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
+
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
+
+        alias_method :reject!, :delete_if
+
+        def reject(&block)
+          dup.reject!(&block)
+        end
+
+        def keys
+          @keys.dup
+        end
+
+        def values
+          @keys.map { |key| self[key] }
+        end
+
+        def to_hash
+          self
+        end
+
+        def to_a
+          @keys.map { |key| [key, self[key]] }
+        end
+
+        def each_key
+          return to_enum(:each_key) unless block_given?
+          @keys.each { |key| yield(key) }
+          self
+        end
+
+        def each_value
+          return to_enum(:each_value) unless block_given?
+          @keys.each { |key| yield(self[key]) }
+          self
+        end
+
+        def each
+          return to_enum(:each) unless block_given?
+          @keys.each { |key| yield([key, self[key]]) }
+          self
+        end
+
+        def each_pair
+          return to_enum(:each_pair) unless block_given?
+          @keys.each { |key| yield(key, self[key]) }
+          self
+        end
+
+        alias_method :select, :find_all
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
+
+        def merge!(other_hash)
+          if block_given?
+            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+          else
+            other_hash.each { |k, v| self[k] = v }
+          end
+          self
+        end
+
+        alias_method :update, :merge!
+
+        def merge(other_hash, &block)
+          dup.merge!(other_hash, &block)
+        end
+
+        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+        def replace(other)
+          super
+          @keys = other.keys
+          self
+        end
+
+        def inspect
+          "#<#{self.class} #{super}>"
+        end
+
+        private
+
+        def sync_keys!
+          @keys.delete_if { |k| !key?(k) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+class Bundler::Thor
+  Correctable =
+    begin
+      require 'did_you_mean'
+
+      # In order to support versions of Ruby that don't have keyword
+      # arguments, we need our own spell checker class that doesn't take key
+      # words. Even though this code wouldn't be hit because of the check
+      # above, it's still necessary because the interpreter would otherwise be
+      # unable to parse the file.
+      class NoKwargSpellChecker < DidYouMean::SpellChecker # :nodoc:
+        def initialize(dictionary)
+          @dictionary = dictionary
+        end
+      end
+
+      DidYouMean::Correctable
+    rescue LoadError, NameError
+    end
+
+  # Bundler::Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+  # errors have their backtrace suppressed and are nicely shown to the user.
+  #
+  # Errors that are caused by the developer, like declaring a method which
+  # overwrites a thor keyword, SHOULD NOT raise a Bundler::Thor::Error. This way, we
+  # ensure that developer errors are shown with full backtrace.
+  class Error < StandardError
+  end
+
+  # Raised when a command was not found.
+  class UndefinedCommandError < Error
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||= spell_checker.correct(error.command).map(&:inspect)
+      end
+
+      def spell_checker
+        NoKwargSpellChecker.new(error.all_commands)
+      end
+    end
+
+    attr_reader :command, :all_commands
+
+    def initialize(command, all_commands, namespace)
+      @command = command
+      @all_commands = all_commands
+
+      message = "Could not find command #{command.inspect}"
+      message = namespace ? "#{message} in #{namespace.inspect} namespace." : "#{message}."
+
+      super(message)
+    end
+
+    prepend Correctable if Correctable
+  end
+  UndefinedTaskError = UndefinedCommandError
+
+  class AmbiguousCommandError < Error
+  end
+  AmbiguousTaskError = AmbiguousCommandError
+
+  # Raised when a command was found, but not invoked properly.
+  class InvocationError < Error
+  end
+
+  class UnknownArgumentError < Error
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||=
+          error.unknown.flat_map { |unknown| spell_checker.correct(unknown) }.uniq.map(&:inspect)
+      end
+
+      def spell_checker
+        @spell_checker ||= NoKwargSpellChecker.new(error.switches)
+      end
+    end
+
+    attr_reader :switches, :unknown
+
+    def initialize(switches, unknown)
+      @switches = switches
+      @unknown = unknown
+
+      super("Unknown switches #{unknown.map(&:inspect).join(', ')}")
+    end
+
+    prepend Correctable if Correctable
+  end
+
+  class RequiredArgumentMissingError < InvocationError
+  end
+
+  class MalformattedArgumentError < InvocationError
+  end
+
+  if Correctable
+    DidYouMean::SPELL_CHECKERS.merge!(
+      'Bundler::Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
+      'Bundler::Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
+    )
+  end
+end