bundler 1.13.7 → 1.14.0.pre.1

data/lib/bundler/dependency.rb

@@ -18,6 +18,7 @@ module Bundler
       :ruby_22  => Gem::Platform::RUBY,
       :ruby_23  => Gem::Platform::RUBY,
       :ruby_24  => Gem::Platform::RUBY,
+      :ruby_25  => Gem::Platform::RUBY,
       :mri      => Gem::Platform::RUBY,
       :mri_18   => Gem::Platform::RUBY,
       :mri_19   => Gem::Platform::RUBY,
@@ -26,6 +27,7 @@ module Bundler
       :mri_22   => Gem::Platform::RUBY,
       :mri_23   => Gem::Platform::RUBY,
       :mri_24   => Gem::Platform::RUBY,
+      :mri_25   => Gem::Platform::RUBY,
       :rbx      => Gem::Platform::RUBY,
       :jruby    => Gem::Platform::JAVA,
       :jruby_18 => Gem::Platform::JAVA,
@@ -38,6 +40,7 @@ module Bundler
       :mswin_22 => Gem::Platform::MSWIN,
       :mswin_23 => Gem::Platform::MSWIN,
       :mswin_24 => Gem::Platform::MSWIN,
+      :mswin_25 => Gem::Platform::MSWIN,
       :mswin64    => Gem::Platform::MSWIN64,
       :mswin64_19 => Gem::Platform::MSWIN64,
       :mswin64_20 => Gem::Platform::MSWIN64,
@@ -45,6 +48,7 @@ module Bundler
       :mswin64_22 => Gem::Platform::MSWIN64,
       :mswin64_23 => Gem::Platform::MSWIN64,
       :mswin64_24 => Gem::Platform::MSWIN64,
+      :mswin64_25 => Gem::Platform::MSWIN64,
       :mingw    => Gem::Platform::MINGW,
       :mingw_18 => Gem::Platform::MINGW,
       :mingw_19 => Gem::Platform::MINGW,
@@ -53,12 +57,14 @@ module Bundler
       :mingw_22 => Gem::Platform::MINGW,
       :mingw_23 => Gem::Platform::MINGW,
       :mingw_24 => Gem::Platform::MINGW,
+      :mingw_25 => Gem::Platform::MINGW,
       :x64_mingw    => Gem::Platform::X64_MINGW,
       :x64_mingw_20 => Gem::Platform::X64_MINGW,
       :x64_mingw_21 => Gem::Platform::X64_MINGW,
       :x64_mingw_22 => Gem::Platform::X64_MINGW,
       :x64_mingw_23 => Gem::Platform::X64_MINGW,
       :x64_mingw_24 => Gem::Platform::X64_MINGW,
+      :x64_mingw_25 => Gem::Platform::X64_MINGW,
     }.freeze
 
     REVERSE_PLATFORM_MAP = {}.tap do |reverse_platform_map|

data/lib/bundler/dsl.rb

@@ -65,7 +65,7 @@ module Bundler
       case specs_by_name_and_version.size
       when 1
         specs = specs_by_name_and_version.values.first
-        spec = specs.find {|s| s.match_platform(Gem::Platform.local) } || specs.first
+        spec = specs.find {|s| s.match_platform(Bundler.local_platform) } || specs.first
 
         @gemspecs << spec
 
@@ -393,7 +393,8 @@ module Bundler
                      "as an option for #{command}, but it is invalid."
                    end
 
-        message << " Valid options are: #{valid_keys.join(", ")}"
+        message << " Valid options are: #{valid_keys.join(", ")}."
+        message << " You may be able to resolve this by upgrading Bundler to the newest version."
         raise InvalidOption, message
       end
     end

data/lib/bundler/env.rb

@@ -12,40 +12,49 @@ module Bundler
       print_gemfile = options.delete(:print_gemfile)
       print_gemspecs = options.delete(:print_gemspecs)
 
