* lib/rubygems: Update to RubyGems 2.5.0+ HEAD(c6b4946).

this version includes #1114, #1314, #1322, #1375, #1383, #1387
* test/rubygems: ditto.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@52666 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,9 @@
+Thu Nov 19 15:16:12 2015  SHIBATA Hiroshi  <hsbt@ruby-lang.org>
+
+	* lib/rubygems: Update to RubyGems 2.5.0+ HEAD(c6b4946).
+	  this version includes #1114, #1314, #1322, #1375, #1383, #1387
+	* test/rubygems: ditto.
+
 Thu Nov 19 14:14:37 2015  NAKAMURA Usaku  <usa@ruby-lang.org>
 
 	* win32/win32.c (finish_overlapped_socket): return value of this

lib/rubygems/basic_specification.rb

@@ -171,8 +171,8 @@ class Gem::BasicSpecification
       begin
         fullpath = nil
         suffixes = Gem.suffixes
-        full_require_paths.find do |dir|
+        suffixes.find do |suf|
-          suffixes.find do |suf|
+          full_require_paths.find do |dir|
             File.file?(fullpath = "#{dir}/#{path}#{suf}")
           end
         end ? fullpath : nil

lib/rubygems/request.rb

@@ -185,6 +185,10 @@ class Gem::Request
 
       bad_response = true
       retry
+    rescue Net::HTTPFatalError
+      verbose "fatal error"
+
+      raise Gem::RemoteFetcher::FetchError.new('fatal error', @uri)
     # HACK work around EOFError bug in Net::HTTP
     # NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible
     # to install gems.
@@ -241,4 +245,3 @@ end
 require 'rubygems/request/http_pool'
 require 'rubygems/request/https_pool'
 require 'rubygems/request/connection_pools'
-

lib/rubygems/resolver.rb

@@ -187,7 +187,7 @@ class Gem::Resolver
 
   def resolve
     locking_dg = Molinillo::DependencyGraph.new
