rubygems-update 2.6.7 → 2.6.8

data/bundler/lib/bundler/lazy_specification.rb

@@ -5,6 +5,22 @@ require "bundler/match_platform"
 
 module Bundler
   class LazySpecification
+    Identifier = Struct.new(:name, :version, :source, :platform, :dependencies)
+    class Identifier
+      include Comparable
+      def <=>(other)
+        return unless other.is_a?(Identifier)
+        [name, version, platform_string] <=> [other.name, other.version, other.platform_string]
+      end
+
+    protected
+
+      def platform_string
+        platform_string = platform.to_s
+        platform_string == Index::RUBY ? Index::NULL : platform_string
+      end
+    end
+
     include MatchPlatform
 
     attr_reader :name, :version, :dependencies, :platform
@@ -53,7 +69,12 @@ module Bundler
     end
 
     def __materialize__
-      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+      search_object = Bundler.settings[:specific_platform] || Bundler.settings[:force_ruby_platform] ? self : Dependency.new(name, version)
+      @specification = if source.is_a?(Source::Gemspec) && source.gemspec.name == name
+        source.gemspec.tap {|s| s.source = source }
+      else
+        source.specs.search(search_object).last
+      end
     end
 
     def respond_to?(*args)
@@ -61,11 +82,15 @@ module Bundler
     end
 
     def to_s
-      @__to_s ||= "#{name} (#{version})"
+      @__to_s ||= if platform == Gem::Platform::RUBY || platform.nil?
+        "#{name} (#{version})"
+      else
+        "#{name} (#{version}-#{platform})"
+      end
     end
 
     def identifier
-      @__identifier ||= [name, version, source, platform, dependencies].hash
+      @__identifier ||= Identifier.new(name, version, source, platform, dependencies)
     end
 
   private

data/bundler/lib/bundler/lockfile_parser.rb

@@ -22,14 +22,18 @@ module Bundler
     GIT          = "GIT".freeze
     GEM          = "GEM".freeze
     PATH         = "PATH".freeze
+    PLUGIN       = "PLUGIN SOURCE".freeze
     SPECS        = "  specs:".freeze
     OPTIONS      = /^  ([a-z]+): (.*)$/i
-    SOURCE       = [GIT, GEM, PATH].freeze
+    SOURCE       = [GIT, GEM, PATH, PLUGIN].freeze
 
     SECTIONS_BY_VERSION_INTRODUCED = {
-      Gem::Version.create("1.0") => [DEPENDENCIES, PLATFORMS, GIT, GEM, PATH].freeze,
-      Gem::Version.create("1.10") => [BUNDLED].freeze,
-      Gem::Version.create("1.12") => [RUBY].freeze,
+      # The strings have to be dup'ed for old RG on Ruby 2.3+
+      # TODO: remove dup in Bundler 2.0
+      Gem::Version.create("1.0".dup) => [DEPENDENCIES, PLATFORMS, GIT, GEM, PATH].freeze,
+      Gem::Version.create("1.10".dup) => [BUNDLED].freeze,
+      Gem::Version.create("1.12".dup) => [RUBY].freeze,
+      Gem::Version.create("1.13".dup) => [PLUGIN].freeze,
     }.freeze
 
     KNOWN_SECTIONS = SECTIONS_BY_VERSION_INTRODUCED.values.flatten.freeze
@@ -46,7 +50,7 @@ module Bundler
 
     def self.sections_to_ignore(base_version = nil)
       base_version &&= base_version.release
-      base_version ||= Gem::Version.create("1.0")
+      base_version ||= Gem::Version.create("1.0".dup)
       attributes = []
       SECTIONS_BY_VERSION_INTRODUCED.each do |version, introduced|
         next if version <= base_version
@@ -88,7 +92,7 @@ module Bundler
         end
       end
       @sources << @rubygems_aggregate
-      @specs = @specs.values
+      @specs = @specs.values.sort_by(&:identifier)
       warn_for_outdated_bundler_version
     rescue ArgumentError => e
       Bundler.ui.debug(e)
@@ -105,8 +109,8 @@ module Bundler
         raise LockfileError, "You must use Bundler #{bundler_version.segments.first} or greater with this lockfile."
       when 0
         if current_version < bundler_version
-          Bundler.ui.warn "Warning: the running version of Bundler is older " \
-               "than the version that created the lockfile. We suggest you " \
+          Bundler.ui.warn "Warning: the running version of Bundler (#{current_version}) is older " \
+               "than the version that created the lockfile (#{bundler_version}). We suggest you " \
                "upgrade to the latest version of Bundler by running `gem " \
                "install bundler#{prerelease_text}`.\n"
         end
@@ -116,17 +120,14 @@ module Bundler
   private
 
     TYPES = {
-      GIT  => Bundler::Source::Git,
-      GEM  => Bundler::Source::Rubygems,
-      PATH => Bundler::Source::Path,
+      GIT    => Bundler::Source::Git,
+      GEM    => Bundler::Source::Rubygems,
+      PATH   => Bundler::Source::Path,
+      PLUGIN => Bundler::Plugin,
     }.freeze
 
     def parse_source(line)
       case line
-      when GIT, GEM, PATH
-        @current_source = nil
-        @opts = {}
-        @type = line
       when SPECS
         case @type
         when PATH
@@ -145,6 +146,9 @@ module Bundler
             @rubygems_aggregate.add_remote(url)
           end
           @current_source = @rubygems_aggregate
+        when PLUGIN
+          @current_source = Plugin.source_from_lock(@opts)
+          @sources << @current_source
         end
       when OPTIONS
         value = $2
@@ -159,6 +163,10 @@ module Bundler
         else
           @opts[key] = value
         end
+      when *SOURCE
+        @current_source = nil
+        @opts = {}
+        @type = line
       else
         parse_spec(line)
       end
@@ -199,8 +207,10 @@ module Bundler
     def parse_spec(line)
       if line =~ NAME_VERSION_4
         name = $1
-        version = Gem::Version.new($2)
-        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        version = $2
+        platform = $3
+        version = Gem::Version.new(version)
+        platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
         @current_spec.source = @current_source
 

data/bundler/lib/bundler/match_platform.rb

@@ -8,7 +8,8 @@ module Bundler
     def match_platform(p)
       Gem::Platform::RUBY == platform ||
         platform.nil? || p == platform ||
-        generic(Gem::Platform.new(platform)) === p
+        generic(Gem::Platform.new(platform)) === p ||
+        Gem::Platform.new(platform) === p
     end
   end
 end

data/bundler/lib/bundler/mirror.rb

@@ -43,7 +43,7 @@ module Bundler
     private
 
       def fetch_valid_mirror_for(uri)
-        mirror = (@mirrors[URI(uri.to_s.downcase)] || Mirror.new(uri)).validate!(@prober)
+        mirror = (@mirrors[URI(uri.to_s.downcase)] || @mirrors[URI(uri.to_s).host] || Mirror.new(uri)).validate!(@prober)
         mirror = Mirror.new(uri) unless mirror.valid?
         mirror
       end
@@ -121,7 +121,7 @@ module Bundler
         if uri == "all"
           @all = true
         else
-          @uri = Settings.normalize_uri(uri)
+          @uri = URI(uri).absolute? ? Settings.normalize_uri(uri) : uri
         end
         @value = value
       end

data/bundler/lib/bundler/plugin.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+require "bundler/plugin/api"
 
 module Bundler
   module Plugin
-    autoload :API,        "bundler/plugin/api"
     autoload :DSL,        "bundler/plugin/dsl"
     autoload :Index,      "bundler/plugin/index"
     autoload :Installer,  "bundler/plugin/installer"
@@ -10,45 +10,62 @@ module Bundler
 
     class MalformattedPlugin < PluginError; end
     class UndefinedCommandError < PluginError; end
+    class UnknownSourceError < PluginError; end
 
     PLUGIN_FILE_NAME = "plugins.rb".freeze
 
   module_function
 
-    @commands = {}
+    def reset!
+      instance_variables.each {|i| remove_instance_variable(i) }
+
+      @sources = {}
+      @commands = {}
+      @hooks_by_event = Hash.new {|h, k| h[k] = [] }
+      @loaded_plugin_names = []
+    end
+
+    reset!
 
     # Installs a new plugin by the given name
     #
     # @param [Array<String>] names the name of plugin to be installed
-    # @param [Hash] options various parameters as described in description
-    # @option options [String] :source rubygems source to fetch the plugin gem from
-    # @option options [String] :version (optional) the version of the plugin to install
+    # @param [Hash] options various parameters as described in description.
+    #               Refer to cli/plugin for available options
     def install(names, options)
-      paths = Installer.new.install(names, options)
+      specs = Installer.new.install(names, options)
 
-      save_plugins paths
+      save_plugins names, specs
     rescue PluginError => e
-      paths.values.map {|path| Bundler.rm_rf(path) } if paths
-      Bundler.ui.error "Failed to install plugin #{name}: #{e.message}\n  #{e.backtrace.join("\n  ")}"
+      specs.values.map {|spec| Bundler.rm_rf(spec.full_gem_path) } if specs
+      Bundler.ui.error "Failed to install plugin #{name}: #{e.message}\n  #{e.backtrace.join("\n ")}"
     end
 
     # Evaluates the Gemfile with a limited DSL and installs the plugins
     # specified by plugin method
     #
     # @param [Pathname] gemfile path
+    # @param [Proc] block that can be evaluated for (inline) Gemfile
     def gemfile_install(gemfile = nil, &inline)
+      builder = DSL.new
       if block_given?
-        builder = DSL.new
         builder.instance_eval(&inline)
-        definition = builder.to_definition(nil, true)
       else
-        definition = DSL.evaluate(gemfile, nil, {})
+        builder.eval_gemfile(gemfile)
       end
-      return unless definition.dependencies.any?
+      definition = builder.to_definition(nil, true)
+
+      return if definition.dependencies.empty?
 
-      plugins = Installer.new.install_definition(definition)
+      plugins = definition.dependencies.map(&:name).reject {|p| index.installed? p }
+      installed_specs = Installer.new.install_definition(definition)
 
-      save_plugins plugins
+      save_plugins plugins, installed_specs, builder.inferred_plugins
+    rescue => e
+      unless e.is_a?(GemfileError)
+        Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
+      end
+      raise
     end
 
     # The index object used to store the details about the plugin
@@ -56,9 +73,25 @@ module Bundler
       @index ||= Index.new
     end
 
-    # The directory root to all plugin related data
+    # The directory root for all plugin related data
+    #
+    # Points to root in app_config_path if ran in an app else points to the one
+    # in user_bundle_path
     def root
-      @root ||= Bundler.user_bundle_path.join("plugin")
+      @root ||= if SharedHelpers.in_bundle?
+        local_root
+      else
+        global_root
+      end
+    end
+
+    def local_root
+      Bundler.app_config_path.join("plugin")
+    end
+
+    # The global directory root for all plugin related data
+    def global_root
+      Bundler.user_bundle_path.join("plugin")
     end
 
     # The cache directory for plugin stuffs
@@ -71,7 +104,7 @@ module Bundler
       @commands[command] = cls
     end
 
-    # Checks if any plugins handles the command
+    # Checks if any plugin handles the command
     def command?(command)
       !index.command_plugin(command).nil?
     end
@@ -79,13 +112,64 @@ module Bundler
     # To be called from Cli class to pass the command and argument to
     # approriate plugin class
     def exec_command(command, args)
-      raise UndefinedCommandError, "Command #{command} not found" unless command? command
+      raise UndefinedCommandError, "Command `#{command}` not found" unless command? command
 
       load_plugin index.command_plugin(command) unless @commands.key? command
 
       @commands[command].new.exec(command, args)
     end
 
+    # To be called via the API to register to handle a source plugin
+    def add_source(source, cls)
+      @sources[source] = cls
+    end
+
+    # Checks if any plugin declares the source
+    def source?(name)
+      !index.source_plugin(name.to_s).nil?
+    end
+
+    # @return [Class] that handles the source. The calss includes API::Source
+    def source(name)
+      raise UnknownSourceError, "Source #{name} not found" unless source? name
+
+      load_plugin(index.source_plugin(name)) unless @sources.key? name
+
+      @sources[name]
+    end
+
+    # @param [Hash] The options that are present in the lock file
+    # @return [API::Source] the instance of the class that handles the source
+    #                       type passed in locked_opts
+    def source_from_lock(locked_opts)
+      src = source(locked_opts["type"])
+
+      src.new(locked_opts.merge("uri" => locked_opts["remote"]))
+    end
+
+    # To be called via the API to register a hooks and corresponding block that
+    # will be called to handle the hook
+    def add_hook(event, &block)
+      @hooks_by_event[event.to_s] << block
+    end
+
+    # Runs all the hooks that are registered for the passed event
+    #
+    # It passes the passed arguments and block to the block registered with
+    # the api.
+    #
+    # @param [String] event
+    def hook(event, *args, &arg_blk)
+      return unless Bundler.feature_flag.plugins?
+
+      plugins = index.hook_plugins(event)
+      return unless plugins.any?
+
+      (plugins - @loaded_plugin_names).each {|name| load_plugin(name) }
+
+      @hooks_by_event[event].each {|blk| blk.call(*args, &arg_blk) }
+    end
+
     # currently only intended for specs
     #
     # @return [String, nil] installed path
@@ -95,13 +179,16 @@ module Bundler
 
     # Post installation processing and registering with index
     #
-    # @param [Hash] plugins mapped to their installtion path
-    def save_plugins(plugins)
-      plugins.each do |name, path|
-        path = Pathname.new path
-        validate_plugin! path
-        register_plugin name, path
-        Bundler.ui.info "Installed plugin #{name}"
+    # @param [Array<String>] plugins list to be installed
+    # @param [Hash] specs of plugins mapped to installation path (currently they
+    #               contain all the installed specs, including plugins)
+    # @param [Array<String>] names of inferred source plugins that can be ignored
+    def save_plugins(plugins, specs, optional_plugins = [])
+      plugins.each do |name|
+        spec = specs[name]
+        validate_plugin! Pathname.new(spec.full_gem_path)
+        installed = register_plugin(name, spec, optional_plugins.include?(name))
+        Bundler.ui.info "Installed plugin #{name}" if installed
       end
     end
 
@@ -110,21 +197,33 @@ module Bundler
     # At present it only checks whether it contains plugins.rb file
     #
     # @param [Pathname] plugin_path the path plugin is installed at
-    # @raise [Error] if plugins.rb file is not found
+    # @raise [MalformattedPlugin] if plugins.rb file is not found
     def validate_plugin!(plugin_path)
       plugin_file = plugin_path.join(PLUGIN_FILE_NAME)
-      raise MalformattedPlugin, "#{PLUGIN_FILE_NAME} was not found in the plugin!" unless plugin_file.file?
+      raise MalformattedPlugin, "#{PLUGIN_FILE_NAME} was not found in the plugin." unless plugin_file.file?
     end
 
     # Runs the plugins.rb file in an isolated namespace, records the plugin
     # actions it registers for and then passes the data to index to be stored.
     #
     # @param [String] name the name of the plugin
-    # @param [Pathname] path the path where the plugin is installed at
-    def register_plugin(name, path)
+    # @param [Specification] spec of installed plugin
+    # @param [Boolean] optional_plugin, removed if there is conflict with any
+    #                     other plugin (used for default source plugins)
+    #
+    # @raise [MalformattedPlugin] if plugins.rb raises any error
+    def register_plugin(name, spec, optional_plugin = false)
       commands = @commands
+      sources = @sources
+      hooks = @hooks_by_event
 
       @commands = {}
+      @sources = {}
+      @hooks_by_event = Hash.new {|h, k| h[k] = [] }
+
+      load_paths = spec.load_paths
+      add_to_load_path(load_paths)
+      path = Pathname.new spec.full_gem_path
 
       begin
         load path.join(PLUGIN_FILE_NAME), true
@@ -132,9 +231,18 @@ module Bundler
         raise MalformattedPlugin, "#{e.class}: #{e.message}"
       end
 
-      index.register_plugin name, path.to_s, @commands.keys
+      if optional_plugin && @sources.keys.any? {|s| source? s }
+        Bundler.rm_rf(path)
+        false
+      else
+        index.register_plugin(name, path.to_s, load_paths, @commands.keys,
+          @sources.keys, @hooks_by_event.keys)
+        true
+      end
     ensure
       @commands = commands
+      @sources = sources
+      @hooks_by_event = hooks
     end
 
     # Executes the plugins.rb file
@@ -146,11 +254,27 @@ module Bundler
       # done to avoid conflicts
       path = index.plugin_path(name)
 
+      add_to_load_path(index.load_paths(name))
+
       load path.join(PLUGIN_FILE_NAME)
+
+      @loaded_plugin_names << name
+    rescue => e
+      Bundler.ui.error "Failed loading plugin #{name}: #{e.message}"
+      raise
+    end
+
+    def add_to_load_path(load_paths)
+      if insert_index = Bundler.rubygems.load_path_insert_index
+        $LOAD_PATH.insert(insert_index, *load_paths)
+      else
+        $LOAD_PATH.unshift(*load_paths)
+      end
     end
 
     class << self
-      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!
+      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!,
+        :add_to_load_path
     end
   end
 end