bundler 1.12.6 → 1.13.0.pre.1

data/lib/bundler/resolver.rb

@@ -106,14 +106,8 @@ module Bundler
         specs.values
       end
 
-      def activate_platform(platform)
-        unless @activated.include?(platform)
-          if for?(platform, nil)
-            @activated << platform
-            return __dependencies[platform] || []
-          end
-        end
-        []
+      def activate_platform!(platform)
+        @activated << platform if !@activated.include?(platform) && for?(platform, nil)
       end
 
       def name
@@ -131,7 +125,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.gem_version)
+            spec_required_ruby_version.satisfied_by?(required_ruby_version.to_gem_version_with_patchlevel)
           else
             true
           end
@@ -240,8 +234,6 @@ module Bundler
       Bundler.ui.info ".", false
     end
 
-  private
-
     include Molinillo::SpecificationProvider
 
     def dependencies_for(specification)
@@ -252,28 +244,34 @@ module Bundler
       platform = dependency.__platform
       dependency = dependency.dep unless dependency.is_a? Gem::Dependency
       search = @search_for[dependency] ||= begin
-        index = @source_requirements[dependency.name] || @index
+        index = index_for(dependency)
         results = index.search(dependency, @base[dependency.name])
         if vertex = @base_dg.vertex_named(dependency.name)
           locked_requirement = vertex.payload.requirement
         end
         if results.any?
-          version = results.first.version
-          nested  = [[]]
+          nested = []
           results.each do |spec|
-            if spec.version != version
-              nested << []
-              version = spec.version
+            version, specs = nested.last
+            if version == spec.version
+              specs << spec
+            else
+              nested << [spec.version, [spec]]
             end
-            nested.last << spec
           end
-          groups = nested.map {|a| SpecGroup.new(a) }
-          !locked_requirement ? groups : groups.select {|sg| locked_requirement.satisfied_by? sg.version }
+          nested.reduce([]) do |groups, (version, specs)|
+            next groups if locked_requirement && !locked_requirement.satisfied_by?(version)
+            groups << SpecGroup.new(specs)
+          end
         else
           []
         end
       end
-      search.select {|sg| sg.for?(platform, @ruby_version) }.each {|sg| sg.activate_platform(platform) }
+      search.select {|sg| sg.for?(platform, @ruby_version) }.each {|sg| sg.activate_platform!(platform) }
+    end
+
+    def index_for(dependency)
+      @source_requirements[dependency.name] || @index
     end
 
     def name_for(dependency)
@@ -293,7 +291,7 @@ module Bundler
     end
 
     def requirement_satisfied_by?(requirement, activated, spec)
-      requirement.matches_spec?(spec)
+      requirement.matches_spec?(spec) || spec.source.is_a?(Source::Gemspec)
     end
 
     def sort_dependencies(dependencies, activated, conflicts)
@@ -308,20 +306,20 @@ module Bundler
       end
     end
 
+  private
+
     def amount_constrained(dependency)
       @amount_constrained ||= {}
       @amount_constrained[dependency.name] ||= begin
         if (base = @base[dependency.name]) && !base.empty?
           dependency.requirement.satisfied_by?(base.first.version) ? 0 : 1
         else
-          base_dep = Dependency.new dependency.name, ">= 0.a"
-          all = search_for(DepProxy.new base_dep, dependency.__platform).size.to_f
-          if all.zero?
-            0
-          elsif (search = search_for(dependency).size.to_f) == all && all == 1
-            0
+          all = index_for(dependency).search(dependency.name).size
+          if all <= 1
+            all
           else
-            search / all
+            search = search_for(dependency).size
+            search - all
           end
         end
       end

data/lib/bundler/ruby_version.rb

@@ -38,6 +38,22 @@ module Bundler
       output
     end
 
+    # @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
+
     def single_version_string
       to_s(gem_version)
     end
@@ -64,7 +80,7 @@ module Bundler
     #   2. ruby_version
     #   3. engine_version
     def diff(other)
-      raise ArgumentError, "Can only diff with a RubyVersion" unless other.is_a?(RubyVersion)
+      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)
@@ -87,9 +103,11 @@ module Bundler
         # 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.dup
+                              ruby_version
                             when "rbx"
                               Rubinius::VERSION.dup
                             when "jruby"
@@ -97,7 +115,15 @@ module Bundler
                             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)
+      @ruby_version ||= RubyVersion.new(ruby_version, RUBY_PATCHLEVEL.to_s, ruby_engine, ruby_engine_version)
+    end
+
+    def to_gem_version_with_patchlevel
+      @gem_version_with_patch ||= begin
+        Gem::Version.create("#{@gem_version}.#{@patchlevel}")
+      rescue ArgumentError
+        @gem_version
+      end
     end
 
   private

data/lib/bundler/rubygems_ext.rb

@@ -22,9 +22,11 @@ module Gem
     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
       if source.respond_to?(:path)