-    Molinillo::Resolver.new(self, self).resolve(@needed.map { |d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload)
+    Molinillo::Resolver.new(self, self).resolve(@needed.map { |d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload).compact
   rescue Molinillo::VersionConflict => e
     conflict = e.conflicts.values.first
     raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)

lib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph.rb

@@ -34,40 +34,34 @@ module Gem::Resolver::Molinillo
     # 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
+    # @attr [Object] requirement The requirement the directed edge represents
-    Edge = Struct.new(:origin, :destination, :requirements)
+    Edge = Struct.new(:origin, :destination, :requirement)
 
-    # @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
+    # are properly copied.
     def initialize_copy(other)
       super
-      @vertices = other.vertices.reduce({}) do |vertices, (name, vertex)|
+      @vertices = {}
-        vertices.tap do |hash|
+      traverse = lambda do |new_v, old_v|
-          hash[name] = vertex.dup.tap { |v| v.graph = self }
+        return if new_v.outgoing_edges.size == old_v.outgoing_edges.size
+        old_v.outgoing_edges.each do |edge|
+          destination = add_vertex(edge.destination.name, edge.destination.payload)
+          add_edge_no_circular(new_v, destination, edge.requirement)
+          traverse.call(destination, edge.destination)
         end
       end
-      @root_vertices = Hash[@vertices.select { |n, _v| other.root_vertices[n] }]
+      other.vertices.each do |name, vertex|
-      @edges = other.edges.map do |edge|
+        new_vertex = add_vertex(name, vertex.payload, vertex.root?)
-        Edge.new(
+        new_vertex.explicit_requirements.replace(vertex.explicit_requirements)
-          vertex_named(edge.origin.name),
+        traverse.call(new_vertex, vertex)
-          vertex_named(edge.destination.name),
-          edge.requirements.dup
-        )
       end
     end
 
@@ -80,7 +74,12 @@ module Gem::Resolver::Molinillo
     #   by a recursive traversal of each {#root_vertices} and its
     #   {Vertex#successors}
     def ==(other)
-      root_vertices == other.root_vertices
+      return false unless other
+      vertices.each do |name, vertex|
+        other_vertex = other.vertex_named(name)
+        return false unless other_vertex
+        return false unless other_vertex.successors.map(&:name).to_set == vertex.successors.map(&:name).to_set
+      end
     end
 
     # @param [String] name
@@ -89,15 +88,13 @@ module Gem::Resolver::Molinillo
     # @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)
+      vertex = add_vertex(name, payload)
-      parent_nodes = parent_names.compact.map { |n| vertex_named(n) }
+      parent_names.each do |parent_name|
-      vertex = vertex_named(name) || if is_root
+        unless parent_name
-                                       add_root_vertex(name, payload)
+          vertex.root = true
-                                     else
+          next
-                                       add_vertex(name, payload)
+        end
-                                     end
+        parent_node = vertex_named(parent_name)
-      vertex.payload ||= payload
-      parent_nodes.each do |parent_node|
         add_edge(parent_node, vertex, requirement)
       end
       vertex
@@ -106,16 +103,11 @@ module Gem::Resolver::Molinillo
     # @param [String] name
     # @param [Object] payload
     # @return [Vertex] the vertex that was added to `self`
-    def add_vertex(name, payload)
+    def add_vertex(name, payload, root = false)
-      vertex = vertices[name] ||= Vertex.new(self, name, payload)
+      vertex = vertices[name] ||= Vertex.new(name, payload)
-      vertex.tap { |v| v.payload = payload }
+      vertex.payload ||= payload
-    end
+      vertex.root ||= root
-
+      vertex
-    # @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
@@ -123,12 +115,12 @@ module Gem::Resolver::Molinillo
     # @param [String] name
     # @return [void]
     def detach_vertex_named(name)
-      vertex = vertex_named(name)
+      return unless vertex = vertices.delete(name)
-      return unless vertex
+      vertex.outgoing_edges.each do |e|
-      successors = vertex.successors
+        v = e.destination
-      vertices.delete(name)
+        v.incoming_edges.delete(e)
-      edges.reject! { |e| e.origin == vertex || e.destination == vertex }
+        detach_vertex_named(v.name) unless v.root? || v.predecessors.any?
-      successors.each { |v| detach_vertex_named(v.name) unless root_vertices[v.name] || v.predecessors.any? }
+      end
     end
 
     # @param [String] name
@@ -140,7 +132,8 @@ module Gem::Resolver::Molinillo
     # @param [String] name
     # @return [Vertex,nil] the root vertex with the given name
     def root_vertex_named(name)
-      root_vertices[name]
+      vertex = vertex_named(name)
+      vertex if vertex && vertex.root?
     end
 
     # Adds a new {Edge} to the dependency graph
@@ -149,18 +142,24 @@ module Gem::Resolver::Molinillo
     # @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)
+      if destination.path_to?(origin)
         raise CircularDependencyError.new([origin, destination])
       end
-      Edge.new(origin, destination, [requirement]).tap { |e| edges << e }
+      add_edge_no_circular(origin, destination, requirement)
+    end
+
+    private
+
+    def add_edge_no_circular(origin, destination, requirement)
+      edge = Edge.new(origin, destination, requirement)
+      origin.outgoing_edges << edge
+      destination.incoming_edges << edge
+      edge
     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
 
@@ -171,50 +170,62 @@ module Gem::Resolver::Molinillo
       #   this vertex
       attr_reader :explicit_requirements
 
-      # @param [DependencyGraph] graph see {#graph}
+      # @return [Boolean] whether the vertex is considered a root vertex
+      attr_accessor :root
+      alias_method :root?, :root
+
       # @param [String] name see {#name}
       # @param [Object] payload see {#payload}
-      def initialize(graph, name, payload)
+      def initialize(name, payload)
-        @graph = graph
         @name = name
         @payload = payload
         @explicit_requirements = []
+        @outgoing_edges = []
+        @incoming_edges = []
       end
 
       # @return [Array<Object>] all of the requirements that required
       #   this vertex
       def requirements
-        incoming_edges.map(&:requirements).flatten + explicit_requirements
+        incoming_edges.map(&:requirement) + explicit_requirements
       end
 
       # @return [Array<Edge>] the edges of {#graph} that have `self` as their
       #   {Edge#origin}
-      def outgoing_edges
+      attr_accessor :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
+      attr_accessor :incoming_edges
-        graph.edges.select { |e| e.destination.shallow_eql?(self) }
-      end
 
-      # @return [Set<Vertex>] the vertices of {#graph} that have an edge with
+      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
       #   `self` as their {Edge#destination}
       def predecessors
-        incoming_edges.map(&:origin).to_set
+        incoming_edges.map(&:origin)
       end
 
-      # @return [Set<Vertex>] the vertices of {#graph} that have an edge with
+      # @return [Array<Vertex>] the vertices of {#graph} where `self` is a
+      #   {#descendent?}
+      def recursive_predecessors
+        vertices = predecessors
+        vertices += vertices.map(&:recursive_predecessors).flatten(1)
+        vertices.uniq!
+        vertices
+      end
+
+      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
       #   `self` as their {Edge#origin}
       def successors
-        outgoing_edges.map(&:destination).to_set
+        outgoing_edges.map(&:destination)
       end
 
-      # @return [Set<Vertex>] the vertices of {#graph} where `self` is an
+      # @return [Array<Vertex>] the vertices of {#graph} where `self` is an
       #   {#ancestor?}
       def recursive_successors
-        successors + successors.map(&:recursive_successors).reduce(Set.new, &:+)
+        vertices = successors
+        vertices += vertices.map(&:recursive_successors).flatten(1)
+        vertices.uniq!
+        vertices
       end
 
       # @return [String] a string suitable for debugging
@@ -226,7 +237,7 @@ module Gem::Resolver::Molinillo
       #   by a recursive traversal of each {Vertex#successors}
       def ==(other)
         shallow_eql?(other) &&
-          successors == other.successors
+          successors.to_set == other.successors.to_set
       end
 
       # @return [Boolean] whether the two vertices are equal, determined
@@ -248,7 +259,7 @@ module Gem::Resolver::Molinillo
       # 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) }
+        equal?(other) || successors.any? { |v| v.path_to?(other) }
       end
 
       alias_method :descendent?, :path_to?
@@ -257,7 +268,7 @@ module Gem::Resolver::Molinillo
       # 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) }
+        other.path_to?(self)
       end
 
       alias_method :is_reachable_from?, :ancestor?

lib/rubygems/resolver/molinillo/lib/molinillo/gem_metadata.rb

@@ -1,3 +1,3 @@
 module Gem::Resolver::Molinillo
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

lib/rubygems/resolver/molinillo/lib/molinillo/resolution.rb

@@ -12,13 +12,15 @@ module Gem::Resolver::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
@@ -164,7 +166,7 @@ module Gem::Resolver::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, {})
@@ -216,7 +218,7 @@ module Gem::Resolver::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
@@ -250,21 +252,23 @@ module Gem::Resolver::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
@@ -322,7 +326,7 @@ module Gem::Resolver::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
@@ -389,17 +393,17 @@ module Gem::Resolver::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_activated = activated.dup)
+      def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated.dup)
-        new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts)
+        new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts) if requires_sort
         new_requirement = new_requirements.shift
         new_name = new_requirement ? name_for(new_requirement) : ''
         possibilities = new_requirement ? search_for(new_requirement) : []
