Warn if bundler version older than in lockfile

lib/bundler.rb

@@ -153,10 +153,13 @@ def definition(unlock = nil)
       end
     end
 
-    def locked_gems
-      @locked_gems ||= begin
+    def lock
+      return @lock if defined?(@lock)
+      if Bundler.default_lockfile.exist?
         lock = Bundler.read_file(Bundler.default_lockfile)
-        LockfileParser.new(lock)
+        @lock = LockfileParser.new(lock)
+      else
+        @lock = nil
       end
     end
 

lib/bundler/cli.rb

@@ -248,6 +248,7 @@ def install
       Bundler.ui.level            = "warn" if opts[:quiet]
       Bundler::Fetcher.disable_endpoint = opts["full-index"]
       Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? '1' : nil
+      locking_bundler_version = Bundler.lock.bundler_version if Bundler.lock
 
       # rubygems plugins sometimes hook into the gem install process
       Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
@@ -274,6 +275,12 @@ def install
       end
 
       clean if Bundler.settings[:clean] && Bundler.settings[:path]
+
+      if locking_bundler_version && locking_bundler_version > Gem::Version.new(Bundler::VERSION)
+        Bundler.ui.warn "You're using an older version of Bundler (#{Bundler::VERSION}) than " \
+          "the one specified in your Gemfile (#{locking_bundler_version})!" \
+          " Please upgrade by running `gem install bundler`."
+      end
     rescue GemNotFound, VersionConflict => e
       if opts[:local] && Bundler.app_cache.exist?
         Bundler.ui.warn "Some gems seem to be missing from your vendor/cache directory."
@@ -303,25 +310,19 @@ def install
       "Only output warnings and errors."
     method_option "full-index", :type => :boolean, :banner =>
         "Use the rubygems modern index instead of the API endpoint"
-    method_option "all", :type => :boolean, :banner =>
-        "updates all gems"
     def update(*gems)
       sources = Array(options[:source])
       Bundler.ui.level = "warn" if options[:quiet]
 
       if gems.empty? && !options[:force]
         Bundler.ui.error "Run `bundle update GEM` to update a specific gem. Run `bundle update --force` if you really want to update all gems."
         exit 1
-      end
-
-      if !options[:all] && gems.empty? && sources.empty?
-        return Bundler.ui.info("Are you sure you want to update every single gem in your bundle?!\n\nIf yes, run bundle update --all.\nIf you want to update an individual gem, run bundle update <gem_name>.\nIf not, have a good day!")
-      elsif options[:all] && gems.empty? && sources.empty?
+      elsif options[:force] && gems.empty? && sources.empty?
         # We're doing a full update
         Bundler.definition(true)
       else
         # cycle through the requested gems, just to make sure they exist
-        names = Bundler.locked_gems.specs.map{ |s| s.name }
+        names = Bundler.lock.specs.map{ |s| s.name }
         gems.each do |g|
           next if names.include?(g)
           raise GemNotFound, not_found_message(g, names)

lib/bundler/definition.rb

@@ -300,6 +300,10 @@ def to_lock
           handled << dep.name
       end
 
+      out << "\n"
+      out << "BUNDLER\n"
+      out << "  #{Bundler::VERSION}"
+
       out
     end
 

lib/bundler/lockfile_parser.rb

@@ -12,10 +12,11 @@
 
 module Bundler
   class LockfileParser
-    attr_reader :sources, :dependencies, :specs, :platforms
+    attr_reader :sources, :dependencies, :specs, :platforms, :bundler_version
 
     DEPENDENCIES = "DEPENDENCIES"
     PLATFORMS    = "PLATFORMS"
+    BUNDLER      = "BUNDLER"
     GIT          = "GIT"
     GEM          = "GEM"
     PATH         = "PATH"
@@ -39,6 +40,8 @@ def initialize(lockfile)
           @state = :dependency
         elsif line == PLATFORMS
           @state = :platform
+        elsif line == BUNDLER
+          @state = :bundler
         else
           send("parse_#{@state}", line)
         end
@@ -140,5 +143,11 @@ def parse_platform(line)
       end
     end
 
+    def parse_bundler(line)
+      if line =~ /^  (.*)$/
+        @bundler_version = Gem::Version.new($1)
+      end
+    end
+
   end
 end

lib/bundler/version.rb

@@ -2,5 +2,5 @@ module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.4.0.rc.1" unless defined?(::Bundler::VERSION)
+  VERSION = "1.4.0.rc.1" unless defined?(Bundler::VERSION)
 end

spec/install/git_spec.rb

@@ -907,7 +907,7 @@
         end
       G
 
-      bundle "update", :env => {"PATH" => ""}
+      bundle "update --force", :env => {"PATH" => ""}
       expect(out).to include("You need to install git to be able to use gems from git repositories. For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git")
     end
   end

spec/install/post_bundle_message_spec.rb

@@ -16,7 +16,7 @@
   let(:bundle_show_message)       {"Use `bundle show [gemname]` to see where a bundled gem is installed."}
   let(:bundle_deployment_message) {"It was installed into ./vendor"}
   let(:bundle_complete_message)   {"Your bundle is complete!"}
-  let(:bundle_updated_message)    {"Your bundle is updated!"}
+  let(:bundle_updated_message)    {"Run `bundle update GEM` to update a specific gem. Run `bundle update --force` if you really want to update all gems."}
 
   describe "for fresh bundle install" do
     it "without any options" do
@@ -120,22 +120,22 @@
 
     it "with --without one group" do
       bundle :install, :without => :emo
-      bundle :update
       expect(out).to include("Gems in the group emo were not installed")
+      bundle :update
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without two groups" do
       bundle "install --without emo test"
-      bundle :update
       expect(out).to include("Gems in the groups emo and test were not installed")
+      bundle :update
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without more groups" do
       bundle "install --without emo obama test"
-      bundle :update
       expect(out).to include("Gems in the groups emo, obama and test were not installed")
+      bundle :update
       expect(out).to include(bundle_updated_message)
     end
   end

spec/lock/lockfile_spec.rb

@@ -761,6 +761,9 @@
 
       DEPENDENCIES
         omg!
+
+      BUNDLER
+        #{Bundler::VERSION}
     L
   end
 
@@ -775,17 +778,19 @@ def set_lockfile_mtime_to_known_value
         source "file://#{gem_repo2}"
         gem "rack"
       G
-      set_lockfile_mtime_to_known_value
+      #set_lockfile_mtime_to_known_value
     end
 
     it "generates Gemfile.lock with \\n line endings" do
+      set_lockfile_mtime_to_known_value
       expect(File.read(bundled_app("Gemfile.lock"))).not_to match("\r\n")
       should_be_installed "rack 1.0"
     end
 
     context "during updates" do
 
       it "preserves Gemfile.lock \\n line endings" do
+        set_lockfile_mtime_to_known_value
         update_repo2
 
         expect { bundle "update --force" }.to change { File.mtime(bundled_app('Gemfile.lock')) }
@@ -794,6 +799,7 @@ def set_lockfile_mtime_to_known_value
       end
 
       it "preserves Gemfile.lock \\n\\r line endings" do
+        set_lockfile_mtime_to_known_value
         update_repo2
         win_lock = File.read(bundled_app("Gemfile.lock")).gsub(/\n/, "\r\n")
         File.open(bundled_app("Gemfile.lock"), "wb"){|f| f.puts(win_lock) }
@@ -808,6 +814,7 @@ def set_lockfile_mtime_to_known_value
     context "when nothing changes" do
 
       it "preserves Gemfile.lock \\n line endings" do
