bundler 1.8.9 → 1.9.0.pre

data/lib/bundler/vendor/Molinillo-0.2.1/lib/molinillo/resolver.rb

@@ -0,0 +1,43 @@
+require 'molinillo/dependency_graph'
+
+module Bundler::Molinillo
+  # This class encapsulates a dependency resolver.
+  # The resolver is responsible for determining which set of dependencies to
+  # activate, with feedback from the the {#specification_provider}
+  #
+  #
+  class Resolver
+    require 'molinillo/resolution'
+
+    # @return [SpecificationProvider] the specification provider used
+    #   in the resolution process
+    attr_reader :specification_provider
+
+    # @return [UI] the UI module used to communicate back to the user
+    #   during the resolution process
+    attr_reader :resolver_ui
+
+    # @param  [SpecificationProvider] specification_provider
+    #   see {#specification_provider}
+    # @param  [UI] resolver_ui
+    #   see {#resolver_ui}
+    def initialize(specification_provider, resolver_ui)
+      @specification_provider = specification_provider
+      @resolver_ui = resolver_ui
+    end
+
+    # Resolves the requested dependencies into a {DependencyGraph},
+    # locking to the base dependency graph (if specified)
+    # @param [Array] requested an array of 'requested' dependencies that the
+    #   {#specification_provider} can understand
+    # @param [DependencyGraph,nil] base the base dependency graph to which
+    #   dependencies should be 'locked'
+    def resolve(requested, base = DependencyGraph.new)
+      Resolution.new(specification_provider,
+                     resolver_ui,
+                     requested,
+                     base).
+        resolve
+    end
+  end
+end

data/lib/bundler/vendor/Molinillo-0.2.1/lib/molinillo/state.rb

@@ -0,0 +1,43 @@
+module Bundler::Molinillo
+  # A state that a {Resolution} can be in
+  # @attr [String] name
+  # @attr [Array<Object>] requirements
+  # @attr [DependencyGraph] activated
+  # @attr [Object] requirement
+  # @attr [Object] possibility
+  # @attr [Integer] depth
+  # @attr [Set<Object>] conflicts
+  ResolutionState = Struct.new(
+    :name,
+    :requirements,
+    :activated,
+    :requirement,
+    :possibilities,
+    :depth,
+    :conflicts
+  )
+
+  # A state that encapsulates a set of {#requirements} with an {Array} of
+  # possibilities
+  class DependencyState < ResolutionState
+    # Removes a possibility from `self`
+    # @return [PossibilityState] a state with a single possibility,
+    #  the possibility that was removed from `self`
+    def pop_possibility_state
+      PossibilityState.new(
+        name,
+        requirements.dup,
+        activated.dup,
+        requirement,
+        [possibilities.pop],
+        depth + 1,
+        conflicts.dup
+      )
+    end
+  end
+
+  # A state that encapsulates a single possibility to fulfill the given
+  # {#requirement}
+  class PossibilityState < ResolutionState
+  end
+end

data/lib/bundler/vendor/{thor.rb → thor-0.19.1/lib/thor.rb}

@@ -1,7 +1,7 @@
-require 'set'
-require 'thor/base'
+require "set"
+require "thor/base"
 
-class Thor # rubocop:disable ClassLength
+class Bundler::Thor # rubocop:disable ClassLength
   class << self
     # Allows for custom "Command" package naming.
     #
@@ -10,7 +10,7 @@ class Thor # rubocop:disable ClassLength
     # options<Hash>
     #
     def package_name(name, options = {})
-      @package_name = name.nil? || name == '' ? nil : name
+      @package_name = name.nil? || name == "" ? nil : name
     end
 
     # Sets the default command when thor is executed without an explicit command to be called.
@@ -20,22 +20,22 @@ class Thor # rubocop:disable ClassLength
     #
     def default_command(meth = nil)
       if meth
-        @default_command = meth == :none ? 'help' : meth.to_s
+        @default_command = meth == :none ? "help" : meth.to_s
       else
