bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/vendor/molinillo/lib/molinillo/gem_metadata.rb

@@ -1,3 +1,3 @@
 module Bundler::Molinillo
-  VERSION = '0.2.3'
+  VERSION = '0.4.0'
 end

data/lib/bundler/vendor/molinillo/lib/molinillo/modules/specification_provider.rb

@@ -86,5 +86,14 @@ module Bundler::Molinillo
         ]
       end
     end
+
+    # Returns whether this dependency, which has no possible matching
+    # specifications, can safely be ignored.
+    #
+    # @param [Object] dependency
+    # @return [Boolean] whether this dependency can safely be skipped.
+    def allow_missing?(dependency)
+      false
+    end
   end
 end

data/lib/bundler/vendor/molinillo/lib/molinillo/resolution.rb

@@ -12,13 +12,15 @@ module Bundler::Molinillo
       # @attr [Object] locked_requirement the relevant locking requirement.
       # @attr [Array<Array<Object>>] requirement_trees the different requirement
       #   trees that led to every requirement for the conflicting name.
+      # @attr [{String=>Object}] activated_by_name the already-activated specs.
       Conflict = Struct.new(
         :requirement,
         :requirements,
         :existing,
         :possibility,
         :locked_requirement,
-        :requirement_trees
+        :requirement_trees,
+        :activated_by_name
       )
 
       # @return [SpecificationProvider] the provider that knows about
@@ -93,7 +95,7 @@ module Bundler::Molinillo
       def start_resolution
         @started_at = Time.now
 
-        states.push(initial_state)
+        handle_missing_or_push_dependency_state(initial_state)
 
         debug { "Starting resolution (#{@started_at})" }
         resolver_ui.before_resolution
@@ -116,7 +118,8 @@ module Bundler::Molinillo
 
       ResolutionState.new.members.each do |member|
         define_method member do |*args, &block|
-          state.send(member, *args, &block)
+          current_state = state || ResolutionState.empty
+          current_state.send(member, *args, &block)
         end
       end
 
@@ -163,7 +166,7 @@ module Bundler::Molinillo
       # @return [DependencyState] the initial state for the resolution
       def initial_state
         graph = DependencyGraph.new.tap do |dg|
-          original_requested.each { |r| dg.add_root_vertex(name_for(r), nil).tap { |v| v.explicit_requirements << r } }
+          original_requested.each { |r| dg.add_vertex(name_for(r), nil, true).tap { |v| v.explicit_requirements << r } }
         end
 
         requirements = sort_dependencies(original_requested, graph, {})
@@ -215,7 +218,7 @@ module Bundler::Molinillo
         return nil unless requirement
         seen = false
         state = states.reverse_each.find do |s|
-          seen ||= s.requirement == requirement
+          seen ||= s.requirement == requirement || s.requirements.include?(requirement)
           seen && s.requirement != requirement && !s.requirements.include?(requirement)
         end
         state && state.requirement
@@ -249,21 +252,23 @@ module Bundler::Molinillo
           name_for_explicit_dependency_source => vertex.explicit_requirements,
           name_for_locking_dependency_source => Array(locked_requirement_named(name)),
         }
-        vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(*edge.requirements) }
+        vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(edge.requirement) }
         conflicts[name] = Conflict.new(
           requirement,
           Hash[requirements.select { |_, r| !r.empty? }],
           vertex.payload,
           possibility,
           locked_requirement_named(name),
-          requirement_trees
+          requirement_trees,
+          Hash[activated.map { |v| [v.name, v.payload] }.select(&:last)]
         )
       end
 
       # @return [Array<Array<Object>>] The different requirement
       #   trees that led to every requirement for the current spec.
       def requirement_trees
-        activated.vertex_named(name).requirements.map { |r| requirement_tree_for(r) }
+        vertex = activated.vertex_named(name)
+        vertex.requirements.map { |r| requirement_tree_for(r) }
       end
 
       # @return [Array<Object>] the list of requirements that led to
@@ -321,7 +326,7 @@ module Bundler::Molinillo
         existing_spec = existing_node.payload
         if requirement_satisfied_by?(requirement, activated, existing_spec)
           new_requirements = requirements.dup
-          push_state_for_requirements(new_requirements)
+          push_state_for_requirements(new_requirements, false)
         else
           return if attempt_to_swap_possibility
           create_conflict
@@ -388,28 +393,42 @@ module Bundler::Molinillo
       def require_nested_dependencies_for(activated_spec)
         nested_dependencies = dependencies_for(activated_spec)
         debug(depth) { "Requiring nested dependencies (#{nested_dependencies.map(&:to_s).join(', ')})" }