-        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s.untaint
+        Pathname.new(loaded_from).dirname.expand_path(source.root).to_s.untaint
       else
         rg_full_gem_path
       end

data/lib/bundler/rubygems_integration.rb

@@ -212,7 +212,7 @@ 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].push(*v) }
+      fetch_prerelease_specs.each {|k, v| spec_list[k].concat(v) }
 
       spec_list.values.first
     ensure
@@ -462,8 +462,14 @@ module Bundler
     end
 
     def redefine_method(klass, method, &block)
-      if klass.instance_methods(false).include?(method)
-        klass.send(:remove_method, method)
+      begin
+        if klass.instance_method(method) && method != :initialize
+          # doing this to ensure we also get private methods
+          klass.send(:remove_method, method)
+        end
+      rescue NameError
+        # method isn't defined
+        nil
       end
       klass.send(:define_method, method, &block)
     end
@@ -605,7 +611,7 @@ module Bundler
         specs = fetch_specs(source, remote, "specs")
         pres = fetch_specs(source, remote, "prerelease_specs") || []
 
-        specs.push(*pres)
+        specs.concat(pres)
       end
 
       def download_gem(spec, uri, path)

data/lib/bundler/runtime.rb

@@ -107,14 +107,6 @@ module Bundler
       end
     end
 
-    def dependencies_for(*groups)
-      if groups.empty?
-        dependencies
-      else
-        dependencies.select {|d| (groups & d.groups).any? }
-      end
-    end
-
     alias_method :gems, :specs
 
     def cache(custom_path = nil)
@@ -125,16 +117,9 @@ module Bundler
 
       Bundler.ui.info "Updating files in #{Bundler.settings.app_cache_path}"
 
-      # Do not try to cache specification for the gem described by the .gemspec
-      root_gem_name = nil
-      if gemspec_cache_hash = Bundler.instance_variable_get(:@gemspec_cache)
-        gemspec = gemspec_cache_hash.values.first
-        root_gem_name = gemspec.name unless gemspec.nil?
-      end
-
       specs.each do |spec|
         next if spec.name == "bundler"
-        next if !Dir.glob("*.gemspec").empty? && spec.source.class == Bundler::Source::Path && root_gem_name && spec.name == root_gem_name
+        next if spec.source.is_a?(Source::Gemspec)
         spec.source.send(:fetch_gem, spec) if Bundler.settings[:cache_all_platforms] && spec.source.respond_to?(:fetch_gem, true)
         spec.source.cache(spec, custom_path) if spec.source.respond_to?(:cache)
       end

data/lib/bundler/settings.rb

@@ -3,7 +3,7 @@ require "uri"
 
 module Bundler
   class Settings
-    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check disable_shared_gems ignore_messages gem.mit gem.coc silence_root_warning no_install).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 no_install plugins).freeze
     NUMBER_KEYS = %w(retry timeout redirect ssl_verify_mode).freeze
     DEFAULT_CONFIG = { :retry => 3, :timeout => 10, :redirect => 5 }.freeze
 
@@ -201,8 +201,8 @@ module Bundler
         hash.delete(key) if value.nil?
         SharedHelpers.filesystem_access(file) do |p|
           FileUtils.mkdir_p(p.dirname)
-          require "bundler/psyched_yaml"
-          File.open(p, "w") {|f| f.puts YAML.dump(hash) }
+          require "bundler/yaml_serializer"
+          p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) }
         end
       end
 
@@ -221,25 +221,29 @@ module Bundler
       Pathname.new(@root).join("config") if @root
     end
 
