bundler 1.11.2 → 1.12.0.pre.1

data/lib/bundler/resolver.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bundler
   class Resolver
     require "bundler/vendored_molinillo"
@@ -12,7 +13,7 @@ module Bundler
       end
 
       def message
-        conflicts.sort.reduce("") do |o, (name, conflict)|
+        conflicts.sort.reduce(String.new) do |o, (name, conflict)|
           o << %(Bundler could not find compatible versions for gem "#{name}":\n)
           if conflict.locked_requirement
             o << %(  In snapshot (#{Bundler.default_lockfile.basename}):\n)
@@ -21,7 +22,7 @@ module Bundler
           end
           o << %(  In Gemfile:\n)
           o << conflict.requirement_trees.sort_by {|t| t.reverse.map(&:name) }.map do |tree|
-            t = ""
+            t = String.new
             depth = 2
             tree.each do |req|
               t << "  " * depth << req.to_s
@@ -130,7 +131,7 @@ module Bundler
       def for?(platform, required_ruby_version)
         if spec = @specs[platform]
           if required_ruby_version && spec.respond_to?(:required_ruby_version) && spec_required_ruby_version = spec.required_ruby_version
-            spec_required_ruby_version.satisfied_by?(required_ruby_version)
+            spec_required_ruby_version.satisfied_by?(required_ruby_version.gem_version)
           else
             true
           end
@@ -192,7 +193,7 @@ module Bundler
       @search_for = {}
       @base_dg = Molinillo::DependencyGraph.new
       @base.each {|ls| @base_dg.add_vertex(ls.name, Dependency.new(ls.name, ls.version), true) }
-      @ruby_version = ruby_version ? Gem::Version.create(ruby_version) : nil
+      @ruby_version = ruby_version
     end
 
     def start(requirements)
@@ -216,15 +217,15 @@ module Bundler
     # @param [Integer] depth the current depth of the resolution process.
     # @return [void]
     def debug(depth = 0)
-      if debug?
-        debug_info = yield
-        debug_info = debug_info.inspect unless debug_info.is_a?(String)
-        STDERR.puts debug_info.split("\n").map {|s| "  " * depth + s }
-      end
+      return unless debug?
+      debug_info = yield
+      debug_info = debug_info.inspect unless debug_info.is_a?(String)
+      STDERR.puts debug_info.split("\n").map {|s| "  " * depth + s }
     end
 
     def debug?
-      ENV["DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER_TREE"]
+      return @debug_mode if defined?(@debug_mode)
+      @debug_mode = ENV["DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER_TREE"]
     end
 
     def before_resolution
@@ -341,12 +342,12 @@ module Bundler
         elsif requirement.source
           name = requirement.name
           versions = @source_requirements[name][name].map(&:version)
-          message  = "Could not find gem '#{requirement}' in #{requirement.source}.\n"
-          if versions.any?
-            message << "Source contains '#{name}' at: #{versions.join(", ")}"
-          else
-            message << "Source does not contain any versions of '#{requirement}'"
-          end
+          message  = String.new("Could not find gem '#{requirement}' in #{requirement.source}.\n")
+          message << if versions.any?
+                       "Source contains '#{name}' at: #{versions.join(", ")}"
+                     else
+                       "Source does not contain any versions of '#{requirement}'"
+                     end
         else
           message = "Could not find gem '#{requirement}' in any of the gem sources " \
             "listed in your Gemfile or available on this machine."

data/lib/bundler/retry.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bundler
   # General purpose class for retrying code that may fail
   class Retry

data/lib/bundler/ruby_dsl.rb

@@ -1,10 +1,16 @@
+# 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 GemfileEvalError, "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,14 @@
+# 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,29 +21,42 @@ 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)
+      @gem_version        = Gem::Requirement.create(@versions.first).requirements.first.last
+      @input_engine       = engine
+      @engine             = engine || "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 single_version_string
+      to_s(gem_version)
+    end
+
     def ==(other)
-      version == other.version &&
+      versions == other.versions &&
         engine == other.engine &&
-        engine_version == other.engine_version &&
+        engine_versions == other.engine_versions &&
         patchlevel == other.patchlevel
     end
 
+    def host
+      @host ||= [
+        RbConfig::CONFIG["host_cpu"],
+        RbConfig::CONFIG["host_vendor"],
+        RbConfig::CONFIG["host_os"]
+      ].join("-")
+    end
+
     # Returns a tuple of these things:
     #   [diff, this, other]
     #   The priority of attributes are
@@ -45,70 +64,48 @@ module Bundler
     #   2. ruby_version
     #   3. engine_version
     def diff(other)
+      raise ArgumentError, "Can only diff with a RubyVersion" unless other.is_a?(RubyVersion)
       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
+      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 host
-      @host ||= [
-        RbConfig::CONFIG["host_cpu"],
-        RbConfig::CONFIG["host_vendor"],
-        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
+    def versions_string(versions)
+      Array(versions).join(", ")
     end
 
-    def gem_version
-      @gem_version ||= Gem::Version.new(version)
-    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
-    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"
+      ruby_engine_version = case ruby_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"
       end
+      @ruby_version ||= RubyVersion.new(RUBY_VERSION.dup, RUBY_PATCHLEVEL.to_s, ruby_engine, ruby_engine_version)
     end
 
-    def patchlevel
-      RUBY_PATCHLEVEL.to_s
+  private
+
+    def matches?(requirements, version)
+      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,3 +1,4 @@
+# frozen_string_literal: true
 require "pathname"
 
 if defined?(Gem::QuickLoader)
@@ -78,7 +79,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"
@@ -94,7 +95,7 @@ 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|
@@ -126,7 +127,7 @@ module Gem
     end
 
     def to_lock
-      out = "  #{name}"
+      out = String.new("  #{name}")
       unless requirement == Gem::Requirement.default
         reqs = requirement.requirements.map {|o, v| "#{o} #{v}" }.sort.reverse
         out << " (#{reqs.join(", ")})"

data/lib/bundler/rubygems_gem_installer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "rubygems/installer"
 
 module Bundler

data/lib/bundler/rubygems_integration.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "monitor"
 require "rubygems"
 require "rubygems/config_file"
@@ -64,7 +65,7 @@ module Bundler
     def configuration
       require "bundler/psyched_yaml"
       Gem.configuration
-    rescue Gem::SystemExitException => e
+    rescue Gem::SystemExitException, LoadError => e
       Bundler.ui.error "#{e.class}: #{e.message}"
       Bundler.ui.trace e
       raise
@@ -181,7 +182,7 @@ module Bundler
     def fetch_prerelease_specs
       fetch_specs(false, true)
     rescue Gem::RemoteFetcher::FetchError
-      [] # if we can't download them, there aren't any
+      {} # if we can't download them, there aren't any
     end
 
     # TODO: This is for older versions of Rubygems... should we support the
@@ -194,9 +195,9 @@ module Bundler
       # Fetch all specs, minus prerelease specs
       spec_list = fetch_specs(true, false)
       # Then fetch the prerelease specs
-      fetch_prerelease_specs.each {|k, v| spec_list[k] += v }
+      fetch_prerelease_specs.each {|k, v| spec_list[k].push(*v) }
 
-      spec_list
+      spec_list.values.first
     ensure
       Bundler.rubygems.sources = old_sources
     end
@@ -578,18 +579,12 @@ module Bundler
       end
 
       def fetch_all_remote_specs(remote)
-        # Since SpecFetcher now returns NameTuples, we just fetch directly
-        # and unmarshal the array ourselves.
-        hash = {}
+        source = remote.uri.is_a?(URI) ? remote.uri : URI.parse(source.to_s)
 
-        source = remote.uri
-        source = URI.parse(source.to_s) unless source.is_a?(URI)
-        hash[source] = fetch_specs(source, remote, "specs")
+        specs = fetch_specs(source, remote, "specs")
+        pres = fetch_specs(source, remote, "prerelease_specs") || []
 
-        pres = fetch_specs(source, remote, "prerelease_specs")
-        hash[source].push(*pres) if pres && !pres.empty?
-
-        hash
+        specs.push(*pres)
       end
 
       def download_gem(spec, uri, path)

data/lib/bundler/runtime.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "digest/sha1"
 
 module Bundler
@@ -12,7 +13,7 @@ module Bundler
 
       specs = groups.any? ? @definition.specs_for(groups) : requested_specs
 
-      setup_environment
+      SharedHelpers.set_bundle_environment
       Bundler.rubygems.replace_entrypoints(specs)
 
       # Activate the specs
@@ -52,7 +53,7 @@ module Bundler
       /^Missing API definition file in (.+)$/i,
       /^cannot load such file -- (.+)$/i,
       /^dlopen\([^)]*\): Library not loaded: (.+)$/i,
-    ]
+    ].freeze
 
     def require(*groups)
       groups.map!(&:to_sym)
@@ -189,26 +190,21 @@ module Bundler
 
       unless dry_run
         stale_files = stale_gem_bins + stale_gem_files + stale_gemspec_files
-        stale_files.each {|file| FileUtils.rm(file) if File.exist?(file) }
-        stale_git_cache_dirs.each {|dir| FileUtils.rm_rf(dir) if File.exist?(dir) }
+        stale_files.each do |file|
+          SharedHelpers.filesystem_access(File.dirname(file)) do |_p|
+            FileUtils.rm(file) if File.exist?(file)
+          end
+        end
+        stale_git_cache_dirs.each do |cache_dir|
+          SharedHelpers.filesystem_access(cache_dir) do |dir|
+            FileUtils.rm_rf(dir) if File.exist?(dir)
+          end
+        end
       end
 
       output
     end
 
-    def setup_environment
-      begin
-        ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
-      rescue Gem::GemNotFoundException
-        ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../exe/bundle", __FILE__)
-      end
-
-      # Set BUNDLE_GEMFILE
-      ENV["BUNDLE_GEMFILE"] = default_gemfile.to_s
-
-      SharedHelpers.set_bundle_environment
-    end
-
   private
 
     def prune_gem_cache(resolve, cache_path)
@@ -265,11 +261,10 @@ module Bundler
         man_subdir unless Dir[man_subdir + "/man?/"].empty?
       end.compact
 
-      unless manuals.empty?
-        ENV["MANPATH"] = manuals.concat(
-          ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR)
-        ).uniq.join(File::PATH_SEPARATOR)
-      end
+      return if manuals.empty?
+      ENV["MANPATH"] = manuals.concat(
+        ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR)
+      ).uniq.join(File::PATH_SEPARATOR)
     end
 
     def remove_dir(dir, dry_run)

data/lib/bundler/settings.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require "uri"
 
 module Bundler
   class Settings
-    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check ignore_messages gem.mit gem.coc silence_root_warning).freeze
+    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check disable_shared_gems ignore_messages gem.mit gem.coc silence_root_warning).freeze
     NUMBER_KEYS = %w(retry timeout redirect ssl_verify_mode).freeze
-    DEFAULT_CONFIG = { :retry => 3, :timeout => 10, :redirect => 5 }
+    DEFAULT_CONFIG = { :retry => 3, :timeout => 10, :redirect => 5 }.freeze
 
     def initialize(root = nil)
       @root          = root
@@ -63,10 +64,7 @@ module Bundler
 
     def mirror_for(uri)
       uri = URI(uri.to_s) unless uri.is_a?(URI)
-
-      # Settings keys are all downcased
-      normalized_key = normalize_uri(uri.to_s.downcase)
-      gem_mirrors[normalized_key] || uri
+      gem_mirrors.for(uri.to_s).uri
     end
 
     def credentials_for(uri)
@@ -74,12 +72,9 @@ module Bundler
     end
 
     def gem_mirrors
-      all.inject({}) do |h, k|
-        if k =~ /^mirror\./
-          uri = normalize_uri($')
-          h[uri] = normalize_uri(self[k])
-        end
-        h
+      all.inject(Mirrors.new) do |mirrors, k|
+        mirrors.parse(k, self[k]) if k =~ /^mirror\./
+        mirrors
       end
     end
 
@@ -161,7 +156,7 @@ module Bundler
   private
 
     def key_for(key)
-      key = normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key
+      key = Settings.normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key
       key = key.to_s.gsub(".", "__").upcase
       "BUNDLE_#{key}"
     end
@@ -215,8 +210,11 @@ module Bundler
     end
 
     def global_config_file
-      file = ENV["BUNDLE_CONFIG"] || File.join(Bundler.rubygems.user_home, ".bundle/config")
-      Pathname.new(file)
+      if ENV["BUNDLE_CONFIG"] && !ENV["BUNDLE_CONFIG"].empty?
+        Pathname.new(ENV["BUNDLE_CONFIG"])
+      else
+        Bundler.user_bundle_path.join("config")
+      end
     end
 
     def local_config_file
@@ -224,17 +222,15 @@ module Bundler
     end
 
     def load_config(config_file)
-      valid_file = config_file && config_file.exist? && !config_file.size.zero?
-      if !ignore_config? && valid_file
+      SharedHelpers.filesystem_access(config_file, :read) do
+        valid_file = config_file && config_file.exist? && !config_file.size.zero?
+        return {} if ignore_config? || !valid_file
         config_regex = /^(BUNDLE_.+): (['"]?)(.*(?:\n(?!BUNDLE).+)?)\2$/
-        raise PermissionError.new(config_file, :read) unless config_file.readable?
         config_pairs = config_file.read.scan(config_regex).map do |m|
           key, _, value = m
           [convert_to_backward_compatible_key(key), value.gsub(/\s+/, " ").tr('"', "'")]
         end
         Hash[config_pairs]
-      else
-        {}
       end
     end
 
@@ -246,7 +242,7 @@ module Bundler
 
     # TODO: duplicates Rubygems#normalize_uri
     # TODO: is this the correct place to validate mirror URIs?
-    def normalize_uri(uri)
+    def self.normalize_uri(uri)
       uri = uri.to_s
       uri = "#{uri}/" unless uri =~ %r{/\Z}
       uri = URI(uri)