-        @default_command ||= from_superclass(:default_command, 'help')
+        @default_command ||= from_superclass(:default_command, "help")
       end
     end
     alias_method :default_task, :default_command
 
-    # Registers another Thor subclass as a command.
+    # Registers another Bundler::Thor subclass as a command.
     #
     # ==== Parameters
-    # klass<Class>:: Thor subclass to register
+    # klass<Class>:: Bundler::Thor subclass to register
     # command<String>:: Subcommand name to use
     # usage<String>:: Short usage for the subcommand
     # description<String>:: Description for the subcommand
     def register(klass, subcommand_name, usage, description, options = {})
-      if klass <= Thor::Group
+      if klass <= Bundler::Thor::Group
         desc usage, description, options
         define_method(subcommand_name) { |*args| invoke(klass, args) }
       else
@@ -147,10 +147,10 @@ class Thor # rubocop:disable ClassLength
     #
     def method_option(name, options = {})
       scope = if options[:for]
-                find_and_refresh_command(options[:for]).options
-              else
-                method_options
-              end
+        find_and_refresh_command(options[:for]).options
+      else
+        method_options
+      end
 
       build_option(name, options, scope)
     end
@@ -159,7 +159,7 @@ class Thor # rubocop:disable ClassLength
     # Prints help information for the given command.
     #
     # ==== Parameters
-    # shell<Thor::Shell>
+    # shell<Bundler::Thor::Shell>
     # command_name<String>
     #
     def command_help(shell, command_name)
@@ -167,12 +167,12 @@ class Thor # rubocop:disable ClassLength
       command = all_commands[meth]
       handle_no_command_error(meth) unless command
 
-      shell.say 'Usage:'
+      shell.say "Usage:"
       shell.say "  #{banner(command)}"
       shell.say
       class_options_help(shell, nil => command.options.map { |_, o| o })
       if command.long_description
-        shell.say 'Description:'
+        shell.say "Description:"
         shell.print_wrapped(command.long_description, :indent => 2)
       else
         shell.say command.description
@@ -183,11 +183,11 @@ class Thor # rubocop:disable ClassLength
     # Prints help information for this class.
     #
     # ==== Parameters
-    # shell<Thor::Shell>
+    # shell<Bundler::Thor::Shell>
     #
     def help(shell, subcommand = false)
       list = printable_commands(true, subcommand)
-      Thor::Util.thor_classes_in(self).each do |klass|
+      Bundler::Thor::Util.thor_classes_in(self).each do |klass|
         list += klass.printable_commands(false)
       end
       list.sort! { |a, b| a[0] <=> b[0] }
@@ -195,7 +195,7 @@ class Thor # rubocop:disable ClassLength
       if defined?(@package_name) && @package_name
         shell.say "#{@package_name} commands:"
       else
-        shell.say 'Commands:'
+        shell.say "Commands:"
       end
 
       shell.print_table(list, :indent => 2, :truncate => true)
@@ -209,7 +209,7 @@ class Thor # rubocop:disable ClassLength
         next if command.hidden?
         item = []
         item << banner(command, false, subcommand)
-        item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : '')
+        item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : "")
         item
       end.compact
     end
@@ -220,12 +220,17 @@ class Thor # rubocop:disable ClassLength
     end
     alias_method :subtasks, :subcommands
 
+    def subcommand_classes
+      @subcommand_classes ||= {}
+    end
+
     def subcommand(subcommand, subcommand_class)
       subcommands << subcommand.to_s
       subcommand_class.subcommand_help subcommand
+      subcommand_classes[subcommand.to_s] = subcommand_class
 
       define_method(subcommand) do |*args|
-        args, opts = Thor::Arguments.split(args)
+        args, opts = Bundler::Thor::Arguments.split(args)
         args.unshift("help") if opts.include? "--help" or opts.include? "-h"
         invoke subcommand_class, args, opts, :invoked_via_subcommand => true, :class_options => options
       end