@@ -420,7 +424,7 @@ module Gem::Resolver::Molinillo
       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, state.activated)
+          push_state_for_requirements(state.requirements.dup, false, state.activated)
         else
           states.push state
         end

lib/rubygems/specification.rb

@@ -2593,6 +2593,7 @@ class Gem::Specification < Gem::BasicSpecification
     trail.push(self)
     begin
       dependencies.each do |dep|
+        next unless dep.runtime?
         dep.to_specs.reverse_each do |dep_spec|
           next if visited.has_key?(dep_spec)
           visited[dep_spec] = true
@@ -2744,7 +2745,7 @@ class Gem::Specification < Gem::BasicSpecification
           "each license must be 64 characters or less"
       end
 
-      if !Gem::Licenses::IDENTIFIERS.include?(license) && !license.eql?(Gem::Licenses::NONSTANDARD)
+      if !Gem::Licenses.match?(license)
         warning <<-warning
 WARNING: license value '#{license}' is invalid.  Use a license identifier from
 http://spdx.org/licenses or '#{Gem::Licenses::NONSTANDARD}' for a nonstandard license.

lib/rubygems/util/licenses.rb

@@ -4,7 +4,8 @@ class Gem::Licenses
   # Software Package Data Exchange (SPDX) standard open-source software
   # license identifiers
   IDENTIFIERS = %w(
-    AAL
+      0BSD
+      AAL
       ADSL
       AFL-1.1
       AFL-1.2
@@ -89,6 +90,7 @@ class Gem::Licenses
       CECILL-1.0
       CECILL-1.1
       CECILL-2.0
+      CECILL-2.1
       CECILL-B
       CECILL-C
       CNRI-Jython
@@ -102,6 +104,7 @@ class Gem::Licenses
       ClArtistic
       Condor-1.1
       Crossword
+      CrystalStacker
       Cube
       D-FSL-1.0
       DOC
@@ -146,6 +149,7 @@ class Gem::Licenses
       Imlib2
       Intel
       Intel-ACPI
+      Interbase-1.0
       JSON
       JasPer-2.0
       LGPL-2.0
@@ -254,6 +258,7 @@ class Gem::Licenses
       SPL-1.0
       SWL
       Saxpath
+      Sendmail
       SimPL-2.0
       Sleepycat
       Spencer-86
@@ -306,4 +311,19 @@ class Gem::Licenses
       xpp
       zlib-acknowledgement
   ).freeze