-      out = String.new("Environment\n\n")
-      out << "    Bundler   #{Bundler::VERSION}\n"
-      out << "    Rubygems  #{Gem::VERSION}\n"
-      out << "    Ruby      #{ruby_version}"
-      out << "    GEM_HOME  #{ENV["GEM_HOME"]}\n" unless ENV["GEM_HOME"].nil? || ENV["GEM_HOME"].empty?
-      out << "    GEM_PATH  #{ENV["GEM_PATH"]}\n" unless ENV["GEM_PATH"] == ENV["GEM_HOME"]
-      out << "    RVM       #{ENV["rvm_version"]}\n" if ENV["rvm_version"]
-      out << "    Git       #{git_version}\n"
+      out = String.new("## Environment\n\n```\n")
+      out << "Bundler   #{Bundler::VERSION}\n"
+      out << "Rubygems  #{Gem::VERSION}\n"
+      out << "Ruby      #{ruby_version}"
+      out << "GEM_HOME  #{ENV["GEM_HOME"]}\n" unless ENV["GEM_HOME"].nil? || ENV["GEM_HOME"].empty?
+      out << "GEM_PATH  #{ENV["GEM_PATH"]}\n" unless ENV["GEM_PATH"] == ENV["GEM_HOME"]
+      out << "RVM       #{ENV["rvm_version"]}\n" if ENV["rvm_version"]
+      out << "Git       #{git_version}\n"
+      out << "Platform  #{Gem::Platform.local}\n"
+      out << "OpenSSL   #{OpenSSL::OPENSSL_VERSION}\n" if defined?(OpenSSL::OPENSSL_VERSION)
       %w(rubygems-bundler open_gem).each do |name|
         specs = Bundler.rubygems.find_name(name)
-        out << "    #{name} (#{specs.map(&:version).join(",")})\n" unless specs.empty?
+        out << "#{name} (#{specs.map(&:version).join(",")})\n" unless specs.empty?
       end
 
-      out << "\nBundler settings\n\n" unless Bundler.settings.all.empty?
+      out << "```\n"
+
+      out << "\n## Bundler settings\n\n```\n" unless Bundler.settings.all.empty?
       Bundler.settings.all.each do |setting|
-        out << "    " << setting << "\n"
+        out << setting << "\n"
         Bundler.settings.pretty_values_for(setting).each do |line|
-          out << "      " << line << "\n"
+          out << "  " << line << "\n"
         end
       end
+      out << "```\n"
+
+      return out unless SharedHelpers.in_bundle?
 
       if print_gemfile
-        out << "\n#{Bundler.default_gemfile.relative_path_from(SharedHelpers.pwd)}\n\n"
-        out << "    " << read_file(Bundler.default_gemfile).gsub(/\n/, "\n    ") << "\n"
+        out << "\n## Gemfile\n"
+        out << "\n### #{Bundler.default_gemfile.relative_path_from(SharedHelpers.pwd)}\n\n"
+        out << "```ruby\n" << read_file(Bundler.default_gemfile).chomp << "\n```\n"
 
-        out << "\n#{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}\n\n"
-        out << "    " << read_file(Bundler.default_lockfile).gsub(/\n/, "\n    ") << "\n"
+        out << "\n### #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}\n\n"
+        out << "```\n" << read_file(Bundler.default_lockfile).chomp << "\n```\n"
       end
 
       if print_gemspecs
         dsl = Dsl.new.tap {|d| d.eval_gemfile(Bundler.default_gemfile) }
+        out << "\n## Gemspecs\n" unless dsl.gemspecs.empty?
         dsl.gemspecs.each do |gs|
-          out << "\n#{File.basename(gs.loaded_from)}"
-          out << "\n\n    " << read_file(gs.loaded_from).gsub(/\n/, "\n    ") << "\n"
+          out << "\n### #{File.basename(gs.loaded_from)}"
+          out << "\n\n```ruby\n" << read_file(gs.loaded_from).chomp << "\n```\n"
         end
       end
 

data/lib/bundler/errors.rb

@@ -52,6 +52,8 @@ module Bundler
   class CyclicDependencyError < BundlerError; status_code(21); end
   class GemfileLockNotFound < BundlerError; status_code(22); end
   class PluginError < BundlerError; status_code(29); end
+  class SudoNotPermittedError < BundlerError; status_code(30); end
+  class ThreadCreationError < BundlerError; status_code(33); end
   class GemfileEvalError < GemfileError; end
   class MarshalError < StandardError; end
 
@@ -131,4 +133,24 @@ module Bundler
 
     status_code(28)
   end
+
+  class NoSpaceOnDeviceError < PermissionError
+    def message
+      "There was an error while trying to #{action} `#{@path}`. " \
+      "There was insufficent space remaining on the device."
+    end
+
+    status_code(31)
+  end
+
+  class GenericSystemCallError < BundlerError
+    attr_reader :underlying_error
+
+    def initialize(underlying_error, message)
+      @underlying_error = underlying_error
+      super("#{message}\nThe underlying system error is #{@underlying_error.class}: #{@underlying_error}")
+    end
+
+    status_code(32)
+  end
 end

data/lib/bundler/feature_flag.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Bundler
+  class FeatureFlag
+    def self.settings_flag(flag, &default)
+      unless Bundler::Settings::BOOL_KEYS.include?(flag.to_s)
+        raise "Cannot use `#{flag}` as a settings feature flag since it isn't a bool key"
+      end
+      define_method("#{flag}?") do
+        value = Bundler.settings[flag]
+        value = instance_eval(&default) if value.nil? && !default.nil?
+        value
+      end
+    end
+
+    (1..10).each {|v| define_method("bundler_#{v}_mode?") { major_version >= v } }
+
+    settings_flag(:allow_offline_install) { bundler_2_mode? }
+    settings_flag(:only_update_to_newer_versions) { bundler_2_mode? }
+    settings_flag(:plugins) { @bundler_version >= Gem::Version.new("1.14") }
+
+    def initialize(bundler_version)
+      @bundler_version = Gem::Version.create(bundler_version)
+    end
+
+    def major_version
+      @bundler_version.segments.first
+    end
+    private :major_version
+
+    class << self; private :settings_flag; end
+  end
+end

data/lib/bundler/fetcher.rb

@@ -237,7 +237,7 @@ module Bundler
           Bundler.settings[:ssl_client_cert]
         raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
 
-        con = Net::HTTP::Persistent.new "bundler", :ENV
+        con = Bundler::Persistent::Net::HTTP::Persistent.new "bundler", :ENV
         if gem_proxy = Bundler.rubygems.configuration[:http_proxy]
           con.proxy = URI.parse(gem_proxy) if gem_proxy != :no_proxy
         end
@@ -273,7 +273,7 @@ module Bundler
       Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
       Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
       Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
-      Net::HTTP::Persistent::Error, Zlib::BufError, Errno::EHOSTUNREACH
+      Bundler::Persistent::Net::HTTP::Persistent::Error, Zlib::BufError, Errno::EHOSTUNREACH
     ].freeze
 
     def bundler_cert_store

data/lib/bundler/fetcher/compact_index.rb

@@ -3,10 +3,10 @@ require "bundler/fetcher/base"
 require "bundler/worker"
 
 module Bundler
+  autoload :CompactIndexClient, "bundler/compact_index_client"
+
   class Fetcher
     class CompactIndex < Base
-      require "bundler/vendor/compact_index_client/lib/compact_index_client"
-
       def self.compact_index_request(method_name)
         method = instance_method(method_name)
         undef_method(method_name)
@@ -61,7 +61,8 @@ module Bundler
       compact_index_request :fetch_spec
 
       def available?
-        user_home = Pathname.new(Bundler.rubygems.user_home)
+        return nil unless md5_available?
+        user_home = Bundler.user_home
         return nil unless user_home.directory? && user_home.writable?
         # Read info file checksums out of /versions, so we can know if gems are up to date
         fetch_uri.scheme != "file" && compact_index_client.update_and_parse_checksums!
@@ -95,7 +96,7 @@ module Bundler
       def bundle_worker(func = nil)
         @bundle_worker ||= begin
           worker_name = "Compact Index (#{display_uri.host})"
-          Bundler::Worker.new(25, worker_name, func)
+          Bundler::Worker.new(Bundler.current_ruby.rbx? ? 1 : 25, worker_name, func)
         end
         @bundle_worker.tap do |worker|
           worker.instance_variable_set(:@func, func) if func
@@ -114,11 +115,22 @@ module Bundler
         def call(path, headers)
           fetcher.downloader.fetch(fetcher.fetch_uri + path, headers)
         rescue NetworkDownError => e
-          raise unless Bundler.settings[:allow_offline_install] && headers["If-None-Match"]
+          raise unless Bundler.feature_flag.allow_offline_install? && headers["If-None-Match"]
           ui.warn "Using the cached data for the new index because of a network error: #{e}"
           Net::HTTPNotModified.new(nil, nil, nil)
         end
       end
+
+      def md5_available?
+        begin
+          require "openssl"
+          return false if defined?(OpenSSL::OPENSSL_FIPS) && OpenSSL::OPENSSL_FIPS
+        rescue LoadError
+          nil
+        end
+
+        true
+      end
     end
   end
 end

data/lib/bundler/fetcher/dependency.rb

@@ -73,7 +73,7 @@ module Bundler
 
       def dependency_api_uri(gem_names = [])
         uri = fetch_uri + "api/v1/dependencies"
-        uri.query = "gems=#{CGI.escape(gem_names.join(","))}" if gem_names.any?
+        uri.query = "gems=#{CGI.escape(gem_names.sort.join(","))}" if gem_names.any?
         uri
       end
     end

data/lib/bundler/fetcher/downloader.rb

@@ -38,6 +38,8 @@ module Bundler
       end
 
       def request(uri, options)
+        validate_uri_scheme!(uri)
+
         Bundler.ui.debug "HTTP GET #{uri}"
         req = Net::HTTP::Get.new uri.request_uri, options
         if uri.user
@@ -61,6 +63,15 @@ module Bundler
           raise HTTPError, "Network error while fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
         end
       end
+
+    private
+
+      def validate_uri_scheme!(uri)
+        return if uri.scheme =~ /\Ahttps?\z/
+        raise InvalidOption,
+          "The request uri `#{uri}` has an invalid scheme (`#{uri.scheme}`). " \
+          "Did you mean `http` or `https`?"
+      end
     end
   end
 end

data/lib/bundler/friendly_errors.rb

@@ -37,6 +37,11 @@ module Bundler
       when Gem::InvalidSpecificationException
         Bundler.ui.error error.message, :wrap => true
       when SystemExit
+      when *[defined?(Java::JavaLang::OutOfMemoryError) && Java::JavaLang::OutOfMemoryError].compact
+        Bundler.ui.error "\nYour JVM has run out of memory, and Bundler cannot continue. " \
+          "You can decrease the amount of memory Bundler needs by removing gems from your Gemfile, " \
+          "especially large gems. (Gems can be as large as hundreds of megabytes, and Bundler has to read those files!). " \
+          "Alternatively, you can increase the amount of memory the JVM is able to use by running Bundler with jruby -J-Xmx1024m -S bundle (JRuby defaults to 500MB)."
       else request_issue_report_for(error)
       end
     end
@@ -53,25 +58,41 @@ module Bundler
     def request_issue_report_for(e)
       Bundler.ui.info <<-EOS.gsub(/^ {8}/, "")
         --- ERROR REPORT TEMPLATE -------------------------------------------------------
-        - What did you do?
+        # Error Report
+
+        ## Questions
+
+        Please fill out answers to these questions, it'll help us figure out
+        why things are going wrong.
+
+        - **What did you do?**
 
           I ran the command `#{$PROGRAM_NAME} #{ARGV.join(" ")}`
 
-        - What did you expect to happen?
+        - **What did you expect to happen?**
 
           I expected Bundler to...
 
-        - What happened instead?
+        - **What happened instead?**
 
           Instead, what happened was...
 
+        - **Have you tried any solutions posted on similar issues in our issue tracker, stack overflow, or google?**
+
+          I tried...
+
+        - **Have you read our issues document, https://github.com/bundler/bundler/blob/master/ISSUES.md?**
+
+          ...
 
-        Error details
+        ## Backtrace
 
-            #{e.class}: #{e.message}
-              #{e.backtrace && e.backtrace.join("\n              ")}
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace && e.backtrace.join("\n          ").chomp}
+        ```
 
-        #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false).gsub(/\n/, "\n      ").strip}
+        #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false)}
         --- TEMPLATE END ----------------------------------------------------------------
 
       EOS

data/lib/bundler/gem_helper.rb

@@ -98,7 +98,7 @@ module Bundler
         allowed_push_host = @gemspec.metadata["allowed_push_host"]
         gem_command += " --host #{allowed_push_host}" if allowed_push_host
       end
-      unless allowed_push_host || Pathname.new("~/.gem/credentials").expand_path.file?
+      unless allowed_push_host || Bundler.user_home.join(".gem/credentials").file?
         raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
       end
       sh(gem_command)

data/lib/bundler/gem_helpers.rb

@@ -25,8 +25,76 @@ module Bundler
     module_function :generic
 
     def generic_local_platform
-      generic(Gem::Platform.local)
+      generic(Bundler.local_platform)
     end
     module_function :generic_local_platform
+
+    def platform_specificity_match(spec_platform, user_platform)
+      spec_platform = Gem::Platform.new(spec_platform)
+      return PlatformMatch::EXACT_MATCH if spec_platform == user_platform
+      return PlatformMatch::WORST_MATCH if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
+
+      PlatformMatch.new(
+        PlatformMatch.os_match(spec_platform, user_platform),
+        PlatformMatch.cpu_match(spec_platform, user_platform),
+        PlatformMatch.platform_version_match(spec_platform, user_platform)
+      )
+    end
+    module_function :platform_specificity_match
+
+    def select_best_platform_match(specs, platform)
+      specs.select {|spec| spec.match_platform(platform) }.
+        min_by {|spec| platform_specificity_match(spec.platform, platform) }
+    end
+    module_function :select_best_platform_match
+
+    PlatformMatch = Struct.new(:os_match, :cpu_match, :platform_version_match)
+    class PlatformMatch
+      def <=>(other)
+        return nil unless other.is_a?(PlatformMatch)
+
+        m = os_match <=> other.os_match
+        return m unless m.zero?
+
+        m = cpu_match <=> other.cpu_match
+        return m unless m.zero?
+
+        m = platform_version_match <=> other.platform_version_match
+        m
+      end
+
+      EXACT_MATCH = new(-1, -1, -1).freeze
+      WORST_MATCH = new(1_000_000, 1_000_000, 1_000_000).freeze
+
+      def self.os_match(spec_platform, user_platform)
+        if spec_platform.os == user_platform.os
+          0
+        else
+          1
+        end
+      end
+
+      def self.cpu_match(spec_platform, user_platform)
+        if spec_platform.cpu == user_platform.cpu
+          0
+        elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
+          0
+        elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
+          1
+        else
+          2
+        end
+      end
+
+      def self.platform_version_match(spec_platform, user_platform)
+        if spec_platform.version == user_platform.version
+          0
+        elsif spec_platform.version.nil?
+          1
+        else
+          2
+        end
+      end
+    end
   end
 end