@@ -273,14 +278,14 @@ class Thor # rubocop:disable ClassLength
     # argument is encountered.  All remaining arguments are passed to the command.
     # This is useful if you have a command that can receive arbitrary additional
     # options, and where those additional options should not be handled by
-    # Thor.
+    # Bundler::Thor.
     #
     # ==== Example
     #
     # To better understand how this is useful, let's consider a command that calls
     # an external command.  A user may want to pass arbitrary options and
     # arguments to that command.  The command itself also accepts some options,
-    # which should be handled by Thor.
+    # which should be handled by Bundler::Thor.
     #
     #   class_option "verbose",  :type => :boolean
     #   stop_on_unknown_option! :exec
@@ -321,27 +326,18 @@ class Thor # rubocop:disable ClassLength
 
     # The method responsible for dispatching given the args.
     def dispatch(meth, given_args, given_opts, config) #:nodoc: # rubocop:disable MethodLength
-      # There is an edge case when dispatching from a subcommand.
-      # A problem occurs invoking the default command. This case occurs
-      # when arguments are passed and a default command is defined, and
-      # the first given_args does not match the default command.
-      # Thor use "help" by default so we skip that case.
-      # Note the call to retrieve_command_name. It's called with
-      # given_args.dup since that method calls args.shift. Then lookup
-      # the command normally. If the first item in given_args is not
-      # a command then use the default command. The given_args will be
-      # intact later since dup was used.
-      if config[:invoked_via_subcommand] && given_args.size >= 1 && default_command != 'help' && given_args.first != default_command
-        meth ||= retrieve_command_name(given_args.dup)
-        command = all_commands[normalize_command_name(meth)]
-        command ||= all_commands[normalize_command_name(default_command)]
-      else
-        meth ||= retrieve_command_name(given_args)
-        command = all_commands[normalize_command_name(meth)]
+      meth ||= retrieve_command_name(given_args)
+      command = all_commands[normalize_command_name(meth)]
+
+      if !command && config[:invoked_via_subcommand]
+        # We're a subcommand and our first argument didn't match any of our
+        # commands. So we put it back and call our default command.
+        given_args.unshift(meth)
+        command = all_commands[normalize_command_name(default_command)]
       end
 
       if command
-        args, opts = Thor::Options.split(given_args)
+        args, opts = Bundler::Thor::Options.split(given_args)
         if stop_on_unknown_option?(command) && !args.empty?
           # given_args starts with a non-option, so we treat everything as
           # ordinary arguments
@@ -364,7 +360,7 @@ class Thor # rubocop:disable ClassLength
     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. It receives
+    # thor class by another ways which is not the Bundler::Thor::Runner. It receives
     # the command that is going to be invoked and a boolean which indicates if
     # the namespace should be displayed as arguments.
     #
@@ -373,11 +369,11 @@ class Thor # rubocop:disable ClassLength
     end
 
     def baseclass #:nodoc:
-      Thor
+      Bundler::Thor
     end
 
     def dynamic_command_class #:nodoc:
-      Thor::DynamicCommand
+      Bundler::Thor::DynamicCommand
     end
 
     def create_command(meth) #:nodoc:
@@ -386,15 +382,15 @@ class Thor # rubocop:disable ClassLength
       @long_desc ||= nil
 
       if @usage && @desc
