bundler 1.12.6 → 1.13.0.pre.1

data/lib/bundler/fetcher/downloader.rb

@@ -58,7 +58,7 @@ module Bundler
           raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
           "connection and try again."
         else
-          raise HTTPError, "Network error while fetching #{uri}"
+          raise HTTPError, "Network error while fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
         end
       end
     end

data/lib/bundler/friendly_errors.rb

@@ -63,7 +63,7 @@ module Bundler
 
         - What happened instead?
 
-          Instead, what actually happened was...
+          Instead, what happened was...
 
 
         Error details

data/lib/bundler/index.rb

@@ -21,15 +21,14 @@ module Bundler
       @sources = []
       @cache = {}
       @specs = Hash.new {|h, k| h[k] = {} }
-      @all_specs = Hash.new {|h, k| h[k] = [] }
+      @all_specs = Hash.new {|h, k| h[k] = EMPTY_SEARCH }
     end
 
     def initialize_copy(o)
-      super
-      @sources = @sources.dup
+      @sources = o.sources.dup
       @cache = {}
       @specs = Hash.new {|h, k| h[k] = {} }
-      @all_specs = Hash.new {|h, k| h[k] = [] }
+      @all_specs = Hash.new {|h, k| h[k] = EMPTY_SEARCH }
 
       o.specs.each do |name, hash|
         @specs[name] = hash.dup
@@ -49,7 +48,7 @@ module Bundler
     end
 
     def search_all(name)
-      all_matches = @all_specs[name] + local_search(name)
+      all_matches = local_search(name) + @all_specs[name]
       @sources.each do |source|
         all_matches.concat(source.search_all(name))
       end
@@ -60,19 +59,18 @@ module Bundler
     # about, returning all of the results.
     def search(query, base = nil)
       results = local_search(query, base)
-      seen = Set.new(results.map {|spec| [spec.name, spec.version, spec.platform] })
+      seen = results.map(&:full_name).to_set
 
       @sources.each do |source|
         source.search(query, base).each do |spec|
-          lookup = [spec.name, spec.version, spec.platform]
-          unless seen.include?(lookup)
-            results << spec
-            seen << lookup
-          end
+          results << spec if seen.add?(spec.full_name)
         end
       end
 
-      results.sort_by {|s| [s.version, s.platform.to_s == RUBY ? NULL : s.platform.to_s] }
+      results.sort_by do |s|
+        platform_string = s.platform.to_s
+        [s.version, platform_string == RUBY ? NULL : platform_string]
+      end
     end
 
     def local_search(query, base = nil)
@@ -90,14 +88,15 @@ module Bundler
 
     def <<(spec)
       @specs[spec.name][spec.full_name] = spec
-
       spec
     end
 
     def each(&blk)
+      return enum_for(:each) unless blk
       specs.values.each do |spec_sets|
         spec_sets.values.each(&blk)
       end
+      sources.each {|s| s.each(&blk) }
     end
 
     # returns a list of the dependencies
@@ -109,17 +108,17 @@ module Bundler
 
     def dependency_names
       names = []
-      each {|s| names.push(*s.dependencies.map(&:name)) }
+      each {|s| names.concat(s.dependencies.map(&:name)) }
       names.uniq
     end
 
     def use(other, override_dupes = false)
       return unless other
       other.each do |s|
-        if (dupes = search_by_spec(s)) && dupes.any?
-          @all_specs[s.name] = [s] + dupes
+        if (dupes = search_by_spec(s)) && !dupes.empty?
+          # safe to << since it's a new array when it has contents
+          @all_specs[s.name] = dupes << s
           next unless override_dupes
-          self << s
         end
         self << s
       end
@@ -135,10 +134,16 @@ module Bundler
     def ==(other)
       all? do |spec|
         other_spec = other[spec].first
-        other_spec && (spec.dependencies & other_spec.dependencies).empty? && spec.source == other_spec.source
+        other_spec && dependencies_eql?(spec, other_spec) && spec.source == other_spec.source
       end
     end
 
+    def dependencies_eql?(spec, other_spec)
+      deps       = spec.dependencies.select {|d| d.type != :development }
+      other_deps = other_spec.dependencies.select {|d| d.type != :development }
+      Set.new(deps) == Set.new(other_deps)
+    end
+
     def add_source(index)
       raise ArgumentError, "Source must be an index, not #{index.class}" unless index.is_a?(Index)
       @sources << index
@@ -154,8 +159,10 @@ module Bundler
     def search_by_dependency(dependency, base = nil)
       @cache[base || false] ||= {}
       @cache[base || false][dependency] ||= begin