+    CONFIG_REGEX = %r{ # rubocop:disable Style/RegexpLiteral
+      ^
+      (BUNDLE_.+):\s # the key
+      (?: !\s)? # optional exclamation mark found with ruby 1.9.3
+      (['"]?) # optional opening quote
+      (.* # contents of the value
+        (?: # optionally, up until the next key
+          (\n(?!BUNDLE).+)*
+        )
+      )
+      \2 # matching closing quote
+      $
+    }xo
+
     def load_config(config_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$/
-        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]
+        require "bundler/yaml_serializer"
+        YAMLSerializer.load config_file.read
       end
     end
 
-    def convert_to_backward_compatible_key(key)
-      key = "#{key}/" if key =~ /https?:/i && key !~ %r{/\Z}
-      key = key.gsub(".", "__") if key.include?(".")
-      key
-    end
-
     # TODO: duplicates Rubygems#normalize_uri
     # TODO: is this the correct place to validate mirror URIs?
     def self.normalize_uri(uri)

data/lib/bundler/setup.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "bundler/postit_trampoline" unless ENV["BUNDLE_DISABLE_POSTIT"]
 require "bundler/shared_helpers"
 
 if Bundler::SharedHelpers.in_bundle?

data/lib/bundler/shared_helpers.rb

@@ -109,6 +109,8 @@ module Bundler
       raise TemporaryResourceError.new(path, action)
     rescue Errno::EPROTO
       raise VirtualProtocolError.new
+    rescue *[const_get_safely(:ENOTSUP, Errno)].compact
+      raise OperationNotSupportedError.new(path, action)
     end
 
     def const_get_safely(constant_name, namespace)
@@ -167,6 +169,7 @@ module Bundler
 
       # Set BUNDLE_GEMFILE
       ENV["BUNDLE_GEMFILE"] = find_gemfile.to_s
+      ENV["BUNDLER_VERSION"] = Bundler::VERSION
     end
 
     def set_path

data/lib/bundler/source.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 module Bundler
   class Source
-    autoload :Rubygems, "bundler/source/rubygems"
-    autoload :Path,     "bundler/source/path"
+    autoload :Gemspec,  "bundler/source/gemspec"
     autoload :Git,      "bundler/source/git"
+    autoload :Path,     "bundler/source/path"
+    autoload :Rubygems, "bundler/source/rubygems"
 
     attr_accessor :dependency_names
 
@@ -18,7 +19,7 @@ module Bundler
         locked_spec = Bundler.locked_gems.specs.find {|s| s.name == spec.name }
         locked_spec_version = locked_spec.version if locked_spec
         if locked_spec_version && spec.version != locked_spec_version
-          message += " (was #{locked_spec_version})"
+          message += " (#{Bundler.ui.add_color("was #{locked_spec_version}", :green)})"
         end
       end
 

data/lib/bundler/source/gemspec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Bundler
+  class Source
+    class Gemspec < Path
+      attr_reader :gemspec
+
+      def initialize(options)
+        super
+        @gemspec = options["gemspec"]
+      end
+    end
+  end
+end

data/lib/bundler/source/git.rb

@@ -86,6 +86,7 @@ module Bundler
       def install_path
         @install_path ||= begin
           git_scope = "#{base_name}-#{shortref_for_path(revision)}"
+
           path = Bundler.install_path.join(git_scope)
 
           if !path.exist? && Bundler.requires_sudo?
@@ -146,7 +147,7 @@ module Bundler
         changed
       end
 
-      # TODO: actually cache git specs
+      # TODO: cache git specs
       def specs(*)
         set_local!(app_cache_path) if has_app_cache? && !local?
 
@@ -227,8 +228,8 @@ module Bundler
       end
 
       def serialize_gemspecs_in(destination)
-        expanded_path = destination.expand_path(Bundler.root)
-        Dir["#{expanded_path}/#{@glob}"].each do |spec_path|
+        destination = destination.expand_path(Bundler.root) if destination.relative?
+        Dir["#{destination}/#{@glob}"].each do |spec_path|
           # Evaluate gemspecs and cache the result. Gemspecs
           # in git might require git or other dependencies.
           # The gemspecs we cache should already be evaluated.

data/lib/bundler/source/git/git_proxy.rb

@@ -86,12 +86,12 @@ module Bundler
         def checkout
           if path.exist?
             return if has_revision_cached?
-            Bundler.ui.info "Fetching #{uri}"
+            Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
             in_path do
               git_retry %(fetch --force --quiet --tags #{uri_escaped_with_configured_credentials} "refs/heads/*:refs/heads/*")
             end
           else
-            Bundler.ui.info "Fetching #{uri}"
+            Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
             SharedHelpers.filesystem_access(path.dirname) do |p|
               FileUtils.mkdir_p(p)
             end
@@ -145,10 +145,14 @@ module Bundler
         end
 
         def git(command, check_errors = true, error_msg = nil)
-          raise GitNotAllowedError.new(command) unless allow?
+          command_with_no_credentials = URICredentialsFilter.credential_filtered_string(command, uri)
+          raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
+
           out = SharedHelpers.with_clean_git_env { `git #{command}` }
-          raise GitCommandError.new(command, path, error_msg) if check_errors && !$?.success?
-          out
+
+          stdout_with_no_credentials = URICredentialsFilter.credential_filtered_string(out, uri)
+          raise GitCommandError.new(command_with_no_credentials, path, error_msg) if check_errors && !$?.success?
+          stdout_with_no_credentials
         end
 
         def has_revision_cached?

data/lib/bundler/source/path.rb

@@ -60,8 +60,8 @@ module Bundler
       end
 
       def eql?(other)
-        other.instance_of?(Path) &&
-          expanded_path == expand(other.path) &&
+        return unless other.class == Path || other.class == Gemspec
+        expanded_path == expand(other.path) &&
           version == other.version
       end
 
@@ -107,6 +107,14 @@ module Bundler
         name
       end
 
+      def root
+        Bundler.root
+      end
+
+      def is_a_path?
+        instance_of?(Path)
+      end
+
     private
 
       def expanded_path
@@ -186,6 +194,7 @@ module Bundler
         # Some gem authors put absolute paths in their gemspec
         # and we have to save them from themselves
         spec.files = spec.files.map do |p|
+          next p unless p =~ /\A#{Pathname::SEPARATOR_PAT}/
           next if File.directory?(p)
           begin
             Pathname.new(p).relative_path_from(gem_dir).to_s