bundler 1.1.5 → 1.2.0.pre

data/lib/bundler/definition.rb

@@ -5,7 +5,7 @@ module Bundler
   class Definition
     include GemHelpers
 
-    attr_reader :dependencies, :platforms, :sources
+    attr_reader :dependencies, :platforms, :sources, :ruby_version
 
     def self.build(gemfile, lockfile, unlock)
       unlock ||= {}
@@ -30,13 +30,14 @@ module Bundler
       specs, then we can try to resolve locally.
 =end
 
-    def initialize(lockfile, dependencies, sources, unlock)
+    def initialize(lockfile, dependencies, sources, unlock, ruby_version = "")
       @unlocking = unlock == true || !unlock.empty?
 
       @dependencies, @sources, @unlock = dependencies, sources, unlock
       @remote            = false
       @specs             = nil
       @lockfile_contents = ""
+      @ruby_version      = ruby_version
 
       if lockfile && File.exists?(lockfile)
         @lockfile_contents = Bundler.read_file(lockfile)
@@ -68,28 +69,13 @@ module Bundler
       @new_platform = !@platforms.include?(current_platform)
       @platforms |= [current_platform]
 
-      @path_changes = @sources.any? do |source|
-        next unless source.instance_of?(Source::Path)
-
-        locked = @locked_sources.find do |ls|
-          ls.class == source.class && ls.path == source.path
-        end
-
-        if locked
-          unlocking = locked.specs.any? do |spec|
-            @locked_specs.any? do |locked_spec|
-              locked_spec.source != locked
-            end
-          end
-        end
-
-        !locked || unlocking || source.specs != locked.specs
-      end
+      @path_changes = converge_paths
       eager_unlock = expand_dependencies(@unlock[:gems])
       @unlock[:gems] = @locked_specs.for(eager_unlock).map { |s| s.name }
 
       @source_changes = converge_sources
       @dependency_changes = converge_dependencies
+      @local_changes = converge_locals
 
       fixup_dependency_types!
     end
@@ -174,7 +160,7 @@ module Bundler
 
     def resolve
       @resolve ||= begin
-        if Bundler.settings[:frozen] || (!@unlocking && !@source_changes && !@dependency_changes && !@new_platform && !@path_changes)
+        if Bundler.settings[:frozen] || (!@unlocking && nothing_changed?)
           @locked_specs
         else
           last_resolve = converge_locked_specs
@@ -350,8 +336,32 @@ module Bundler
       raise ProductionError, msg if added.any? || deleted.any? || changed.any?
     end
 
+    def validate_ruby!
+      return unless ruby_version
+
+      system_ruby_version = Bundler::SystemRubyVersion.new
+      if diff = ruby_version.diff(system_ruby_version)
+        problem, expected, actual = diff
+
+        msg = case problem
+        when :engine
+          "Your Ruby engine is #{actual}, but your Gemfile specified #{expected}"
+        when :version
+          "Your Ruby version is #{actual}, but your Gemfile specified #{expected}"
+        when :engine_version
+          "Your #{system_ruby_version.engine} version is #{actual}, but your Gemfile specified #{ruby_version.engine} #{expected}"
+        end
+
+        raise RubyVersionMismatch, msg
+      end
+    end
+
   private
 
+    def nothing_changed?
+      !@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes
+    end
+
     def pretty_dep(dep, source = false)
       msg  = "#{dep.name}"
       msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default
@@ -359,6 +369,52 @@ module Bundler
       msg
     end
 
+    # Check if the specs of the given source changed
+    # according to the locked source. A block should be
+    # in order to specify how the locked version of
+    # the source should be found.
+    def specs_changed?(source, &block)
+      locked = @locked_sources.find(&block)
+
+      if locked
+        unlocking = locked.specs.any? do |spec|
+          @locked_specs.any? do |locked_spec|
+            locked_spec.source != locked
+          end
+        end
+      end
+
+      !locked || unlocking || source.specs != locked.specs
+    end
+
+    # Get all locals and override their matching sources.
+    # Return true if any of the locals changed (for example,
+    # they point to a new revision) or depend on new specs.
+    def converge_locals
+      locals = []
+
+      Bundler.settings.local_overrides.map do |k,v|
+        spec   = @dependencies.find { |s| s.name == k }
+        source = spec && spec.source
+        if source && source.respond_to?(:local_override!)
+          locals << [ source, source.local_override!(v) ]
+        end
+      end
+
+      locals.any? do |source, changed|
+        changed || specs_changed?(source) { |o| source.class === o.class && source.uri == o.uri }
+      end
+    end
+
+    def converge_paths
+      @sources.any? do |source|
+        next unless source.instance_of?(Source::Path)
+        specs_changed?(source) do |ls|
+          ls.class == source.class && ls.path == source.path
+        end
+      end
+    end
+
     def converge_sources
       changes = false
 

data/lib/bundler/deployment.rb

@@ -41,16 +41,16 @@ module Bundler
           bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), 'bundle'))
           bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
           bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
-          app_path = context.fetch(:latest_release)
-          if app_path.to_s.empty?
+          current_release = context.fetch(:current_release)
+          if current_release.to_s.empty?
             raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
           end
-          args = ["--gemfile #{File.join(app_path, bundle_gemfile)}"]
+          args = ["--gemfile #{File.join(current_release, bundle_gemfile)}"]
           args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
           args << bundle_flags.to_s
           args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
 
-          run "cd #{app_path} && #{bundle_cmd} install #{args.join(' ')}"
+          run "cd #{current_release} && #{bundle_cmd} install #{args.join(' ')}"
         end
       end
     end

data/lib/bundler/dsl.rb

@@ -4,7 +4,7 @@ module Bundler
   class Dsl
     def self.evaluate(gemfile, lockfile, unlock)
       builder = new
-      builder.instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
+      builder.eval_gemfile(gemfile)
       builder.to_definition(lockfile, unlock)
     rescue ScriptError, RegexpError, NameError, ArgumentError => e
       e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
@@ -15,6 +15,8 @@ module Bundler
 
     VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
 
+    attr_accessor :dependencies
+
     def initialize
       @rubygems_source = Source::Rubygems.new
       @source          = nil
@@ -23,9 +25,15 @@ module Bundler
       @groups          = []
       @platforms       = []
       @env             = nil
+      @ruby_version    = nil
     end
 
-    attr_accessor :dependencies
+    def eval_gemfile(gemfile)
+      instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
+    rescue SyntaxError => e
+      bt = e.message.split("\n")[1..-1]
+      raise GemfileError, ["Gemfile syntax error:", *bt].join("\n")
+    end
 
     def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
@@ -59,7 +67,6 @@ module Bundler
       options = Hash === args.last ? args.pop : {}
       version = args || [">= 0"]
 
-      _deprecated_options(options)
       _normalize_options(name, version, options)
 
       dep = Dependency.new(name, version, options)
@@ -86,7 +93,7 @@ module Bundler
           else
             raise DslError, "You cannot specify the same gem twice coming from different sources. You " \
                             "specified that #{dep.name} (#{dep.requirement}) should come from " \
-                            "#{current.source || 'an unspecified source'} and #{dep.source}"
+                            "#{current.source || 'an unspecfied source'} and #{dep.source}"
           end
         end
       end
@@ -138,7 +145,7 @@ module Bundler
 
     def to_definition(lockfile, unlock)
       @sources << @rubygems_source unless @sources.include?(@rubygems_source)
-      Definition.new(lockfile, @dependencies, @sources, unlock)
+      Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version)
     end
 
     def group(*args, &blk)
@@ -163,25 +170,18 @@ module Bundler
       @env = old
     end
 
-    def ruby(*args)
-      msg = "Ignoring `ruby` directive. This is a feature added to Bundler 1.2.0 \n" \
-            "and higher. Please upgrade if you would like to use it. \n\n"
-      Bundler.ui.warn msg
-    end
+    def ruby(ruby_version, options = {})
+      raise GemfileError, "Please define :engine_version" if options[:engine] && options[:engine_version].nil?
+      raise GemfileError, "Please define :engine" if options[:engine_version] && options[:engine].nil?
 
-    # Deprecated methods
+      raise GemfileError, "ruby_version must match the :engine_version for MRI" if options[:engine] == "ruby" && options[:engine_version] && ruby_version != options[:engine_version]
+      @ruby_version = RubyVersion.new(ruby_version, options[:engine], options[:engine_version])
+    end
 
-    def self.deprecate(name, replacement = nil)
-      define_method(name) do |*|
-        message = "'#{name}' has been removed from the Gemfile DSL, "
-        if replacement
-          message << "and has been replaced with '#{replacement}'."
-        else
-          message << "and is no longer supported."
-        end
-        message << "\nSee the README for more information on upgrading from Bundler 0.8."
-        raise DeprecatedError, message
-      end
+    def method_missing(name, *args)
+      location = caller[0].split(':')[0..1].join(':')
+      raise GemfileError, "Undefined local variable or method `#{name}' for Gemfile\n" \
+        "        from #{location}"
     end
 
   private
@@ -200,7 +200,8 @@ module Bundler
     def _normalize_options(name, version, opts)
       _normalize_hash(opts)
 
-      invalid_keys = opts.keys - %w(group groups git github path name branch ref tag require submodules platform platforms type)
+      valid_keys = %w(group groups git github path name branch ref tag require submodules platform platforms type)
+      invalid_keys = opts.keys - valid_keys
       if invalid_keys.any?
         plural = invalid_keys.size > 1
         message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
@@ -209,6 +210,8 @@ module Bundler
         else
           message << "as an option for gem '#{name}', but it is invalid."
         end
+
+        message << " Valid options are: #{valid_keys.join(", ")}"
         raise InvalidOption, message
       end
 
@@ -249,7 +252,5 @@ module Bundler
       opts["group"]     = groups
     end
 
-    def _deprecated_options(options)
-    end
   end
 end

data/lib/bundler/fetcher.rb

@@ -1,5 +1,5 @@
 require 'uri'
-require 'bundler/vendored_persistent'
+require 'net/http/persistent'
 
 module Bundler
   # Handles all the fetching with the rubygems server
@@ -104,16 +104,6 @@ module Bundler
       end
 
       index
-    rescue LoadError => e
-      if e.message.include?("cannot load such file -- openssl")
-        raise InstallError,
-          "\nCould not load OpenSSL." \
-          "\nYou must recompile Ruby with OpenSSL support or change the sources in your" \
-          "\nGemfile from 'https' to 'http'. Instructions for compiling with OpenSSL" \
-          "\nusing RVM are available at rvm.io/packages/openssl."
-      else
-        raise e
-      end
     end
 
     # fetch index
@@ -185,7 +175,8 @@ module Bundler
               raise GemspecError, %{Unfortunately, the gem #{s[:name]} (#{s[:number]}) } +
                 %{has an invalid gemspec. As a result, Bundler cannot install this Gemfile. } +
                 %{Please ask the gem author to yank the bad version to fix this issue. For } +
-                %{more information, see http://bit.ly/syck-defaultkey.}
+                %{more information, see http://bit.ly/syck-defaultkey. For a temporary } +
+                %{workaround try using the --full-index option.}
             else
               raise e
             end
@@ -217,7 +208,7 @@ module Bundler
           Bundler.ui.debug "Could not fetch prerelease specs from #{strip_user_pass_from_uri(@remote_uri)}"
         end
       rescue Gem::RemoteFetcher::FetchError
-        raise HTTPError, "Could not reach #{strip_user_pass_from_uri(@remote_uri)}"
+        raise Bundler::HTTPError, "Could not reach #{strip_user_pass_from_uri(@remote_uri)}"
       end
 
       return spec_list

data/lib/bundler/gem_helper.rb

@@ -6,16 +6,26 @@ module Bundler
   class GemHelper
     include Rake::DSL if defined? Rake::DSL
 
-    def self.install_tasks(opts = {})
-      dir = opts[:dir] || Dir.pwd
-      self.new(dir, opts[:name]).install
+    class << self
+      # set when install'd.
+      attr_accessor :instance
+
+      def install_tasks(opts = {})
+        new(opts[:dir], opts[:name]).install
+      end
+
+      def gemspec(&block)
+        gemspec = instance.gemspec
+        block.call(gemspec) if block
+        gemspec
+      end
     end
 
     attr_reader :spec_path, :base, :gemspec
 
-    def initialize(base, name = nil)
+    def initialize(base = nil, name = nil)
       Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
-      @base = base
+      @base = (base ||= Dir.pwd)
       gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "{,*}.gemspec")]
       raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
       @spec_path = gemspecs.first
@@ -37,6 +47,8 @@ module Bundler
       task 'release' do
         release_gem
       end
+
+      GemHelper.instance = self
     end
 
     def build_gem

data/lib/bundler/graph.rb

@@ -40,9 +40,9 @@ module Bundler
             @relations[dependency.name] += child_dependencies.map(&:name).to_set
             tmp += child_dependencies
 
-            @node_options[dependency.name] = {:label => _make_label(dependency, :node)}
+            @node_options[dependency.name] = _make_label(dependency, :node)
             child_dependencies.each do |c_dependency|
-              @edge_options["#{dependency.name}_#{c_dependency.name}"] = {:label => _make_label(c_dependency, :edge)}
+              @edge_options["#{dependency.name}_#{c_dependency.name}"] = _make_label(c_dependency, :edge)
             end
           end
           parent_dependencies = tmp
@@ -58,8 +58,8 @@ module Bundler
           relations[group.to_s].add(dependency)
           @relations[group.to_s].add(dependency.name)
 
-          @node_options[group.to_s] ||= {:label => _make_label(group, :node)}
-          @edge_options["#{group}_#{dependency.name}"] = {:label => _make_label(dependency, :edge)}
+          @node_options[group.to_s] ||= _make_label(group, :node)
+          @edge_options["#{group}_#{dependency.name}"] = _make_label(dependency, :edge)
         end
       end
       @groups = relations.keys
@@ -84,7 +84,7 @@ module Bundler
       else
         raise ArgumentError, "2nd argument is invalid"
       end
-      label
+      label.nil? ? {} : { :label => label }
     end
 
     class GraphVizClient
@@ -109,7 +109,7 @@ module Bundler
 
       def run
         @groups.each do |group|
-          g.add_node(
+          g.add_nodes(
             group,
             {:style     => 'filled',
              :fillcolor => '#B9B9D5',
@@ -121,11 +121,11 @@ module Bundler
         @relations.each do |parent, children|
           children.each do |child|
             if @groups.include?(parent)
-              g.add_node(child, {:style => 'filled', :fillcolor => '#B9B9D5'}.merge(@node_options[child]))
-              g.add_edge(parent, child, {:constraint => false}.merge(@edge_options["#{parent}_#{child}"]))
+              g.add_nodes(child, {:style => 'filled', :fillcolor => '#B9B9D5'}.merge(@node_options[child]))
+              g.add_edges(parent, child, {:constraint => false}.merge(@edge_options["#{parent}_#{child}"]))
             else
-              g.add_node(child, @node_options[child])
-              g.add_edge(parent, child, @edge_options["#{parent}_#{child}"])
+              g.add_nodes(child, @node_options[child])
+              g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
             end
           end
         end

data/lib/bundler/installer.rb

@@ -7,12 +7,45 @@ module Bundler
       attr_accessor :post_install_messages
     end
 
+    # Begins the installation process for Bundler.
+    # For more information see the #run method on this class.
     def self.install(root, definition, options = {})
       installer = new(root, definition)
       installer.run(options)
       installer
     end
 
+    # Runs the install procedures for a specific Gemfile.
+    #
+    # Firstly, this method will check to see if Bundler.bundle_path exists 
+    # and if not then will create it. This is usually the location of gems
+    # on the system, be it RVM or at a system path.
+    # 
+    # Secondly, it checks if Bundler has been configured to be "frozen"
+    # Frozen ensures that the Gemfile and the Gemfile.lock file are matching.
+    # This stops a situation where a developer may update the Gemfile but may not run
+    # `bundle install`, which leads to the Gemfile.lock file not being correctly updated.
+    # If this file is not correctly updated then any other developer running
+    # `bundle install` will potentially not install the correct gems.
+    #
+    # Thirdly, Bundler checks if there are any dependencies specified in the Gemfile using 
+    # Bundler::Environment#dependencies. If there are no dependencies specified then
+    # Bundler returns a warning message stating so and this method returns.
+    #
+    # Fourthly, Bundler checks if the default lockfile (Gemfile.lock) exists, and if so
+    # then proceeds to set up a defintion based on the default gemfile (Gemfile) and the
+    # default lock file (Gemfile.lock). However, this is not the case if the platform is different
+    # to that which is specified in Gemfile.lock, or if there are any missing specs for the gems.
+    #
+    # Fifthly, Bundler resolves the dependencies either through a cache of gems or by remote.
+    # This then leads into the gems being installed, along with stubs for their executables,
+    # but only if the --binstubs option has been passed or Bundler.options[:bin] has been set
+    # earlier. 
+    # 
+    # Sixthly, a new Gemfile.lock is created from the installed gems to ensure that the next time
+    # that a user runs `bundle install` they will receive any updates from this process.
+    # 
+    # Finally: TODO add documentation for how the standalone process works.
     def run(options)
       # Create the BUNDLE_PATH directory
       begin
@@ -88,10 +121,9 @@ module Bundler
       # other failure, likely a native extension build failure
       Bundler.ui.info ""
       Bundler.ui.warn "#{e.class}: #{e.message}"
-      msg = "An error occured while installing #{spec.name} (#{spec.version}),"
+      msg = "An error occurred while installing #{spec.name} (#{spec.version}),"
       msg << " and Bundler cannot continue.\nMake sure that `gem install"
       msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
-      Bundler.ui.debug e.backtrace.join("\n")
       raise Bundler::InstallError, msg
     end