bundler 1.8.9 → 1.9.0.pre

data/lib/bundler/rubygems_ext.rb

@@ -72,7 +72,7 @@ module Gem
     end
 
     def to_gemfile(path = nil)
-      gemfile = "source :gemcutter\n"
+      gemfile = "source 'https://rubygems.org'\n"
       gemfile << dependencies_to_gemfile(nondevelopment_dependencies)
       unless development_dependencies.empty?
         gemfile << "\n"

data/lib/bundler/rubygems_integration.rb

@@ -161,14 +161,12 @@ module Bundler
     end
 
     def with_build_args(args)
-      ext_lock.synchronize do
-        old_args = self.build_args
-        begin
-          self.build_args = args
-          yield
-        ensure
-          self.build_args = old_args
-        end
+      old_args = self.build_args
+      begin
+        self.build_args = args
+        yield
+      ensure
+        self.build_args = old_args
       end
     end
 
@@ -585,12 +583,6 @@ module Bundler
       def ext_lock
         Gem::Ext::Builder::CHDIR_MONITOR
       end
-
-      def find_name(name)
-        Gem::Specification.stubs.find_all do |spec|
-          spec.name == name
-        end.map(&:to_spec)
-      end
     end
 
   end

data/lib/bundler/runtime.rb

@@ -88,6 +88,9 @@ module Bundler
               raise if $1 != namespaced_file
             end
           end
+        rescue => e
+          Bundler.ui.debug e
+          Bundler.ui.warn "Unable to require #{required_file}. #{e.class}: #{e.message}."
         end
       end
     end

data/lib/bundler/shared_helpers.rb

@@ -35,27 +35,32 @@ module Bundler
     end
 
     def default_bundle_dir
-      bundle_dir = find_directory(".bundle")
-      return nil unless bundle_dir
-
       global_bundle_dir = File.join(Bundler.rubygems.user_home, ".bundle")
-      return nil if bundle_dir == global_bundle_dir
+      bundle_dir = find_directory(".bundle")
 
-      Pathname.new(bundle_dir)
+      if bundle_dir && bundle_dir != global_bundle_dir
+        Pathname.new(bundle_dir)
+      else
+        nil
+      end
     end
 
     def in_bundle?
       find_gemfile
     end
 
+    def chdir_monitor
+      Bundler.rubygems.ext_lock
+    end
+
     def chdir(dir, &blk)
-      Bundler.rubygems.ext_lock.synchronize do
+      chdir_monitor.synchronize do
         Dir.chdir dir, &blk
       end
     end
 
     def pwd
-      Bundler.rubygems.ext_lock.synchronize do
+      chdir_monitor.synchronize do
         Dir.pwd
       end
     end

data/lib/bundler/source.rb

@@ -37,10 +37,5 @@ module Bundler
     def can_lock?(spec)
       spec.source == self
     end
-
-    def include?(other)
-      other == self
-    end
-
   end
 end

data/lib/bundler/source/path.rb

@@ -130,7 +130,8 @@ module Bundler
         index = Index.new
 
         if File.directory?(expanded_path)
-          Dir["#{expanded_path}/#{@glob}"].each do |file|
+          # We sort depth-first since `<<` will override the earlier-found specs
+          Dir["#{expanded_path}/#{@glob}"].sort_by { |p| -p.split(File::SEPARATOR).size }.each do |file|
             spec = Bundler.load_gemspec(file)
             if spec
               spec.loaded_from = file.to_s

data/lib/bundler/source/path/installer.rb

@@ -3,8 +3,6 @@ module Bundler
     class Path
 
       class Installer < Bundler::GemInstaller
-        attr_reader :spec
-
         def initialize(spec, options = {})
           @spec              = spec
           @tmp_bin_dir       = "#{Bundler.tmp(spec.full_name)}/bin"

data/lib/bundler/source/rubygems.rb

@@ -36,15 +36,11 @@ module Bundler
       end
 
       def eql?(o)
-        o.is_a?(Rubygems) && o.credless_remotes == credless_remotes
+        o.is_a?(Rubygems) && remotes_equal?(o.remotes)
       end
 
       alias == eql?
 
-      def include?(o)
-        o.is_a?(Rubygems) && (o.credless_remotes - credless_remotes).empty?
-      end
-
       def can_lock?(spec)
         spec.source.is_a?(Rubygems)
       end
@@ -204,12 +200,6 @@ module Bundler
 
     protected
 
-      def credless_remotes
-        remotes.map(&method(:suppress_configured_credentials))
-      end
-
-    private
-
       def source_uris_for_spec(spec)
         specs.search_all(spec.name).inject([]) do |uris, s|
           uris << s.source_uri.without_credentials if s.source_uri
@@ -217,6 +207,8 @@ module Bundler
         end
       end
 
+    private
+
       def loaded_from(spec)
         "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
       end
@@ -315,6 +307,8 @@ module Bundler
           # the gemspecs of those gems, if the non-api sites contain more than
           # about 100 gems, we just treat all sites as non-api for speed.
           allow_api = idx.size < API_REQUEST_LIMIT && dependency_names.size < API_REQUEST_LIMIT
+          Bundler.ui.debug "Need to query more than #{API_REQUEST_LIMIT} gems." \
+            " Downloading full index instead..." unless allow_api
 
           if allow_api
             api_fetchers.each do |f|
@@ -376,6 +370,10 @@ module Bundler
         spec.loaded_from && spec.loaded_from.include?("specifications/default/")
       end
 
+      def remotes_equal?(other_remotes)
+        remotes.map(&method(:suppress_configured_credentials)) == other_remotes.map(&method(:suppress_configured_credentials))
+      end
+
     end
   end
 end

data/lib/bundler/templates/newgem/Rakefile.tt

@@ -14,7 +14,6 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 <% end -%>
-
 <% if config[:ext] -%>
 require "rake/extensiontask"
 

data/lib/bundler/templates/newgem/newgem.gemspec.tt

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
     spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
   end
 
-  spec.add_development_dependency "bundler", "~> <%= Bundler::VERSION.split(".")[0..1].join(".") %>"
+  spec.add_development_dependency "bundler", "~> <%= config[:bundler_version] %>"
   spec.add_development_dependency "rake", "~> 10.0"
 <%- if config[:ext] -%>
   spec.add_development_dependency "rake-compiler"

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

@@ -0,0 +1,5 @@
+require 'molinillo/gem_metadata'
+require 'molinillo/errors'
+require 'molinillo/resolver'
+require 'molinillo/modules/ui'
+require 'molinillo/modules/specification_provider'

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

@@ -0,0 +1,266 @@
+require 'set'
+require 'tsort'
+
+module Bundler::Molinillo
+  # A directed acyclic graph that is tuned to hold named dependencies
+  class DependencyGraph
+    include Enumerable
+
+    # Enumerates through the vertices of the graph.
+    # @return [Array<Vertex>] The graph's vertices.
+    def each
+      vertices.values.each { |v| yield v }
+    end
+
+    include TSort
+
+    alias_method :tsort_each_node, :each
+
+    def tsort_each_child(vertex, &block)
+      vertex.successors.each(&block)
+    end
+
+    # Topologically sorts the given vertices.
+    # @param [Enumerable<Vertex>] vertices the vertices to be sorted, which must
+    #   all belong to the same graph.
+    # @return [Array<Vertex>] The sorted vertices.
+    def self.tsort(vertices)
+      TSort.tsort(
+        lambda { |b| vertices.each(&b) },
+        lambda { |v, &b| (v.successors & vertices).each(&b) }
+      )
+    end
+
+    # A directed edge of a {DependencyGraph}
+    # @attr [Vertex] origin The origin of the directed edge
+    # @attr [Vertex] destination The destination of the directed edge
+    # @attr [Array] requirements The requirements the directed edge represents
+    Edge = Struct.new(:origin, :destination, :requirements)
+
+    # @return [{String => Vertex}] vertices that have no {Vertex#predecessors},
+    #   keyed by by {Vertex#name}
+    attr_reader :root_vertices
+    # @return [{String => Vertex}] the vertices of the dependency graph, keyed
+    #   by {Vertex#name}
+    attr_reader :vertices
+    # @return [Set<Edge>] the edges of the dependency graph
+    attr_reader :edges
+
+    def initialize
+      @vertices = {}
+      @edges = Set.new
+      @root_vertices = {}
+    end
+
+    # Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices}
+    # have the correct {Vertex#graph} set
+    def initialize_copy(other)
+      super
+      @vertices = other.vertices.reduce({}) do |vertices, (name, vertex)|
+        vertices.tap do |hash|
+          hash[name] = vertex.dup.tap { |v| v.graph = self }
+        end
+      end
+      @root_vertices = Hash[vertices.select { |n, _v| other.root_vertices[n] }]
+      @edges = other.edges.map do |edge|
+        Edge.new(
+          vertex_named(edge.origin.name),
+          vertex_named(edge.destination.name),
+          edge.requirements.dup
+        )
+      end
+    end
+
+    # @return [String] a string suitable for debugging
+    def inspect
+      "#{self.class}:#{vertices.values.inspect}"
+    end
+
+    # @return [Boolean] whether the two dependency graphs are equal, determined
+    #   by a recursive traversal of each {#root_vertices} and its
+    #   {Vertex#successors}
+    def ==(other)
+      root_vertices == other.root_vertices
+    end
+
+    # @param [String] name
+    # @param [Object] payload
+    # @param [Array<String>] parent_names
+    # @param [Object] requirement the requirement that is requiring the child
+    # @return [void]
+    def add_child_vertex(name, payload, parent_names, requirement)
+      is_root = parent_names.include?(nil)
+      parent_nodes = parent_names.compact.map { |n| vertex_named(n) }
+      vertex = vertex_named(name) || if is_root
+                                       add_root_vertex(name, payload)
+                                     else
+                                       add_vertex(name, payload)
+                                     end
+      vertex.payload ||= payload
+      parent_nodes.each do |parent_node|
+        add_edge(parent_node, vertex, requirement)
+      end
+      vertex
+    end
+
+    # @param [String] name
+    # @param [Object] payload
+    # @return [Vertex] the vertex that was added to `self`
+    def add_vertex(name, payload)
+      vertex = vertices[name] ||= Vertex.new(self, name, payload)
+      vertex.tap { |v| v.payload = payload }
+    end
+
+    # @param [String] name
+    # @param [Object] payload
+    # @return [Vertex] the vertex that was added to `self`
+    def add_root_vertex(name, payload)
+      add_vertex(name, payload).tap { |v| root_vertices[name] = v }
+    end
+
+    # Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively
+    # removing any non-root vertices that were orphaned in the process
+    # @param [String] name
+    # @return [void]
+    def detach_vertex_named(name)
+      vertex = vertex_named(name)
+      return unless vertex
+      successors = vertex.successors
+      vertices.delete(name)
+      edges.reject! { |e| e.origin == vertex || e.destination == vertex }
+      successors.each { |v| detach_vertex_named(v.name) unless root_vertices[v.name] || v.predecessors.any? }
+    end
+
+    # @param [String] name
+    # @return [Vertex,nil] the vertex with the given name
+    def vertex_named(name)
+      vertices[name]
+    end
+
+    # @param [String] name
+    # @return [Vertex,nil] the root vertex with the given name
+    def root_vertex_named(name)
+      root_vertices[name]
+    end
+
+    # Adds a new {Edge} to the dependency graph
+    # @param [Vertex] origin
+    # @param [Vertex] destination
+    # @param [Object] requirement the requirement that this edge represents
+    # @return [Edge] the added edge
+    def add_edge(origin, destination, requirement)
+      if origin == destination || destination.path_to?(origin)
+        raise CircularDependencyError.new([origin, destination])
+      end
+      Edge.new(origin, destination, [requirement]).tap { |e| edges << e }
+    end
+
+    # A vertex in a {DependencyGraph} that encapsulates a {#name} and a
+    # {#payload}
+    class Vertex
+      # @return [DependencyGraph] the graph this vertex is a node of
+      attr_accessor :graph
+
+      # @return [String] the name of the vertex
+      attr_accessor :name
+
+      # @return [Object] the payload the vertex holds
+      attr_accessor :payload
+
+      # @return [Arrary<Object>] the explicit requirements that required
+      #   this vertex
+      attr_reader :explicit_requirements
+
+      # @param [DependencyGraph] graph see {#graph}
+      # @param [String] name see {#name}
+      # @param [Object] payload see {#payload}
+      def initialize(graph, name, payload)
+        @graph = graph
+        @name = name
+        @payload = payload
+        @explicit_requirements = []
+      end
+
+      # @return [Array<Object>] all of the requirements that required
+      #   this vertex
+      def requirements
+        incoming_edges.map(&:requirements).flatten + explicit_requirements
+      end
+
+      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
+      #   {Edge#origin}
+      def outgoing_edges
+        graph.edges.select { |e| e.origin.shallow_eql?(self) }
+      end
+
+      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
+      #   {Edge#destination}
+      def incoming_edges
+        graph.edges.select { |e| e.destination.shallow_eql?(self) }
+      end
+
+      # @return [Set<Vertex>] the vertices of {#graph} that have an edge with
+      #   `self` as their {Edge#destination}
+      def predecessors
+        incoming_edges.map(&:origin).to_set
+      end
+
+      # @return [Set<Vertex>] the vertices of {#graph} that have an edge with
+      #   `self` as their {Edge#origin}
+      def successors
+        outgoing_edges.map(&:destination).to_set
+      end
+
+      # @return [Set<Vertex>] the vertices of {#graph} where `self` is an
+      #   {#ancestor?}
+      def recursive_successors
+        successors + successors.map(&:recursive_successors).reduce(Set.new, &:+)
+      end
+
+      # @return [String] a string suitable for debugging
+      def inspect
+        "#{self.class}:#{name}(#{payload.inspect})"
+      end
+
+      # @return [Boolean] whether the two vertices are equal, determined
+      #   by a recursive traversal of each {Vertex#successors}
+      def ==(other)
+        shallow_eql?(other) &&
+          successors == other.successors
+      end
+
+      # @return [Boolean] whether the two vertices are equal, determined
+      #   solely by {#name} and {#payload} equality
+      def shallow_eql?(other)
+        other &&
+          name == other.name &&
+          payload == other.payload
+      end
+
+      alias_method :eql?, :==
+
+      # @return [Fixnum] a hash for the vertex based upon its {#name}
+      def hash
+        name.hash
+      end
+
+      # Is there a path from `self` to `other` following edges in the
+      # dependency graph?
+      # @return true iff there is a path following edges within this {#graph}
+      def path_to?(other)
+        successors.include?(other) || successors.any? { |v| v.path_to?(other) }
+      end
+
+      alias_method :descendent?, :path_to?
+
+      # Is there a path from `other` to `self` following edges in the
+      # dependency graph?
+      # @return true iff there is a path following edges within this {#graph}
+      def ancestor?(other)
+        predecessors.include?(other) || predecessors.any? { |v| v.ancestor?(other) }
+      end
+
+      alias_method :is_reachable_from?, :ancestor?
+    end
+  end
+end