bundler 1.7.15 → 1.8.0.pre

data/spec/support/matchers.rb

@@ -1,77 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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 gem_repo4(*args)
-      tmp("gems/remote4", *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

@@ -1,10 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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