bundler-prehistoric 1.6.2

data/spec/support/less_than_proc.rb

@@ -0,0 +1,14 @@
+class LessThanProc < Proc
+  attr_accessor :present
+
+  def self.with(present)
+    pv = Gem::Version.new(present.dup)
+    lt = self.new { |required| pv < Gem::Version.new(required) }
+    lt.present = present
+    return lt
+  end
+
+  def inspect
+    "\"=< #{present.to_s}\""
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,77 @@
+module Spec
+  module Matchers
+    RSpec::Matchers.define :have_dep do |*args|
+      dep = Bundler::Dependency.new(*args)
+
+      match do |actual|
+        actual.length == 1 && actual.all? { |d| d == dep }
+      end
+    end
+
+    RSpec::Matchers.define :have_gem do |*args|
+      match do |actual|
+        actual.length == args.length && actual.all? { |a| args.include?(a.full_name) }
+      end
+    end
+
+    RSpec::Matchers.define :have_rubyopts do |*args|
+      args = args.flatten
+      args = args.first.split(/\s+/) if args.size == 1
+
+      #failure_message_for_should "Expected RUBYOPT to have options #{args.join(" ")}. It was #{ENV["RUBYOPT"]}"
+
+      match do |actual|
+        actual = actual.split(/\s+/) if actual.is_a?(String)
+        args.all? {|arg| actual.include?(arg) } && actual.uniq.size == actual.size
+      end
+    end
+
+    def should_be_installed(*names)
+      opts = names.last.is_a?(Hash) ? names.pop : {}
+      groups = Array(opts[:groups])
+      groups << opts
+      names.each do |name|
+        name, version, platform = name.split(/\s+/)
+        version_const = name == 'bundler' ? 'Bundler::VERSION' : Spec::Builders.constantize(name)
+        run "require '#{name}.rb'; puts #{version_const}", *groups
+        actual_version, actual_platform = out.split(/\s+/)
+        expect(Gem::Version.new(actual_version)).to eq(Gem::Version.new(version))
+        expect(actual_platform).to eq(platform)
+      end
+    end
+
+    alias should_be_available should_be_installed
+
+    def should_not_be_installed(*names)
+      opts = names.last.is_a?(Hash) ? names.pop : {}
+      groups = Array(opts[:groups]) || []
+      names.each do |name|
+        name, version = name.split(/\s+/)
+        run <<-R, *(groups + [opts])
+          begin
+            require '#{name}'
+            puts #{Spec::Builders.constantize(name)}
+          rescue LoadError, NameError
+            puts "WIN"
+          end
+        R
+        if version.nil? || out == "WIN"
+          expect(out).to eq("WIN")
+        else
+          expect(Gem::Version.new(out)).not_to eq(Gem::Version.new(version))
+        end
+      end
+    end
+
+    def should_be_locked
+      expect(bundled_app("Gemfile.lock")).to exist
+    end
+
+    def lockfile_should_be(expected)
+      should_be_locked
+      spaces = expected[/\A\s+/, 0] || ""
+      expected.gsub!(/^#{spaces}/, '')
+      expect(bundled_app("Gemfile.lock").read).to eq(expected)
+    end
+  end
+end

data/spec/support/path.rb

@@ -0,0 +1,81 @@
+require 'pathname'
+
+module Spec
+  module Path
+    def root
+      @root ||= Pathname.new(File.expand_path("../../..", __FILE__))
+    end
+
+    def tmp(*path)
+      root.join("tmp", *path)
+    end
+
+    def home(*path)
+      tmp.join("home", *path)
+    end
+
+    def default_bundle_path(*path)
+      system_gem_path(*path)
+    end
+
+    def bundled_app(*path)
+      root = tmp.join("bundled_app")
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    alias bundled_app1 bundled_app
+
+    def bundled_app2(*path)
+      root = tmp.join("bundled_app2")
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    def vendored_gems(path = nil)
+      bundled_app(*["vendor/bundle", Gem.ruby_engine, Gem::ConfigMap[:ruby_version], path].compact)
+    end
+
+    def cached_gem(path)
+      bundled_app("vendor/cache/#{path}.gem")
+    end
+
+    def base_system_gems
+      tmp.join("gems/base")
+    end
+
+    def gem_repo1(*args)
+      tmp("gems/remote1", *args)
+    end
+
+    def gem_repo_missing(*args)
+      tmp("gems/missing", *args)
+    end
+
+    def gem_repo2(*args)
+      tmp("gems/remote2", *args)
+    end
+
+    def gem_repo3(*args)
+      tmp("gems/remote3", *args)
+    end
+
+    def security_repo(*args)
+      tmp("gems/security_repo", *args)
+    end
+
+    def system_gem_path(*path)
+      tmp("gems/system", *path)
+    end
+
+    def lib_path(*args)
+      tmp("libs", *args)
+    end
+
+    def bundler_path
+      Pathname.new(File.expand_path('../../../lib', __FILE__))
+    end
+
+    extend self
+  end
+end

data/spec/support/permissions.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Permissions
+    def with_umask(new_umask)
+      old_umask = File.umask(new_umask)
+      yield if block_given?
+    ensure
+      File.umask(old_umask)
+    end
+  end
+end

data/spec/support/platforms.rb

@@ -0,0 +1,94 @@
+module Spec
+  module Platforms
+    include Bundler::GemHelpers
+
+    def rb
+      Gem::Platform::RUBY
+    end
+
+    def mac
+      Gem::Platform.new('x86-darwin-10')
+    end
+
+    def java
+      Gem::Platform.new([nil, "java", nil])
+    end
+
+    def linux
+      Gem::Platform.new(['x86', 'linux', nil])
+    end
+
+    def mswin
+      Gem::Platform.new(['x86', 'mswin32', nil])
+    end
+
+    def mingw
+      Gem::Platform.new(['x86', 'mingw32', nil])
+    end
+
+    def x64_mingw
+      Gem::Platform.new(['x64', 'mingw32', nil])
+    end
+
+    def all_platforms
+      [rb, java, linux, mswin, mingw, x64_mingw]
+    end
+
+    def local
+      generic(Gem::Platform.local)
+    end
+
+    def not_local
+      all_platforms.find { |p| p != generic(Gem::Platform.local) }
+    end
+
+    def local_tag
+      if RUBY_PLATFORM == "java"
+        :jruby
+      else
+        :ruby
+      end
+    end
+
+    def not_local_tag
+      [:ruby, :jruby].find { |tag| tag != local_tag }
+    end
+
+    def local_ruby_engine
+      ENV["BUNDLER_SPEC_RUBY_ENGINE"] || (defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby")
+    end
+
+    def local_engine_version
+      return ENV["BUNDLER_SPEC_RUBY_ENGINE_VERSION"] if ENV["BUNDLER_SPEC_RUBY_ENGINE_VERSION"]
+
+      case local_ruby_engine
+      when "ruby"
+        RUBY_VERSION
+      when "rbx"
+        Rubinius::VERSION
+      when "jruby"
+        JRUBY_VERSION
+      else
+        raise BundlerError, "That RUBY_ENGINE is not recognized"
+        nil
+      end
+    end
+
+    def not_local_engine_version
+      case not_local_tag
+      when :ruby
+        not_local_ruby_version
+      when :jruby
+        "1.6.1"
+      end
+    end
+
+    def not_local_ruby_version
+      "1.12"
+    end
+
+    def not_local_patchlevel
+      9999
+    end
+  end
+end

data/spec/support/ruby_ext.rb

@@ -0,0 +1,20 @@
+class IO
+  def read_available_bytes(chunk_size = 16384, select_timeout = 0.02)
+    buffer = []
+
+    return "" if closed? || eof?
+    # IO.select cannot be used here due to the fact that it
+    # just does not work on windows
+    while true
+      begin
+        IO.select([self], nil, nil, select_timeout)
+        break if eof? # stop raising :-(
+        buffer << self.readpartial(chunk_size)
+      rescue(EOFError)
+        break
+      end
+    end
+
+    return buffer.join
+  end
+end

data/spec/support/rubygems_ext.rb

@@ -0,0 +1,39 @@
+require 'rubygems/user_interaction'
+require 'support/path'
+
+module Spec
+  module Rubygems
+    def self.setup
+      Gem.clear_paths
+
+      ENV['BUNDLE_PATH'] = nil
+      ENV['GEM_HOME'] = ENV['GEM_PATH'] = Path.base_system_gems.to_s
+      ENV['PATH'] = ["#{Path.root}/bin", "#{Path.system_gem_path}/bin", ENV['PATH']].join(File::PATH_SEPARATOR)
+
+      unless File.exist?("#{Path.base_system_gems}")
+        FileUtils.mkdir_p(Path.base_system_gems)
+        puts "fetching fakeweb, artifice, sinatra, rake, rack, and builder for the tests to use..."
+        `gem install fakeweb artifice --no-rdoc --no-ri`
+        `gem install sinatra --version 1.2.7 --no-rdoc --no-ri`
+        # Rake version has to be consistent for tests to pass
+        `gem install rake --version 10.0.2 --no-rdoc --no-ri`
+        # 3.0.0 breaks 1.9.2 specs
+        `gem install builder --version 2.1.2 --no-rdoc --no-ri`
+        `gem install rack --no-rdoc --no-ri`
+      end
+
+      ENV['HOME'] = Path.home.to_s
+
+      Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
+    end
+
+    def gem_command(command, args = "", options = {})
+      if command == :exec && !options[:no_quote]
+        args = args.gsub(/(?=")/, "\\")
+        args = %["#{args}"]
+      end
+      lib  = File.join(File.dirname(__FILE__), '..', '..', 'lib')
+      %x{#{Gem.ruby} -I#{lib} -rubygems -S gem --backtrace #{command} #{args}}.strip
+    end
+  end
+end

data/spec/support/streams.rb

@@ -0,0 +1,13 @@
+require 'stringio'
+
+def capture(*streams)
+  streams.map! { |stream| stream.to_s }
+  begin
+    result = StringIO.new
+    streams.each { |stream| eval "$#{stream} = result" }
+    yield
+  ensure
+    streams.each { |stream| eval("$#{stream} = #{stream.upcase}") }
+  end
+  result.string
+end

data/spec/support/sudo.rb

@@ -0,0 +1,16 @@
+module Spec
+  module Sudo
+    def self.present?
+      @which_sudo ||= Bundler.which("sudo")
+    end
+
+    def sudo(cmd)
+      raise "sudo not present" unless Sudo.present?
+      sys_exec("sudo #{cmd}")
+    end
+
+    def chown_system_gems_to_root
+      sudo "chown -R root #{system_gem_path}"
+    end
+  end
+end

data/spec/update/gems_spec.rb

@@ -0,0 +1,201 @@
+require "spec_helper"
+
+describe "bundle update" do
+  before :each do
+    build_repo2
+
+    install_gemfile <<-G
+      source "file://#{gem_repo2}"
+      gem "activesupport"
+      gem "rack-obama"
+    G
+  end
+
+  describe "with no arguments" do
+    it "updates the entire bundle" do
+      update_repo2 do
+        build_gem "activesupport", "3.0"
+      end
+
+      bundle "update"
+      should_be_installed "rack 1.2", "rack-obama 1.0", "activesupport 3.0"
+    end
+
+    it "doesn't delete the Gemfile.lock file if something goes wrong" do
+      gemfile <<-G
+        source "file://#{gem_repo2}"
+        gem "activesupport"
+        gem "rack-obama"
+        exit!
+      G
+      bundle "update"
+      expect(bundled_app("Gemfile.lock")).to exist
+    end
+  end
+
+  describe "--quiet argument" do
+    it "shows UI messages without --quiet argument" do
+      bundle "update"
+      expect(out).to include("Fetching source")
+    end
+
+    it "does not show UI messages with --quiet argument" do
+      bundle "update --quiet"
+      expect(out).not_to include("Fetching source")
+    end
+  end
+
+  describe "with a top level dependency" do
+    it "unlocks all child dependencies that are unrelated to other locked dependencies" do
+      update_repo2 do
+        build_gem "activesupport", "3.0"
+      end
+
+      bundle "update rack-obama"
+      should_be_installed "rack 1.2", "rack-obama 1.0", "activesupport 2.3.5"
+    end
+  end
+
+  describe "with an unknown dependency" do
+    it "should inform the user" do
+      bundle "update halting-problem-solver", :expect_err=>true
+      expect(out).to include "Could not find gem 'halting-problem-solver'"
+    end
+    it "should suggest alternatives" do
+      bundle "update active-support", :expect_err=>true
+      expect(out).to include "Did you mean activesupport?"
+    end
+  end
+
+  describe "with a child dependency" do
+    it "should update the child dependency" do
+      update_repo2
+      bundle "update rack"
+      should_be_installed "rack 1.2"
+    end
+  end
+
+  describe "with --local option" do
+    it "doesn't hit repo2" do
+      FileUtils.rm_rf(gem_repo2)
+
+      bundle "update --local"
+      expect(out).not_to match(/Fetching source index/)
+    end
+  end
+
+  describe "with --group option" do
+    it "should update only specifed group gems" do
+      install_gemfile <<-G
+        source "file://#{gem_repo2}"
+        gem "activesupport", :group => :development
+        gem "rack"
+      G
+      update_repo2 do
+        build_gem "activesupport", "3.0"
+      end
+      bundle "update --group development"
+      should_be_installed "activesupport 3.0"
+      should_not_be_installed "rack 1.2"
+    end
+  end
+end
+
+describe "bundle update in more complicated situations" do
+  before :each do
+    build_repo2
+  end
+
+  it "will eagerly unlock dependencies of a specified gem" do
+    install_gemfile <<-G
+      source "file://#{gem_repo2}"
+
+      gem "thin"
+      gem "rack-obama"
+    G
+
+    update_repo2 do
+      build_gem "thin" , '2.0' do |s|
+        s.add_dependency "rack"
+      end
+    end
+
+    bundle "update thin"
+    should_be_installed "thin 2.0", "rack 1.2", "rack-obama 1.0"
+  end
+end
+
+describe "bundle update without a Gemfile.lock" do
+  it "should not explode" do
+    build_repo2
+
+    gemfile <<-G
+      source "file://#{gem_repo2}"
+
+      gem "rack", "1.0"
+    G
+
+    bundle "update"
+
+    should_be_installed "rack 1.0.0"
+  end
+end
+
+describe "bundle update when a gem depends on a newer version of bundler" do
+  before(:each) do
+    build_repo2 do
+      build_gem "rails", "3.0.1" do |s|
+        s.add_dependency "bundler", Bundler::VERSION.succ
+      end
+    end
+
+    gemfile <<-G
+      source "file://#{gem_repo2}"
+      gem "rails", "3.0.1"
+    G
+  end
+
+  it "should not explode" do
+    bundle "update"
+    expect(err).to be_empty
+  end
+
+  it "should explain that bundler conflicted" do
+    bundle "update"
+    expect(out).not_to match(/in snapshot/i)
+    expect(out).to match(/current Bundler version/i)
+    expect(out).to match(/perhaps you need to update bundler/i)
+  end
+end
+
+describe "bundle update" do
+  it "shows the previous version of the gem when updated from rubygems source" do
+    build_repo2
+
+    install_gemfile <<-G
+      source "file://#{gem_repo2}"
+      gem "activesupport"
+    G
+
+    bundle "update"
+    expect(out).to include("Using activesupport 2.3.5")
+
+    update_repo2 do
+      build_gem "activesupport", "3.0"
+    end
+
+    bundle "update"
+    expect(out).to include("Installing activesupport 3.0 (was 2.3.5)")
+  end
+
+  it "shows error message when Gemfile.lock is not preset and gem is specified" do
+    install_gemfile <<-G
+      source "file://#{gem_repo2}"
+      gem "activesupport"
+    G
+
+    bundle "update nonexisting", :exitstatus => true
+    expect(out).to include("This Bundle hasn't been installed yet. Run `bundle install` to update and install the bundled gems.")
+    expect(@exitstatus).to eq(22)
+  end
+end