-        nested_dependencies.each { |d|  activated.add_child_vertex name_for(d), nil, [name_for(activated_spec)], d }
+        nested_dependencies.each { |d| activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d) }
 
-        push_state_for_requirements(requirements + nested_dependencies)
+        push_state_for_requirements(requirements + nested_dependencies, nested_dependencies.size > 0)
       end
 
       # Pushes a new {DependencyState} that encapsulates both existing and new
       # requirements
       # @param [Array] new_requirements
       # @return [void]
-      def push_state_for_requirements(new_requirements)
-        new_requirements = sort_dependencies(new_requirements.uniq, activated, conflicts)
+      def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated.dup)
+        new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts) if requires_sort
         new_requirement = new_requirements.shift
-        states.push DependencyState.new(
-          new_requirement ? name_for(new_requirement) : '',
-          new_requirements,
-          activated.dup,
-          new_requirement,
-          new_requirement ? search_for(new_requirement) : [],
-          depth,
-          conflicts.dup
+        new_name = new_requirement ? name_for(new_requirement) : ''
+        possibilities = new_requirement ? search_for(new_requirement) : []
+        handle_missing_or_push_dependency_state DependencyState.new(
+          new_name, new_requirements, new_activated,
+          new_requirement, possibilities, depth, conflicts.dup
         )
       end
+
+      # Pushes a new {DependencyState}.
+      # If the {#specification_provider} says to
+      # {SpecificationProvider#allow_missing?} that particular requirement, and
+      # there are no possibilities for that requirement, then `state` is not
+      # pushed, and the node in {#activated} is removed, and we continue
+      # resolving the remaining requirements.
+      # @param [DependencyState] state
+      # @return [void]
+      def handle_missing_or_push_dependency_state(state)
+        if state.requirement && state.possibilities.empty? && allow_missing?(state.requirement)
+          state.activated.detach_vertex_named(state.name)
+          push_state_for_requirements(state.requirements.dup, false, state.activated)
+        else
+          states.push state
+        end
+      end
     end
   end
 end

data/lib/bundler/vendor/molinillo/lib/molinillo/state.rb

@@ -17,6 +17,14 @@ module Bundler::Molinillo
     :conflicts
   )
 
+  class ResolutionState
+    # Returns an empty resolution state
+    # @return [ResolutionState] an empty state
+    def self.empty
+      new(nil, [], DependencyGraph.new, nil, nil, 0, Set.new)
+    end
+  end
+
   # A state that encapsulates a set of {#requirements} with an {Array} of
   # possibilities
   class DependencyState < ResolutionState

data/lib/bundler/vendored_molinillo.rb

@@ -1,2 +1,2 @@
 module Bundler; end
-require 'bundler/vendor/molinillo/lib/molinillo'
+require "bundler/vendor/molinillo/lib/molinillo"

data/lib/bundler/vendored_persistent.rb

@@ -1,11 +1,11 @@
 # We forcibly require OpenSSL, because net/http/persistent will only autoload
 # it. On some Rubies, autoload fails but explicit require succeeds.
 begin
-  require 'openssl'
+  require "openssl"
 rescue LoadError
   # some Ruby builds don't have OpenSSL
 end
 
-vendor = File.expand_path('../vendor', __FILE__)
+vendor = File.expand_path("../vendor", __FILE__)
 $:.unshift(vendor) unless $:.include?(vendor)
-require 'net/http/persistent'
+require "net/http/persistent"

data/lib/bundler/vendored_thor.rb

@@ -1,3 +1,3 @@
 module Bundler; end
-require 'bundler/vendor/thor/lib/thor'
-require 'bundler/vendor/thor/lib/thor/actions'
+require "bundler/vendor/thor/lib/thor"
+require "bundler/vendor/thor/lib/thor/actions"

data/lib/bundler/version.rb

@@ -2,5 +2,5 @@ module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.10.6" unless defined?(::Bundler::VERSION)
+  VERSION = "1.11.0.pre.1" unless defined?(::Bundler::VERSION)
 end

data/lib/bundler/vlad.rb

@@ -2,7 +2,7 @@
 #
 # Just add "require 'bundler/vlad'" in your Vlad deploy.rb, and
 # include the vlad:bundle:install task in your vlad:deploy task.
-require 'bundler/deployment'
+require "bundler/deployment"
 
 include Rake::DSL if defined? Rake::DSL
 

data/lib/bundler/worker.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require "thread"
 
 module Bundler
   class Worker
