bundler 1.9.0 → 1.17.3

data/lib/bundler/resolver/spec_group.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Resolver
+    class SpecGroup
+      include GemHelpers
+
+      attr_accessor :name, :version, :source
+      attr_accessor :ignores_bundler_dependencies
+
+      def initialize(all_specs)
+        raise ArgumentError, "cannot initialize with an empty value" unless exemplary_spec = all_specs.first
+        @name = exemplary_spec.name
+        @version = exemplary_spec.version
+        @source = exemplary_spec.source
+
+        @activated_platforms = []
+        @dependencies = nil
+        @specs        = Hash.new do |specs, platform|
+          specs[platform] = select_best_platform_match(all_specs, platform)
+        end
+        @ignores_bundler_dependencies = true
+      end
+
+      def to_specs
+        @activated_platforms.map do |p|
+          next unless s = @specs[p]
+          lazy_spec = LazySpecification.new(name, version, s.platform, source)
+          lazy_spec.dependencies.replace s.dependencies
+          lazy_spec
+        end.compact
+      end
+
+      def activate_platform!(platform)
+        return unless for?(platform)
+        return if @activated_platforms.include?(platform)
+        @activated_platforms << platform
+      end
+
+      def for?(platform)
+        spec = @specs[platform]
+        !spec.nil?
+      end
+
+      def to_s
+        @to_s ||= "#{name} (#{version})"
+      end
+
+      def dependencies_for_activated_platforms
+        dependencies = @activated_platforms.map {|p| __dependencies[p] }
+        metadata_dependencies = @activated_platforms.map do |platform|
+          metadata_dependencies(@specs[platform], platform)
+        end
+        dependencies.concat(metadata_dependencies).flatten
+      end
+
+      def ==(other)
+        return unless other.is_a?(SpecGroup)
+        name == other.name &&
+          version == other.version &&
+          source == other.source
+      end
+
+      def eql?(other)
+        name.eql?(other.name) &&
+          version.eql?(other.version) &&
+          source.eql?(other.source)
+      end
+
+      def hash
+        to_s.hash ^ source.hash
+      end
+
+    private
+
+      def __dependencies
+        @dependencies = Hash.new do |dependencies, platform|
+          dependencies[platform] = []
+          if spec = @specs[platform]
+            spec.dependencies.each do |dep|
+              next if dep.type == :development
+              next if @ignores_bundler_dependencies && dep.name == "bundler".freeze
+              dependencies[platform] << DepProxy.new(dep, platform)
+            end
+          end
+          dependencies[platform]
+        end
+      end
+
+      def metadata_dependencies(spec, platform)
+        return [] unless spec
+        # Only allow endpoint specifications since they won't hit the network to
+        # fetch the full gemspec when calling required_ruby_version
+        return [] if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)
+        dependencies = []
+        if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
+          dependencies << DepProxy.new(Gem::Dependency.new("ruby\0", spec.required_ruby_version), platform)
+        end
+        if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
+          dependencies << DepProxy.new(Gem::Dependency.new("rubygems\0", spec.required_rubygems_version), platform)
+        end
+        dependencies
+      end
+    end
+  end
+end

data/lib/bundler/retry.rb

@@ -1,50 +1,56 @@
+# frozen_string_literal: true
+
 module Bundler
   # General purpose class for retrying code that may fail
   class Retry
-    DEFAULT_ATTEMPTS = 2
     attr_accessor :name, :total_runs, :current_run
 
     class << self
-      attr_accessor :attempts
-    end
+      def default_attempts
+        default_retries + 1
+      end
+      alias_method :attempts, :default_attempts
 
-    def initialize(name, exceptions = nil, attempts = nil)
-      @name        = name
-      attempts    ||= default_attempts
-      @exceptions = Array(exceptions) || []
-      @total_runs =  attempts.next # will run once, then upto attempts.times
+      def default_retries
+        Bundler.settings[:retry]
+      end
     end
 
-    def default_attempts
-      return Integer(self.class.attempts) if self.class.attempts
-      DEFAULT_ATTEMPTS
+    def initialize(name, exceptions = nil, retries = self.class.default_retries)
+      @name = name
+      @retries = retries
+      @exceptions = Array(exceptions) || []
+      @total_runs = @retries + 1 # will run once, then upto attempts.times
     end
 
     def attempt(&block)
       @current_run = 0
       @failed      = false
       @error       = nil