-        base_class = @hide ? Thor::HiddenCommand : Thor::Command
+        base_class = @hide ? Bundler::Thor::HiddenCommand : Bundler::Thor::Command
         commands[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
         @usage, @desc, @long_desc, @method_options, @hide = nil
         true
-      elsif all_commands[meth] || meth == 'method_missing'
+      elsif all_commands[meth] || meth == "method_missing"
         true
       else
         puts "[WARNING] Attempted to create command #{meth.inspect} without usage or description. " <<
-             'Call desc if you want this method to be available as command or declare it inside a ' <<
+             "Call desc if you want this method to be available as command or declare it inside a " <<
              "no_commands{} block. Invoked from #{caller[1].inspect}."
         false
       end
@@ -425,7 +421,7 @@ class Thor # rubocop:disable ClassLength
     # +normalize_command_name+ also converts names like +animal-prison+
     # into +animal_prison+.
     def normalize_command_name(meth) #:nodoc:
-      return default_command.to_s.gsub('-', '_') unless meth
+      return default_command.to_s.gsub("-", "_") unless meth
 
       possibilities = find_command_possibilities(meth)
       if possibilities.size > 1
@@ -438,7 +434,7 @@ class Thor # rubocop:disable ClassLength
         meth = possibilities.first
       end
 
-      meth.to_s.gsub('-', '_') # treat foo-bar as foo_bar
+      meth.to_s.gsub("-", "_") # treat foo-bar as foo_bar
     end
     alias_method :normalize_task_name, :normalize_command_name
 
@@ -461,7 +457,7 @@ class Thor # rubocop:disable ClassLength
     alias_method :find_task_possibilities, :find_command_possibilities
 
     def subcommand_help(cmd)
-      desc 'help [COMMAND]', 'Describe subcommands or one specific subcommand'
+      desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
       class_eval "
         def help(command = nil, subcommand = true); super; end
 "
@@ -469,12 +465,20 @@ class Thor # rubocop:disable ClassLength
     alias_method :subtask_help, :subcommand_help
   end
 
-  include Thor::Base
+  include Bundler::Thor::Base
 
   map HELP_MAPPINGS => :help
 
-  desc 'help [COMMAND]', 'Describe available commands or one specific command'
+  desc "help [COMMAND]", "Describe available commands or one specific command"
   def help(command = nil, subcommand = false)
-    command ? self.class.command_help(shell, command) : self.class.help(shell, subcommand)
+    if command
+      if self.class.subcommands.include? command
+        self.class.subcommand_classes[command].help(shell, true)
+      else
+        self.class.command_help(shell, command)
+      end
+    else
+      self.class.help(shell, subcommand)
+    end
   end
 end

data/lib/bundler/vendor/{thor → thor-0.19.1/lib/thor}/actions.rb

@@ -1,14 +1,14 @@
-require 'fileutils'
-require 'uri'
-require 'thor/core_ext/io_binary_read'
-require 'thor/actions/create_file'
-require 'thor/actions/create_link'
-require 'thor/actions/directory'
-require 'thor/actions/empty_directory'
-require 'thor/actions/file_manipulation'
-require 'thor/actions/inject_into_file'
-
-class Thor
+require "fileutils"
+require "uri"
+require "thor/core_ext/io_binary_read"
+require "thor/actions/create_file"
+require "thor/actions/create_link"
+require "thor/actions/directory"
+require "thor/actions/empty_directory"
+require "thor/actions/file_manipulation"
+require "thor/actions/inject_into_file"
+
+class Bundler::Thor
   module Actions
     attr_accessor :behavior
 
@@ -17,7 +17,7 @@ class Thor
     end
 
     module ClassMethods
-      # Hold source paths for one Thor instance. source_paths_for_search is the
+      # Hold source paths for one Bundler::Thor instance. source_paths_for_search is the
       # method responsible to gather source_paths from this current class,
       # inherited paths and the source root.
       #
@@ -48,17 +48,17 @@ class Thor
       # Add runtime options that help actions execution.
       #
       def add_runtime_options!
-        class_option :force, :type => :boolean, :aliases => '-f', :group => :runtime,
-                             :desc => 'Overwrite files that already exist'
+        class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                             :desc => "Overwrite files that already exist"
 
-        class_option :pretend, :type => :boolean, :aliases => '-p', :group => :runtime,
-                               :desc => 'Run but do not make any changes'
+        class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
+                               :desc => "Run but do not make any changes"
 
-        class_option :quiet, :type => :boolean, :aliases => '-q', :group => :runtime,
-                             :desc => 'Suppress status output'
+        class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
+                             :desc => "Suppress status output"
 
-        class_option :skip, :type => :boolean, :aliases => '-s', :group => :runtime,
-                            :desc => 'Skip files that already exist'
+        class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                            :desc => "Skip files that already exist"
       end
     end
 
@@ -73,10 +73,10 @@ class Thor
     #
     def initialize(args = [], options = {}, config = {})
       self.behavior = case config[:behavior].to_s
-                      when 'force', 'skip'
+                      when "force", "skip"
                         _cleanup_options_and_set(options, config[:behavior])
                         :invoke
-                      when 'revoke'
+                      when "revoke"
                         :revoke
                       else
                         :invoke
@@ -106,7 +106,7 @@ class Thor
     #
     def destination_root=(root)
       @destination_stack ||= []
-      @destination_stack[0] = File.expand_path(root || '')
+      @destination_stack[0] = File.expand_path(root || "")
     end
 
     # Returns the given path relative to the absolute root (ie, root where
@@ -114,8 +114,8 @@ class Thor
     #
     def relative_to_original_destination_root(path, remove_dot = true)
       path = path.dup
-      if path.gsub!(@destination_stack[0], '.')
-        remove_dot ? (path[2..-1] || '') : path
+      if path.gsub!(@destination_stack[0], ".")
+        remove_dot ? (path[2..-1] || "") : path
       else
         path
       end
@@ -147,7 +147,7 @@ class Thor
       end
 
       if source_paths.empty?
-        message << 'Currently you have no source paths.'
+        message << "Currently you have no source paths."
       else
         message << "Your current source paths are: \n#{source_paths.join("\n")}"
       end
@@ -164,7 +164,7 @@ class Thor
     # dir<String>:: the directory to move to.
     # config<Hash>:: give :verbose => true to log and use padding.
     #
-    def inside(dir = '', config = {}, &block)
+    def inside(dir = "", config = {}, &block)
       verbose = config.fetch(:verbose, false)
       pretend = options[:pretend]
 
@@ -215,7 +215,7 @@ class Thor
       shell.padding += 1 if verbose
 
       if is_uri
-        contents = open(path, 'Accept' => 'application/x-thor-template') { |io| io.read }
+        contents = open(path, "Accept" => "application/x-thor-template") { |io| io.read }
       else
         contents = open(path) { |io| io.read }
       end
@@ -263,7 +263,7 @@ class Thor
     #
     def run_ruby_script(command, config = {})
       return unless behavior == :invoke
-      run command, config.merge(:with => Thor::Util.ruby_command)
+      run command, config.merge(:with => Bundler::Thor::Util.ruby_command)
     end
 
     # Run a thor command. A hash of options can be given and it's converted to
@@ -273,7 +273,7 @@ class Thor
     # command<String>:: the command to be invoked
     # args<Array>:: arguments to the command
     # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
-    #                Other options are given as parameter to Thor.
+    #                Other options are given as parameter to Bundler::Thor.
     #
     #
     # ==== Examples
@@ -291,8 +291,8 @@ class Thor
       capture = config.key?(:capture) ? config.delete(:capture) : false
 
       args.unshift(command)
-      args.push Thor::Options.to_switches(config)
-      command = args.join(' ').strip
+      args.push Bundler::Thor::Options.to_switches(config)
+      command = args.join(" ").strip
 
       run command, :with => :thor, :verbose => verbose, :pretend => pretend, :capture => capture
     end
@@ -308,10 +308,10 @@ class Thor
     def _cleanup_options_and_set(options, key) #:nodoc:
       case options
       when Array
-        %w(--force -f --skip -s).each { |i| options.delete(i) }
+        %w[--force -f --skip -s].each { |i| options.delete(i) }
         options << "--#{key}"
       when Hash
-        [:force, :skip, 'force', 'skip'].each { |i| options.delete(i) }
+        [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
         options.merge!(key => true)
       end
     end