@@ -19,7 +19,7 @@ module Bundler
       @request_queue = Queue.new
       @response_queue = Queue.new
       @func = func
-      @threads = size.times.map { |i| Thread.start { process_queue(i) } }
+      @threads = size.times.map {|i| Thread.start { process_queue(i) } }
       trap("INT") { abort_threads }
     end
 
@@ -61,13 +61,12 @@ module Bundler
     # so as worker threads after retrieving it, shut themselves down
     def stop_threads
       @threads.each { @request_queue.enq POISON }
-      @threads.each { |thread| thread.join }
+      @threads.each(&:join)
     end
 
     def abort_threads
-      @threads.each {|i| i.exit }
+      @threads.each(&:exit)
       exit 1
     end
-
   end
 end

data/man/bundle-config.ronn

@@ -84,8 +84,10 @@ The following is a list of all configuration keys and their purpose. You can
 learn more about their operation in [bundle install(1)][bundle-install].
 
 * `path` (`BUNDLE_PATH`):
-  The location on disk to install gems. Defaults to `$GEM_HOME` in development
-  and `vendor/bundle` when `--deployment` is used
+  The location on disk where all gems in your bundle will be located regardless
+  of `$GEM_HOME` or `$GEM_PATH` values. Bundle gems not found in this location
+  will be installed by `bundle install`. Defaults to `Gem.dir`. When --deployment is
+  used, defaults to vendor/bundle.
 * `frozen` (`BUNDLE_FROZEN`):
   Disallow changes to the `Gemfile`. Defaults to `true` when `--deployment`
   is used.

data/man/bundle-gem.ronn

@@ -0,0 +1,77 @@
+bundle-gem(1) -- Generate a project skeleton for creating a rubygem
+====================================================================
+
+## SYNOPSIS
+
+`bundle gem` <GEM_NAME> [OPTIONS]
+
+## DESCRIPTION
+
+Generates a directory named `GEM_NAME` with a `Rakefile`, `GEM_NAME.gemspec`,
+and other supporting files and directories that can be used to develop a
+rubygem with that name.
+
+Run `rake -T` in the resulting project for a list of Rake tasks that can used
+to test and publish the gem to rubygems.org.
+
+The generated project skeleton can be customized with OPTIONS, as explained
+below. Note that these options can also be specified via Bundler's global
+configuration file using the following names:
+
+* `gem.coc`
+* `gem.mit`
+* `gem.test`
+
+## OPTIONS
+
+* `-b` or `--bin`:
+  Specify that Bundler should create a binary (as `exe/GEM_NAME`) in the
+  generated rubygem project. This binary will also be added to the
+  `GEM_NAME.gemspec` manifest. This behavior is disabled by default.
+
+* `--no-bin`:
+  Do not create a binary (overrides `--bin` specified in the global config).
+
+* `--coc`:
+  Add a `CODE_OF_CONDUCT.md` file to the root of the generated project. If
+  this option is unspecified, an interactive prompt will be displayed and the
+  answer will be saved in Bundler's global config for future `bundle gem` use.
+
+* `--no-coc`:
+  Do not create a `CODE_OF_CONDUCT.md` (overrides `--coc` specified in the
+  global config).
+
+* `--ext`:
+  Add boilerplate for C extension code to the generated project. This behavior
+  is disabled by default.
+
+* `--no-ext`:
+  Do not add C extension code (overrides `--ext` specified in the global
+  config).
+
+* `--mit`:
+  Add an MIT license to a `LICENSE.txt` file in the root of the generated
+  project. Your name from the global git config is used for the copyright
+  statement. If this option is unspecified, an interactive prompt will be
+  displayed and the answer will be saved in Bundler's global config for future
+  `bundle gem` use.
+
+* `--no-mit`:
+  Do not create a `LICENSE.txt` (overrides `--mit` specified in the global
+  config).
+
+* `-t`, `--test=minitest`, `--test=rspec`:
+  Specify the test framework that Bundler should use when generating the
+  project. Acceptable values are `minitest` and `rspec`. The `GEM_NAME.gemspec`
+  will be configured and a skeleton test/spec directory will be created based
+  on this option. If this option is unspecified, an interactive prompt will be
+  displayed and the answer will be saved in Bundler's global config for future
+  `bundle gem` use.
+
+* `-e`, `--edit[=EDITOR]`:
+  Open the resulting GEM_NAME.gemspec in EDITOR, or the default editor if not
+  specified. The default is `$BUNDLER_EDITOR`, `$VISUAL`, or `$EDITOR`.
+
+## SEE ALSO
+
+* bundle-config(1)