+        File.mtime(bundled_app('Gemfile.lock'))
         expect { ruby <<-RUBY
                    require 'rubygems'
                    require 'bundler'
@@ -817,9 +824,9 @@ def set_lockfile_mtime_to_known_value
       end
 
       it "preserves Gemfile.lock \\n\\r line endings" do
+        mtime = File.mtime(bundled_app('Gemfile.lock'))
         win_lock = File.read(bundled_app("Gemfile.lock")).gsub(/\n/, "\r\n")
         File.open(bundled_app("Gemfile.lock"), "wb"){|f| f.puts(win_lock) }
-        set_lockfile_mtime_to_known_value
 
         expect { ruby <<-RUBY
                    require 'rubygems'

spec/other/platform_spec.rb

@@ -528,7 +528,7 @@ def should_be_patchlevel_incorrect(opts = {:exitstatus => true})
         build_gem "activesupport", "3.0"
       end
 
-      bundle :update, :exitstatus => true
+      bundle 'update --force', :exitstatus => true
       should_be_patchlevel_incorrect
     end
   end

spec/runtime/setup_spec.rb

@@ -374,7 +374,7 @@
         Dir["**/*"].each do |f|
           File.directory?(f) ?
             File.chmod(0555, f) :
-            File.chmod(0444, f)
+            File.chmod(0644, f)
         end
         should_be_installed "rack 1.0.0"
       ensure

spec/support/matchers.rb

@@ -71,6 +71,8 @@ def lockfile_should_be(expected)
       should_be_locked
       spaces = expected[/\A\s+/, 0] || ""
       expected.gsub!(/^#{spaces}/, '')
+      bundler_version = "\nBUNDLER\n  #{Bundler::VERSION}\n"
+      expected.gsub!(/\z/, bundler_version) unless expected.match(/BUNDLER/)
       expect(bundled_app("Gemfile.lock").read).to eq(expected)
     end
   end

spec/update/gems_spec.rb

@@ -3,7 +3,7 @@
 describe "bundle update" do
   it "prints a message" do
     bundle "update"
-    expect(out).to include("Are you sure you want to update every single gem in your bundle?!\n\nIf yes, run bundle update --all.\nIf you want to update an individual gem, run bundle update <gem_name>.\nIf not, have a good day!")
+    expect(out).to include("Run `bundle update GEM` to update a specific gem. Run `bundle update --force` if you really want to update all gems.")
   end
 
   it "does not print bundle was updated" do
@@ -12,7 +12,7 @@
   end
 end
 
-describe "bundle update --all" do
+describe "bundle update --force" do
   before :each do
     build_repo2
 

spec/warn-bundler-version-older-than-in-lockfile_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe "lockfile" do
+  include Bundler::GemHelpers
+
+  it "prints out the Bundler version that generated the lockfile" do
+
+    install_gemfile <<-G
+      source "file://#{gem_repo1}"
+
+      gem "rails"
+    G
+
+    lockfile_should_be <<-G
+      GEM
+        remote: file:#{gem_repo1}/
+        specs:
+          actionmailer (2.3.2)
+            activesupport (= 2.3.2)
+          actionpack (2.3.2)
+            activesupport (= 2.3.2)
+          activerecord (2.3.2)
+            activesupport (= 2.3.2)
+          activeresource (2.3.2)
+            activesupport (= 2.3.2)
+          activesupport (2.3.2)
+          rails (2.3.2)
+            actionmailer (= 2.3.2)
+            actionpack (= 2.3.2)
+            activerecord (= 2.3.2)
+            activeresource (= 2.3.2)
+            rake (= 10.0.2)
+          rake (10.0.2)
+
+      PLATFORMS
+        #{generic(Gem::Platform.local)}
+
+      DEPENDENCIES
+        rails
+
+      BUNDLER
+        #{Bundler::VERSION}
+    G
+
+  end
+
+  it "warns if the bundler version is older than the version that created" do
+    gemfile <<-G
+      source "file://#{gem_repo1}"
+
+      gem "rails"
+    G
+
+    lockfile <<-L
+      GEM
+        remote: file:#{gem_repo1}/
+        specs:
+          actionmailer (2.3.2)
+            activesupport (= 2.3.2)
+          actionpack (2.3.2)
+            activesupport (= 2.3.2)
+          activerecord (2.3.2)
+            activesupport (= 2.3.2)
+          activeresource (2.3.2)
+            activesupport (= 2.3.2)
+          activesupport (2.3.2)
+          rails (2.3.2)
+            actionmailer (= 2.3.2)
+            actionpack (= 2.3.2)
+            activerecord (= 2.3.2)
+            activeresource (= 2.3.2)
+            rake (= 10.0.2)
+          rake (10.0.2)
+
+      PLATFORMS
+        #{generic(Gem::Platform.local)}
+
+      DEPENDENCIES
+        rails
+
+      BUNDLER
+        100.1
+    L
+
+    bundle :install
+    expect(out).to include("You're using an older version of Bundler (#{
+      Bundler::VERSION}) than the one specified in your Gemfile (100.1)")
+  end
+
+end