-        specs = specs_by_name(dependency.name) + (base || [])
+        specs = specs_by_name(dependency.name)
+        specs += base if base
         found = specs.select do |spec|
+          next true if spec.source.is_a?(Source::Gemspec)
           if base # allow all platforms when searching from a lockfile
             dependency.matches_spec?(spec)
           else
@@ -174,25 +181,11 @@ module Bundler
       end
     end
 
+    EMPTY_SEARCH = [].freeze
+
     def search_by_spec(spec)
       spec = @specs[spec.name][spec.full_name]
-      spec ? [spec] : []
-    end
-
-    if RUBY_VERSION < "1.9"
-      def same_version?(a, b)
-        regex = /^(.*?)(?:\.0)*$/
-        a.to_s[regex, 1] == b.to_s[regex, 1]
-      end
-    else
-      def same_version?(a, b)
-        a == b
-      end
-    end
-
-    def spec_satisfies_dependency?(spec, dep)
-      return false unless dep.name == spec.name
-      dep.requirement.satisfied_by?(spec.version)
+      spec ? [spec] : EMPTY_SEARCH
     end
   end
 end

data/lib/bundler/inline.rb

@@ -41,6 +41,7 @@ def gemfile(install = false, options = {}, &gemfile)
   end
   ENV["BUNDLE_GEMFILE"] ||= "Gemfile"
 
+  Bundler::Plugin.gemfile_install(&gemfile) if Bundler.settings[:plugins]
   builder = Bundler::Dsl.new
   builder.instance_eval(&gemfile)
 
@@ -48,8 +49,17 @@ def gemfile(install = false, options = {}, &gemfile)
   def definition.lock(*); end
   definition.validate_ruby!
 
-  if install
-    Bundler.ui = ui
+  missing_specs = proc do
+    begin
+      !definition.missing_specs.empty?
+    rescue Bundler::GemNotFound, Bundler::GitError
+      definition.instance_variable_set(:@index, nil)
+      true
+    end
+  end
+
+  Bundler.ui = ui if install
+  if install || missing_specs.call
     Bundler::Installer.install(Bundler.root, definition, :system => true)
     Bundler::Installer.post_install_messages.each do |name, message|
       Bundler.ui.info "Post-install message from #{name}:\n#{message}"
@@ -58,7 +68,7 @@ def gemfile(install = false, options = {}, &gemfile)
 
   runtime = Bundler::Runtime.new(nil, definition)
   runtime.setup.require
-
+ensure
   bundler_module = class << Bundler; self; end
-  bundler_module.send(:define_method, :root, old_root)
+  bundler_module.send(:define_method, :root, old_root) if old_root
 end

data/lib/bundler/installer.rb

@@ -68,6 +68,7 @@ module Bundler
       end
 
       resolve_if_need(options)
+      ensure_specs_are_compatible!
       install(options)
 
       lock unless Bundler.settings[:frozen]
@@ -146,9 +147,9 @@ module Bundler
   private
 
     # the order that the resolver provides is significant, since
-    # dependencies might actually affect the installation of a gem.
+    # dependencies might affect the installation of a gem.
     # that said, it's a rare situation (other than rake), and parallel
-    # installation is just SO MUCH FASTER. so we let people opt in.
+    # installation is SO MUCH FASTER. so we let people opt in.
     def install(options)
       force = options["force"]
       jobs = 1
@@ -156,6 +157,24 @@ module Bundler
       install_in_parallel jobs, options[:standalone], force
     end
 
+    def ensure_specs_are_compatible!
+      system_ruby = Bundler::RubyVersion.system
+      rubygems_version = Gem::Version.create(Gem::VERSION)
+      specs.each do |spec|
+        if required_ruby_version = spec.required_ruby_version
+          unless required_ruby_version.satisfied_by?(system_ruby.gem_version)
+            raise InstallError, "#{spec.full_name} requires ruby version #{required_ruby_version}, " \
+              "which is incompatible with the current version, #{system_ruby}"
+          end
+        end
+        next unless required_rubygems_version = spec.required_rubygems_version
+        unless required_rubygems_version.satisfied_by?(rubygems_version)
+          raise InstallError, "#{spec.full_name} requires rubygems version #{required_rubygems_version}, " \
+            "which is incompatible with the current version, #{rubygems_version}"
+        end
+      end
+    end
+
     def can_install_in_parallel?
       if Bundler.rubygems.provides?(">= 2.1.0")
         true
@@ -185,7 +204,7 @@ module Bundler
         local = Bundler.ui.silence do
           begin
             tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
-            true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
+            true unless tmpdef.new_platform? || tmpdef.missing_dependencies.any?
           rescue BundlerError
           end
         end

data/lib/bundler/installer/gem_installer.rb