data/man/bundle-install.ronn

@@ -10,6 +10,7 @@ bundle-install(1) -- Install the dependencies specified in your Gemfile
                  [--jobs=NUMBER]
                  [--local]
                  [--deployment]
+                 [--force]
                  [--no-cache]
                  [--no-prune]
                  [--path PATH]
@@ -67,7 +68,8 @@ update process below under [CONSERVATIVE UPDATING][].
   to this location.
 
 * `--jobs=[<number>]`:
-  Install gems by starting <number> of workers parallely.
+  The maximum number of parallel download and install jobs. The default
+  is `1`.
 
 * `--local`:
   Do not attempt to connect to `rubygems.org`. Instead, Bundler will use the
@@ -77,8 +79,12 @@ update process below under [CONSERVATIVE UPDATING][].
 
 * `--deployment`:
   In [deployment mode][DEPLOYMENT MODE], Bundler will 'roll-out' the bundle for
-  `production` use. Please check carefully if you want to have this option
-  enabled in `development` or `test` environments.
+  production or CI use. Please check carefully if you want to have this option
+  enabled in your development environment.
+
+* `--force`:
+  Force download every gem, even if the required versions are already available
+  locally.
 
 * `--system`:
   Installs the gems specified in the bundle to the system's Rubygems location.
@@ -118,7 +124,8 @@ update process below under [CONSERVATIVE UPDATING][].
   runtime. A space separated list of groups to install has to be specified.
   Bundler creates a directory named `bundle` and installs the bundle there. It
   also generates a `bundle/bundler/setup.rb` file to replace Bundler's own setup
-  in the manner required.
+  in the manner required. Using this option implicitly sets `path`, which is a
+  [remembered option][REMEMBERED OPTIONS].
 
 * `--trust-policy=[<policy>]`:
   Apply the Rubygems security policy <policy>, where policy is one of
@@ -142,8 +149,8 @@ update process below under [CONSERVATIVE UPDATING][].
 ## DEPLOYMENT MODE
 
 Bundler's defaults are optimized for development. To switch to
-defaults optimized for deployment, use the `--deployment` flag.
-Do not activate deployment mode on development machines, as it
+defaults optimized for deployment and for CI, use the `--deployment`
+flag. Do not activate deployment mode on development machines, as it
 will cause an error when the Gemfile(5) is modified.
 
 1. A `Gemfile.lock` is required.

data/man/bundle-lock.ronn

@@ -0,0 +1,47 @@
+bundle-lock(1) -- Creates / Updates a lockfile without installing
+=================================================================
+
+## SYNOPSIS
+
+`bundle lock` [--update]
+              [--local]
+              [--print]
+              [--lockfile=PATH]
+
+## DESCRIPTION
+
+Lock the gems specified in Gemfile.
+
+## OPTIONS
+
+* `--update=<*gems>`:
+  Ignores the existing lockfile. Resolve then updates lockfile. Taking a list
+  of gems or updating all gems if no list is given.
+
+* `--local`:
+  Do not attempt to connect to `rubygems.org`. Instead, Bundler will use the
+  gems already present in Rubygems' cache or in `vendor/cache`. Note that if a
+  appropriate platform-specific gem exists on `rubygems.org` it will not be
+  found.
+
+* `--print`:
+  Prints the lockfile to STDOUT instead of writing to the file system.
+
+* `--lockfile=<path>`:
+  The path where the lockfile should be written to.
+
+## UPDATING ALL GEMS
+
+If you run `bundle lock` with `--update` option without list of gems, bundler will
+ignore any previously installed gems and resolve all dependencies again based
+on the latest versions of all gems available in the sources.
+
+## UPDATING A LIST OF GEMS
+
+Sometimes, you want to update a single gem in the Gemfile(5), and leave the rest of
+the gems that you specified locked to the versions in the `Gemfile.lock`.
+
+For instance, you only want to update `nokogiri`, run `bundle lock --update nokogiri`.
+
+Bundler will update `nokogiri` and any of its dependencies, but leave the rest of the
+gems that you specified locked to the versions in the `Gemfile.lock`.

data/man/bundle.ronn

@@ -76,7 +76,7 @@ We divide `bundle` subcommands into primary commands and utilities.
 * `bundle init(1)`:
   Generate a simple `Gemfile`, placed in the current directory
 
-* `bundle gem(1)`:
+* [bundle gem(1)][bundle-gem]:
   Create a simple gem, suitable for development with bundler
 
 * [bundle platform(1)][bundle-platform]: