bundler 1.9.0 → 1.17.3

data/lib/bundler/similarity_detector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class SimilarityDetector
     SimilarityScore = Struct.new(:string, :distance)
@@ -8,56 +10,54 @@ module Bundler
     end
 
     # return an array of words similar to 'word' from the corpus
-    def similar_words(word, limit=3)
-      words_by_similarity = @corpus.map{|w| SimilarityScore.new(w, levenshtein_distance(word, w))}
-      words_by_similarity.select{|s| s.distance<=limit}.sort_by(&:distance).map(&:string)
+    def similar_words(word, limit = 3)
+      words_by_similarity = @corpus.map {|w| SimilarityScore.new(w, levenshtein_distance(word, w)) }
+      words_by_similarity.select {|s| s.distance <= limit }.sort_by(&:distance).map(&:string)
     end
 
     # return the result of 'similar_words', concatenated into a list
     # (eg "a, b, or c")
-    def similar_word_list(word, limit=3)
-      words = similar_words(word,limit)
-      if words.length==1
+    def similar_word_list(word, limit = 3)
+      words = similar_words(word, limit)
+      if words.length == 1
         words[0]
-      elsif words.length>1
-        [words[0..-2].join(', '), words[-1]].join(' or ')
+      elsif words.length > 1
+        [words[0..-2].join(", "), words[-1]].join(" or ")
       end
     end
 
-
   protected
+
     # http://www.informit.com/articles/article.aspx?p=683059&seqNum=36
-    def levenshtein_distance(this, that, ins=2, del=2, sub=1)
+    def levenshtein_distance(this, that, ins = 2, del = 2, sub = 1)
       # ins, del, sub are weighted costs
       return nil if this.nil?
       return nil if that.nil?
-      dm = []        # distance matrix
+      dm = [] # distance matrix
 
       # Initialize first row values
-      dm[0] = (0..this.length).collect { |i| i * ins }
+      dm[0] = (0..this.length).collect {|i| i * ins }
       fill = [0] * (this.length - 1)
 
       # Initialize first column values
-      for i in 1..that.length
+      (1..that.length).each do |i|
         dm[i] = [i * del, fill.flatten]
       end
 
       # populate matrix
-      for i in 1..that.length
-        for j in 1..this.length
+      (1..that.length).each do |i|
+        (1..this.length).each do |j|
           # critical comparison
           dm[i][j] = [
-               dm[i-1][j-1] +
-                 (this[j-1] == that[i-1] ? 0 : sub),
-                   dm[i][j-1] + ins,
-               dm[i-1][j] + del
-         ].min
+            dm[i - 1][j - 1] + (this[j - 1] == that[i - 1] ? 0 : sub),
+            dm[i][j - 1] + ins,
+            dm[i - 1][j] + del
+          ].min
         end
       end
 
       # The last value in matrix is the Levenshtein distance between the strings
       dm[that.length][this.length]
     end
-
   end
 end

data/lib/bundler/source.rb

@@ -1,18 +1,12 @@
+# frozen_string_literal: true
+
 module Bundler
   class Source
-    autoload :Rubygems, 'bundler/source/rubygems'
-    autoload :Path,     'bundler/source/path'
-    autoload :Git,      'bundler/source/git'
-
-    def self.mirror_for(uri)
-      uri = URI(uri.to_s) unless uri.is_a?(URI)
-
-      # Settings keys are all downcased
-      mirrors = Bundler.settings.gem_mirrors
-      normalized_key = URI(uri.to_s.downcase)
-
-      mirrors[normalized_key] || uri
-    end
+    autoload :Gemspec,  "bundler/source/gemspec"
+    autoload :Git,      "bundler/source/git"
+    autoload :Metadata, "bundler/source/metadata"
+    autoload :Path,     "bundler/source/path"
+    autoload :Rubygems, "bundler/source/rubygems"
 
     attr_accessor :dependency_names
 
@@ -22,12 +16,13 @@ module Bundler
 
     def version_message(spec)
       message = "#{spec.name} #{spec.version}"
+      message += " (#{spec.platform})" if spec.platform != Gem::Platform::RUBY && !spec.platform.nil?
 
       if Bundler.locked_gems
-        locked_spec = Bundler.locked_gems.specs.find { |s| s.name == spec.name }
+        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})", version_color(spec.version, locked_spec_version))
         end
       end
 
@@ -37,5 +32,63 @@ module Bundler
     def can_lock?(spec)
       spec.source == self
     end