-      while keep_trying? do
-        run(&block)
-      end
+      run(&block) while keep_trying?
       @result
     end
-    alias :attempts :attempt
+    alias_method :attempts, :attempt
 
   private
+
     def run(&block)
       @failed      = false
       @current_run += 1
       @result = block.call
     rescue => e
-      fail(e)
+      fail_attempt(e)
     end
 
-    def fail(e)
+    def fail_attempt(e)
       @failed = true
-      raise e if last_attempt? || @exceptions.any?{ |k| e.is_a?(k) }
+      if last_attempt? || @exceptions.any? {|k| e.is_a?(k) }
+        Bundler.ui.info "" unless Bundler.ui.debug?
+        raise e
+      end
       return true unless name
-      Bundler.ui.warn "Retrying#{" #{name}" if name} due to error (#{current_run.next}/#{total_runs}): #{e.class} #{e.message}"
+      Bundler.ui.info "" unless Bundler.ui.debug? # Add new line incase dots preceded this
+      Bundler.ui.warn "Retrying #{name} due to error (#{current_run.next}/#{total_runs}): #{e.class} #{e.message}", Bundler.ui.debug?
     end
 
     def keep_trying?

data/lib/bundler/ruby_dsl.rb

@@ -1,10 +1,17 @@
+# frozen_string_literal: true
+
 module Bundler
   module RubyDsl
-    def ruby(ruby_version, options = {})
+    def ruby(*ruby_version)
+      options = ruby_version.last.is_a?(Hash) ? ruby_version.pop : {}
+      ruby_version.flatten!
       raise GemfileError, "Please define :engine_version" if options[:engine] && options[:engine_version].nil?
       raise GemfileError, "Please define :engine" if options[:engine_version] && options[:engine].nil?
 
-      raise GemfileError, "ruby_version must match the :engine_version for MRI" if options[:engine] == "ruby" && options[:engine_version] && ruby_version != options[:engine_version]
+      if options[:engine] == "ruby" && options[:engine_version] &&
+          ruby_version != Array(options[:engine_version])
+        raise GemfileEvalError, "ruby_version must match the :engine_version for MRI"
+      end
       @ruby_version = RubyVersion.new(ruby_version, options[:patchlevel], options[:engine], options[:engine_version])
     end
   end

data/lib/bundler/ruby_version.rb

@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 module Bundler
   class RubyVersion
-    attr_reader :version, :patchlevel, :engine, :engine_version
+    attr_reader :versions,
+      :patchlevel,
+      :engine,
+      :engine_versions,
+      :gem_version,
+      :engine_gem_version
 
-    def initialize(version, patchlevel, engine, engine_version)
+    def initialize(versions, patchlevel, engine, engine_version)
       # The parameters to this method must satisfy the
       # following constraints, which are verified in
       # the DSL:
@@ -15,47 +22,52 @@ module Bundler
       #   must not be specified, or the engine version
       #   specified must match the version.
 
-      @version        = version
-      @engine         = engine || "ruby"
-      # keep track of the engine specified by the user
-      @input_engine   = engine
-      @engine_version = engine_version || version
-      @patchlevel     = patchlevel
+      @versions = Array(versions).map do |v|
+        op, v = Gem::Requirement.parse(v)
+        op == "=" ? v.to_s : "#{op} #{v}"
+      end
+
+      @gem_version        = Gem::Requirement.create(@versions.first).requirements.first.last
+      @input_engine       = engine && engine.to_s
+      @engine             = engine && engine.to_s || "ruby"
+      @engine_versions    = (engine_version && Array(engine_version)) || @versions
+      @engine_gem_version = Gem::Requirement.create(@engine_versions.first).requirements.first.last
+      @patchlevel         = patchlevel
     end
 
-    def to_s
-      output = "ruby #{version}"
+    def to_s(versions = self.versions)
+      output = String.new("ruby #{versions_string(versions)}")
       output << "p#{patchlevel}" if patchlevel
-      output << " (#{engine} #{engine_version})" unless engine == "ruby"
+      output << " (#{engine} #{versions_string(engine_versions)})" unless engine == "ruby"
 
       output
     end
 
-    def ==(other)
-      version          == other.version &&
-        engine         == other.engine &&
-        engine_version == other.engine_version &&
-        patchlevel     == other.patchlevel
+    # @private
+    PATTERN = /
+      ruby\s
+      ([\d.]+) # ruby version
+      (?:p(-?\d+))? # optional patchlevel
+      (?:\s\((\S+)\s(.+)\))? # optional engine info
+    /xo
+
+    # Returns a RubyVersion from the given string.
+    # @param [String] the version string to match.
+    # @return [RubyVersion,Nil] The version if the string is a valid RubyVersion
+    #         description, and nil otherwise.
+    def self.from_string(string)
+      new($1, $2, $3, $4) if string =~ PATTERN
     end
 
-    # Returns a tuple of these things:
-    #   [diff, this, other]
-    #   The priority of attributes are
-    #   1. engine
-    #   2. ruby_version
-    #   3. engine_version
-    def diff(other)
-      if engine != other.engine && @input_engine
-        [ :engine, engine, other.engine ]
-      elsif version != other.version
-        [ :version, version, other.version ]
-      elsif engine_version != other.engine_version && @input_engine
-        [ :engine_version, engine_version, other.engine_version ]
-      elsif patchlevel != other.patchlevel && @patchlevel
-        [ :patchlevel, patchlevel, other.patchlevel ]
-      else
-        nil
-      end
+    def single_version_string
+      to_s(gem_version)
+    end
+
+    def ==(other)
+      versions == other.versions &&
+        engine == other.engine &&
+        engine_versions == other.engine_versions &&
+        patchlevel == other.patchlevel
     end
 
     def host
@@ -65,53 +77,76 @@ module Bundler
         RbConfig::CONFIG["host_os"]
       ].join("-")
     end
-  end
-
-  # A subclass of RubyVersion that implements version,
-  # engine and engine_version based upon the current
-  # information in the system. It can be used anywhere
-  # a RubyVersion object is expected, and can be
-  # compared with a RubyVersion object.
-  class SystemRubyVersion < RubyVersion
-    def initialize(*)
-      # override the default initialize, because
-      # we will implement version, engine and
-      # engine_version dynamically
-    end
 
-    def version
-      RUBY_VERSION.dup
+    # Returns a tuple of these things:
+    #   [diff, this, other]
+    #   The priority of attributes are
+    #   1. engine
+    #   2. ruby_version
+    #   3. engine_version
+    def diff(other)
+      raise ArgumentError, "Can only diff with a RubyVersion, not a #{other.class}" unless other.is_a?(RubyVersion)
+      if engine != other.engine && @input_engine
+        [:engine, engine, other.engine]
+      elsif versions.empty? || !matches?(versions, other.gem_version)
+        [:version, versions_string(versions), versions_string(other.versions)]
+      elsif @input_engine && !matches?(engine_versions, other.engine_gem_version)
+        [:engine_version, versions_string(engine_versions), versions_string(other.engine_versions)]
+      elsif patchlevel && (!patchlevel.is_a?(String) || !other.patchlevel.is_a?(String) || !matches?(patchlevel, other.patchlevel))
+        [:patchlevel, patchlevel, other.patchlevel]
+      end
     end
 
-    def gem_version
-      @gem_version ||= Gem::Version.new(version)
+    def versions_string(versions)
+      Array(versions).join(", ")
     end
 
-    def engine
-      if defined?(RUBY_ENGINE)
+    def self.system
+      ruby_engine = if defined?(RUBY_ENGINE) && !RUBY_ENGINE.nil?
         RUBY_ENGINE.dup
       else
         # not defined in ruby 1.8.7
         "ruby"
       end
+      # :sob: mocking RUBY_VERSION breaks stuff on 1.8.7
+      ruby_version = ENV.fetch("BUNDLER_SPEC_RUBY_VERSION") { RUBY_VERSION }.dup
+      ruby_engine_version = case ruby_engine
+                            when "ruby"
+                              ruby_version
+                            when "rbx"
+                              Rubinius::VERSION.dup
+                            when "jruby"
+                              JRUBY_VERSION.dup
+                            else
+                              RUBY_ENGINE_VERSION.dup
+      end
+      patchlevel = RUBY_PATCHLEVEL.to_s
+
+      @ruby_version ||= RubyVersion.new(ruby_version, patchlevel, ruby_engine, ruby_engine_version)
     end
 
-    def engine_version
-      case engine
-      when "ruby"
-        RUBY_VERSION.dup
-      when "rbx"
-        Rubinius::VERSION.dup
-      when "jruby"
-        JRUBY_VERSION.dup
-      else
-        raise BundlerError, "RUBY_ENGINE value #{RUBY_ENGINE} is not recognized"
-        nil
+    def to_gem_version_with_patchlevel
+      @gem_version_with_patch ||= begin
+        Gem::Version.create("#{@gem_version}.#{@patchlevel}")
+      rescue ArgumentError
+        @gem_version
       end
     end
 
-    def patchlevel
-      RUBY_PATCHLEVEL.to_s
+    def exact?
+      return @exact if defined?(@exact)
+      @exact = versions.all? {|v| Gem::Requirement.create(v).exact? }
+    end
+
+  private
+
+    def matches?(requirements, version)
+      # Handles RUBY_PATCHLEVEL of -1 for instances like ruby-head
+      return requirements == version if requirements.to_s == "-1" || version.to_s == "-1"
+
+      Array(requirements).all? do |requirement|
+        Gem::Requirement.create(requirement).satisfied_by?(Gem::Version.create(version))
+      end
     end
   end
 end

data/lib/bundler/rubygems_ext.rb

@@ -1,36 +1,65 @@
-require 'pathname'
+# frozen_string_literal: true
+
+require "pathname"
 
 if defined?(Gem::QuickLoader)
   # Gem Prelude makes me a sad panda :'(
   Gem::QuickLoader.load_full_rubygems_library
 end
 
-require 'rubygems'
-require 'rubygems/specification'
-require 'bundler/match_platform'
+require "rubygems"
+require "rubygems/specification"
+
+begin
+  # Possible use in Gem::Specification#source below and require
+  # shouldn't be deferred.
+  require "rubygems/source"
+rescue LoadError
+  # Not available before RubyGems 2.0.0, ignore
+  nil
+end
+
+require "bundler/match_platform"
 
 module Gem
-  @loaded_stacks = Hash.new { |h,k| h[k] = [] }
+  @loaded_stacks = Hash.new {|h, k| h[k] = [] }
 
   class Specification
-    attr_accessor :source_uri, :location, :relative_loaded_from
+    attr_accessor :remote, :location, :relative_loaded_from
 
-    remove_method :source if instance_methods(false).include?(:source)
-    attr_accessor :source
+    if instance_methods(false).map(&:to_sym).include?(:source)
+      remove_method :source
+      attr_writer :source
+      def source
+        (defined?(@source) && @source) || Gem::Source::Installed.new
+      end
+    else
+      attr_accessor :source
+    end
 
     alias_method :rg_full_gem_path, :full_gem_path
     alias_method :rg_loaded_from,   :loaded_from
 
+    attr_writer :full_gem_path unless instance_methods.include?(:full_gem_path=)
+
     def full_gem_path
-      source.respond_to?(:path) ?
-        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s.untaint :
+      # this cannot check source.is_a?(Bundler::Plugin::API::Source)
+      # because that _could_ trip the autoload, and if there are unresolved
+      # gems at that time, this method could be called inside another require,
+      # thus raising with that constant being undefined. Better to check a method
+      if source.respond_to?(:path) || (source.respond_to?(:bundler_plugin_api_source?) && source.bundler_plugin_api_source?)
+        Pathname.new(loaded_from).dirname.expand_path(source.root).to_s.untaint
+      else
         rg_full_gem_path
+      end
     end
 
     def loaded_from
-      relative_loaded_from ?
-        source.path.join(relative_loaded_from).to_s :
+      if relative_loaded_from
+        source.path.join(relative_loaded_from).to_s
+      else
         rg_loaded_from
+      end
     end
 
     def load_paths
@@ -48,9 +77,11 @@ module Gem
     if method_defined?(:extension_dir)
       alias_method :rg_extension_dir, :extension_dir
       def extension_dir
-        @extension_dir ||= source.respond_to?(:extension_dir_name) ?
-          File.expand_path(File.join(extensions_dir, source.extension_dir_name)) :
+        @bundler_extension_dir ||= if source.respond_to?(:extension_dir_name)
+          File.expand_path(File.join(extensions_dir, source.extension_dir_name))
+        else
           rg_extension_dir
+        end
       end
     end
 
@@ -72,7 +103,7 @@ module Gem
     end
 
     def to_gemfile(path = nil)