@@ -39,7 +39,7 @@ module Bundler
     end
 
     def handle_exception(e)
-      # if install hook failed or gem signature is bad, just die
+      # Die if install hook failed or gem signature is bad.
       raise e if e.is_a?(Bundler::InstallHookError) || e.is_a?(Bundler::SecurityError)
       # other failure, likely a native extension build failure
       Bundler.ui.info ""

data/lib/bundler/installer/standalone.rb

@@ -38,7 +38,7 @@ module Bundler
     end
 
     def bundler_path
-      File.join(Bundler.settings[:path], "bundler")
+      Bundler.root.join(Bundler.settings[:path], "bundler")
     end
 
     def gem_path(path, spec)

data/lib/bundler/mirror.rb

@@ -32,10 +32,10 @@ module Bundler
 
       def parse(key, value)
         config = MirrorConfig.new(key, value)
-        if config.all?
-          mirror = @all
+        mirror = if config.all?
+          @all
         else
-          mirror = (@mirrors[config.uri] = @mirrors[config.uri] || Mirror.new)
+          (@mirrors[config.uri] = @mirrors[config.uri] || Mirror.new)
         end
         config.update_mirror(mirror)
       end
@@ -177,7 +177,7 @@ module Bundler
   #   a given mirror.
   #
   # One mirror may correspond to many different addresses, both
-  #   because of it having many dns entries or just because
+  #   because of it having many dns entries or because
   #   the network interface is both ipv4 and ipv5
   class MirrorSockets
     def initialize(mirror)

data/lib/bundler/plugin.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Plugin
+    autoload :API,        "bundler/plugin/api"
+    autoload :DSL,        "bundler/plugin/dsl"
+    autoload :Index,      "bundler/plugin/index"
+    autoload :Installer,  "bundler/plugin/installer"
+    autoload :SourceList, "bundler/plugin/source_list"
+
+    class MalformattedPlugin < PluginError; end
+    class UndefinedCommandError < PluginError; end
+
+    PLUGIN_FILE_NAME = "plugins.rb".freeze
+
+  module_function
+
+    @commands = {}
+
+    # 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
+    def install(names, options)
+      paths = Installer.new.install(names, options)
+
+      save_plugins paths
+    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  ")}"
+    end
+
+    # Evaluates the Gemfile with a limited DSL and installs the plugins
+    # specified by plugin method
+    #
+    # @param [Pathname] gemfile path
+    def gemfile_install(gemfile = nil, &inline)
+      if block_given?
+        builder = DSL.new
+        builder.instance_eval(&inline)
+        definition = builder.to_definition(nil, true)
+      else
+        definition = DSL.evaluate(gemfile, nil, {})
+      end
+      return unless definition.dependencies.any?
+
+      plugins = Installer.new.install_definition(definition)
+
+      save_plugins plugins
+    end
+
+    # The index object used to store the details about the plugin
+    def index
+      @index ||= Index.new
+    end
+
+    # The directory root to all plugin related data
+    def root
+      @root ||= Bundler.user_bundle_path.join("plugin")
+    end
+
+    # The cache directory for plugin stuffs
+    def cache
+      @cache ||= root.join("cache")
+    end
+
+    # To be called via the API to register to handle a command
+    def add_command(command, cls)
+      @commands[command] = cls
+    end
+
+    # Checks if any plugins handles the command
+    def command?(command)
+      !index.command_plugin(command).nil?
+    end
+
+    # 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
+
+      load_plugin index.command_plugin(command) unless @commands.key? command
+
+      @commands[command].new.exec(command, args)
+    end
+
+    # currently only intended for specs
+    #
+    # @return [String, nil] installed path
+    def installed?(plugin)
+      Index.new.installed?(plugin)
+    end
+
+    # 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}"
+      end
+    end
+
+    # Checks if the gem is good to be a plugin
+    #
+    # 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
+    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?
+    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)
+      commands = @commands
+
+      @commands = {}
+
+      begin
+        load path.join(PLUGIN_FILE_NAME), true
+      rescue StandardError => e
+        raise MalformattedPlugin, "#{e.class}: #{e.message}"
+      end
+
+      index.register_plugin name, path.to_s, @commands.keys
+    ensure
+      @commands = commands
+    end
+
+    # Executes the plugins.rb file
+    #
+    # @param [String] name of the plugin
+    def load_plugin(name)
+      # Need to ensure before this that plugin root where the rest of gems
+      # are installed to be on load path to support plugin deps. Currently not
+      # done to avoid conflicts
+      path = index.plugin_path(name)
+
+      load path.join(PLUGIN_FILE_NAME)
+    end
+
+    class << self
+      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!
+    end
+  end
+end