+
+    # it's possible that gems from one source depend on gems from some
+    # other source, so now we download gemspecs and iterate over those
+    # dependencies, looking for gems we don't have info on yet.
+    def double_check_for(*); end
+
+    def dependency_names_to_double_check
+      specs.dependency_names
+    end
+
+    def include?(other)
+      other == self
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id} #{self}>"
+    end
+
+    def path?
+      instance_of?(Bundler::Source::Path)
+    end
+
+    def extension_cache_path(spec)
+      return unless Bundler.feature_flag.global_gem_cache?
+      return unless source_slug = extension_cache_slug(spec)
+      Bundler.user_cache.join(
+        "extensions", Gem::Platform.local.to_s, Bundler.ruby_scope,
+        source_slug, spec.full_name
+      )
+    end
+
+  private
+
+    def version_color(spec_version, locked_spec_version)
+      if Gem::Version.correct?(spec_version) && Gem::Version.correct?(locked_spec_version)
+        # display yellow if there appears to be a regression
+        earlier_version?(spec_version, locked_spec_version) ? :yellow : :green
+      else
+        # default to green if the versions cannot be directly compared
+        :green
+      end
+    end
+
+    def earlier_version?(spec_version, locked_spec_version)
+      Gem::Version.new(spec_version) < Gem::Version.new(locked_spec_version)
+    end
+
+    def print_using_message(message)
+      if !message.include?("(was ") && Bundler.feature_flag.suppress_install_using_messages?
+        Bundler.ui.debug message
+      else
+        Bundler.ui.info message
+      end
+    end
+
+    def extension_cache_slug(_)
+      nil
+    end
   end
 end

data/lib/bundler/source/gemspec.rb

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

data/lib/bundler/source/git.rb

@@ -1,12 +1,12 @@
-require 'fileutils'
-require 'uri'
-require 'digest/sha1'
+# frozen_string_literal: true
+
+require "bundler/vendored_fileutils"
+require "uri"
 
 module Bundler
   class Source
-
     class Git < Path
-      autoload :GitProxy, 'bundler/source/git/git_proxy'
+      autoload :GitProxy, "bundler/source/git/git_proxy"
 
       attr_reader :uri, :ref, :branch, :options, :submodules
 
@@ -18,14 +18,15 @@ module Bundler
         @allow_remote = false
 
         # Stringify options that could be set as symbols
-        %w(ref branch tag revision).each{|k| options[k] = options[k].to_s if options[k] }
+        %w[ref branch tag revision].each {|k| options[k] = options[k].to_s if options[k] }
 
-        @uri        = options["uri"] || ''
+        @uri        = options["uri"] || ""
+        @safe_uri   = URICredentialsFilter.credential_filtered_uri(@uri)
         @branch     = options["branch"]
-        @ref        = options["ref"] || options["branch"] || options["tag"] || 'master'
+        @ref        = options["ref"] || options["branch"] || options["tag"] || "master"
         @submodules = options["submodules"]
         @name       = options["name"]
-        @version    = options["version"]
+        @version    = options["version"].to_s.strip.gsub("-", ".pre.")
 
         @copied     = false
         @local      = false
@@ -36,10 +37,10 @@ module Bundler
       end
 
       def to_lock
-        out = "GIT\n"
+        out = String.new("GIT\n")
         out << "  remote: #{@uri}\n"
         out << "  revision: #{revision}\n"
-        %w(ref branch tag submodules).each do |opt|
+        %w[ref branch tag submodules].each do |opt|
           out << "  #{opt}: #{options[opt]}\n" if options[opt]
         end
         out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
@@ -50,31 +51,38 @@ module Bundler
         [self.class, uri, ref, branch, name, version, submodules].hash
       end
 
-      def eql?(o)
-        o.is_a?(Git)         &&
-        uri == o.uri         &&
-        ref == o.ref         &&
-        branch == o.branch   &&
-        name == o.name       &&
-        version == o.version &&
-        submodules == o.submodules
+      def eql?(other)
+        other.is_a?(Git) && uri == other.uri && ref == other.ref &&
+          branch == other.branch && name == other.name &&
+          version == other.version && submodules == other.submodules
       end
 
-      alias == eql?
+      alias_method :==, :eql?
 
       def to_s
         at = if local?
           path
-        elsif options["ref"]
-          shortref_for_display(options["ref"])
+        elsif user_ref = options["ref"]
+          if ref =~ /\A[a-z0-9]{4,}\z/i
+            shortref_for_display(user_ref)
+          else
+            user_ref
+          end
         else
           ref
         end
-        "#{uri} (at #{at})"
+
+        rev = begin
+                "@#{shortref_for_display(revision)}"
+              rescue GitError
+                nil
+              end
+
+        "#{@safe_uri} (at #{at}#{rev})"
       end
 
       def name
-        File.basename(@uri, '.git')
+        File.basename(@uri, ".git")
       end
 
       # This is the path which is going to contain a specific
@@ -83,6 +91,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?
@@ -93,7 +102,7 @@ module Bundler
         end
       end
 
-      alias :path :install_path
+      alias_method :path, :install_path
 
       def extension_dir_name
         "#{base_name}-#{shortref_for_path(revision)}"
@@ -101,6 +110,8 @@ module Bundler
 
       def unlock!
         git_proxy.revision = nil
+        options["revision"] = nil
+
         @unlocked = true
       end
 
@@ -143,14 +154,11 @@ module Bundler
         changed
       end
 
-      # TODO: actually cache git specs
       def specs(*)
-        if has_app_cache? && !local?
-          set_local!(app_cache_path)
-        end
+        set_local!(app_cache_path) if has_app_cache? && !local?
 
         if requires_checkout? && !@copied
-          git_proxy.checkout
+          fetch
           git_proxy.copy_to(install_path, submodules)
           serialize_gemspecs_in(install_path)
           @copied = true
@@ -159,24 +167,27 @@ module Bundler
         local_specs
       end
 
-      def install(spec)
-        debug = nil
-        if requires_checkout? && !@copied
-          debug = "  * Checking out revision: #{ref}"
+      def install(spec, options = {})
+        force = options[:force]
+
+        print_using_message "Using #{version_message(spec)} from #{self}"
+
+        if (requires_checkout? && !@copied) || force
+          Bundler.ui.debug "  * Checking out revision: #{ref}"
           git_proxy.copy_to(install_path, submodules)
           serialize_gemspecs_in(install_path)
           @copied = true
         end
-        generate_bin(spec)
-        if requires_checkout? && spec.post_install_message
-          Installer.post_install_messages[spec.name] = spec.post_install_message
-        end
-        ["Using #{version_message(spec)} from #{to_s}", nil, debug]
+
+        generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }
+        generate_bin(spec, generate_bin_options)
+
+        requires_checkout? ? spec.post_install_message : nil
       end
 
       def cache(spec, custom_path = nil)
         app_cache_path = app_cache_path(custom_path)
-        return unless Bundler.settings[:cache_all]
+        return unless Bundler.feature_flag.cache_all?
         return if path == app_cache_path
         cached!
         FileUtils.rm_rf(app_cache_path)
@@ -189,7 +200,7 @@ module Bundler
         super
       rescue PathError => e
         Bundler.ui.trace e
-        raise GitError, "#{to_s} is not yet checked out. Run `bundle install` first."
+        raise GitError, "#{self} is not yet checked out. Run `bundle install` first."
       end
 
       # This is the path which is going to contain a cache
@@ -198,13 +209,11 @@ module Bundler
       # When using local git repos, this is set to the local repo.
       def cache_path
         @cache_path ||= begin
-          git_scope = "#{base_name}-#{uri_hash}"
-
-          if Bundler.requires_sudo?
-            Bundler.user_bundle_path.join("cache/git", git_scope)
+          if Bundler.requires_sudo? || Bundler.feature_flag.global_gem_cache?
+            Bundler.user_cache
           else
-            Bundler.cache.join("git", git_scope)
-          end
+            Bundler.bundle_path.join("cache", "bundler")
+          end.join("git", git_scope)
         end
       end
 
@@ -220,17 +229,19 @@ module Bundler
         @allow_remote || @allow_cached
       end
 
-      private
+    private
 
       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.
           spec = Bundler.load_gemspec(spec_path)
           next unless spec
-          File.open(spec_path, 'wb') {|file| file.write(spec.to_ruby) }
+          Bundler.rubygems.set_installed_by_version(spec)
+          Bundler.rubygems.validate(spec)
+          File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
         end
       end
 
@@ -253,7 +264,7 @@ module Bundler
       end
 
       def base_name
-        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*},''),".git")
+        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*}, ""), ".git")
       end
 
       def shortref_for_display(ref)
@@ -268,12 +279,12 @@ module Bundler
         if uri =~ %r{^\w+://(\w+@)?}
           # Downcase the domain component of the URI
           # and strip off a trailing slash, if one is present
-          input = URI.parse(uri).normalize.to_s.sub(%r{/$},'')
+          input = URI.parse(uri).normalize.to_s.sub(%r{/$}, "")
         else
           # If there is no URI scheme, assume it is an ssh/git URI
           input = uri
         end
-        Digest::SHA1.hexdigest(input)
+        SharedHelpers.digest(:SHA1).hexdigest(input)
       end
 
       def cached_revision
@@ -288,7 +299,31 @@ module Bundler
         @git_proxy ||= GitProxy.new(cache_path, uri, ref, cached_revision, self)
       end
 
-    end
+      def fetch
+        git_proxy.checkout
+      rescue GitError => e
+        raise unless Bundler.feature_flag.allow_offline_install?
+        Bundler.ui.warn "Using cached git data because of network errors:\n#{e}"
+      end
+
+      # no-op, since we validate when re-serializing the gemspec
+      def validate_spec(_spec); end
 
+      if Bundler.rubygems.stubs_provide_full_functionality?
+        def load_gemspec(file)
+          stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
+          stub.full_gem_path = Pathname.new(file).dirname.expand_path(root).to_s.untaint
+          StubSpecification.from_stub(stub)
+        end
+      end
+
+      def git_scope
+        "#{base_name}-#{uri_hash}"
+      end
+
+      def extension_cache_slug(_)
+        extension_dir_name
+      end
+    end
   end
 end