-      gemfile = "source 'https://rubygems.org'\n"
+      gemfile = String.new("source 'https://rubygems.org'\n")
       gemfile << dependencies_to_gemfile(nondevelopment_dependencies)
       unless development_dependencies.empty?
         gemfile << "\n"
@@ -88,48 +119,47 @@ module Gem
   private
 
     def dependencies_to_gemfile(dependencies, group = nil)
-      gemfile = ''
+      gemfile = String.new
       if dependencies.any?
         gemfile << "group :#{group} do\n" if group
         dependencies.each do |dependency|
-          gemfile << '  ' if group
-          gemfile << %|gem "#{dependency.name}"|
+          gemfile << "  " if group
+          gemfile << %(gem "#{dependency.name}")
           req = dependency.requirements_list.first
-          gemfile << %|, "#{req}"| if req
+          gemfile << %(, "#{req}") if req
           gemfile << "\n"
         end
         gemfile << "end\n" if group
       end
       gemfile
     end
-
   end
 
   class Dependency
-    attr_accessor :source, :groups
+    attr_accessor :source, :groups, :all_sources
 
-    alias eql? ==
+    alias_method :eql?, :==
 
     def encode_with(coder)
       to_yaml_properties.each do |ivar|
-        coder[ivar.to_s.sub(/^@/, '')] = instance_variable_get(ivar)
+        coder[ivar.to_s.sub(/^@/, "")] = instance_variable_get(ivar)
       end
     end
 
     def to_yaml_properties
-      instance_variables.reject { |p| ["@source", "@groups"].include?(p.to_s) }
+      instance_variables.reject {|p| ["@source", "@groups", "@all_sources"].include?(p.to_s) }
     end
 
     def to_lock
-      out = "  #{name}"
-      unless requirement == Gem::Requirement.default
-        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }.sort.reverse
-        out << " (#{reqs.join(', ')})"
+      out = String.new("  #{name}")
+      unless requirement.none?
+        reqs = requirement.requirements.map {|o, v| "#{o} #{v}" }.sort.reverse
+        out << " (#{reqs.join(", ")})"
       end
       out
     end
 
-    # Backport of performance enhancement added to Rubygems 1.4
+    # Backport of performance enhancement added to RubyGems 1.4
     def matches_spec?(spec)
       # name can be a Regexp, so use ===
       return false unless name === spec.name
@@ -140,18 +170,28 @@ module Gem
   end
 
   class Requirement
-    # Backport of performance enhancement added to Rubygems 1.4
+    # Backport of performance enhancement added to RubyGems 1.4
     def none?
-      @none ||= (to_s == ">= 0")
+      # note that it might be tempting to replace with with RubyGems 2.0's
+      # improved implementation. Don't. It requires `DefaultRequirement` to be
+      # defined, and more importantantly, these overrides are not used when the
+      # running RubyGems defines these methods
+      to_s == ">= 0"
     end unless allocate.respond_to?(:none?)
+
+    # Backport of performance enhancement added to RubyGems 2.2
+    def exact?
+      return false unless @requirements.size == 1
+      @requirements[0][0] == "="
+    end unless allocate.respond_to?(:exact?)
   end
 
   class Platform
-    JAVA  = Gem::Platform.new('java') unless defined?(JAVA)
-    MSWIN = Gem::Platform.new('mswin32') unless defined?(MSWIN)
-    MSWIN64 = Gem::Platform.new('mswin64') unless defined?(MSWIN64)
-    MINGW = Gem::Platform.new('x86-mingw32') unless defined?(MINGW)
-    X64_MINGW = Gem::Platform.new('x64-mingw32') unless defined?(X64_MINGW)
+    JAVA  = Gem::Platform.new("java") unless defined?(JAVA)
+    MSWIN = Gem::Platform.new("mswin32") unless defined?(MSWIN)
+    MSWIN64 = Gem::Platform.new("mswin64") unless defined?(MSWIN64)
+    MINGW = Gem::Platform.new("x86-mingw32") unless defined?(MINGW)
+    X64_MINGW = Gem::Platform.new("x64-mingw32") unless defined?(X64_MINGW)
 
     undef_method :hash if method_defined? :hash
     def hash
@@ -159,7 +199,7 @@ module Gem
     end
 
     undef_method :eql? if method_defined? :eql?
-    alias eql? ==
+    alias_method :eql?, :==
   end
 end