+
+  REGEXP = %r{
+    \A
+    (
+      #{Regexp.union(IDENTIFIERS)}
+      \+?
+      (\s WITH \s .+)?
+      | #{NONSTANDARD}
+    )
+    \Z
+  }ox.freeze
+
+  def self.match?(license)
+    !REGEXP.match(license).nil?
+  end
 end

test/rubygems/test_gem_specification.rb

@@ -2128,6 +2128,27 @@ dependencies: []
     assert_nil @ext.to_fullpath("notexist")
   end
 
+  def test_fullpath_return_rb_extension_file_when_exist_the_same_name_file
+    ext_spec
+
+    @ext.require_paths = 'lib'
+
+    dir = File.join(@gemhome, 'gems', @ext.original_name, 'lib')
+    expected_rb = File.join(dir, 'code.rb')
+    FileUtils.mkdir_p dir
+    FileUtils.touch expected_rb
+
+    dir = @ext.extension_dir
+    ext = RbConfig::CONFIG["DLEXT"]
+    expected_so = File.join(dir, "code.#{ext}")
+    FileUtils.mkdir_p dir
+    FileUtils.touch expected_so
+
+    @ext.activate
+
+    assert_equal expected_rb, @ext.to_fullpath("code")
+  end
+
   def test_require_already_activated
     save_loaded_features do
       a1 = new_spec "a", "1", nil, "lib/d.rb"
@@ -2874,6 +2895,46 @@ http://spdx.org/licenses or 'Nonstandard' for a nonstandard license.
     warning
   end
 
+  def test_validate_license_values_plus
+    util_setup_validate
+
+    use_ui @ui do
+      @a1.licenses = ['GPL-2.0+']
+      @a1.validate
+    end
+
+    assert_empty @ui.error
+  end
+
+  def test_validate_license_values_with
+    util_setup_validate
+
+    use_ui @ui do
+      @a1.licenses = ['GPL-2.0+ WITH Autoconf-exception-2.0']
+      @a1.validate
+    end
+
+    assert_empty @ui.error
+  end
+
+  def test_validate_license_with_nonsense_suffix
+    util_setup_validate
+
+    use_ui @ui do
+      @a1.licenses = ['GPL-2.0+ FOO', 'GPL-2.0 FOO']
+      @a1.validate
+    end
+
+    assert_match <<-warning, @ui.error
+WARNING: license value 'GPL-2.0+ FOO' is invalid.  Use a license identifier from
+http://spdx.org/licenses or 'Nonstandard' for a nonstandard license.
+    warning
+    assert_match <<-warning, @ui.error
+WARNING: license value 'GPL-2.0 FOO' is invalid.  Use a license identifier from
+http://spdx.org/licenses or 'Nonstandard' for a nonstandard license.
+    warning
+  end
+
   def test_validate_name
     util_setup_validate
 

test/rubygems/test_require.rb

@@ -277,6 +277,21 @@ class TestGemRequire < Gem::TestCase
     assert_equal %w(a-1.0 b-2.0), loaded_spec_names
   end
 
+  def test_require_doesnt_traverse_development_dependencies
+    a = new_spec("a", "1", nil, "lib/a.rb")
+    z = new_spec("z", "1", "w" => "> 0")
+    w1 = new_spec("w", "1") { |s| s.add_development_dependency "non-existent" }
+    w2 = new_spec("w", "2") { |s| s.add_development_dependency "non-existent" }
+
+    install_specs a, w1, w2, z
+
+    assert gem("z")
+    assert_equal %w(z-1), loaded_spec_names
+    assert_equal ["w (> 0)"], unresolved_names
+
+    assert require("a")
+  end
+
   def test_default_gem_only
     default_gem_spec = new_default_spec("default", "2.0.0.0",
                                         nil, "default/gem.rb")