bundler_package_git 1.1.pre.1

data/spec/support/fakeweb/rack-1.0.0.marshal

@@ -0,0 +1,2 @@
+[{	:dependencies[["	thin"	>= 0["ruby-openid"
+1.0.0

data/spec/support/fakeweb/windows.rb

@@ -0,0 +1,23 @@
+require File.expand_path("../../path.rb", __FILE__)
+include Spec::Path
+
+files = [ 'specs.4.8.gz',
+          'prerelease_specs.4.8.gz',
+          'quick/Marshal.4.8/rcov-1.0-mswin32.gemspec.rz',
+          'gems/rcov-1.0-mswin32.gem' ]
+
+# Set up pretend http gem server with FakeWeb
+$LOAD_PATH.unshift "#{Dir[base_system_gems.join("gems/fakeweb*/lib")].first}"
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+files.each do |file|
+  FakeWeb.register_uri(:get, "http://localgemserver.test/#{file}",
+    :body => File.read("#{gem_repo1}/#{file}"))
+end
+FakeWeb.register_uri(:get, "http://localgemserver.test/gems/rcov-1.0-x86-mswin32.gem",
+  :status => ["404", "Not Found"])
+
+FakeWeb.register_uri(:get, "http://localgemserver.test/api/v1/dependencies?gems=rcov",
+  :status => ["404", "Not Found"])

data/spec/support/helpers.rb

@@ -0,0 +1,246 @@
+module Spec
+  module Helpers
+    def reset!
+      @in_p, @out_p, @err_p = nil, nil, nil
+      Dir["#{tmp}/{gems/*,*}"].each do |dir|
+        next if %(base remote1 gems rubygems).include?(File.basename(dir))
+        unless ENV['BUNDLER_SUDO_TESTS']
+          FileUtils.rm_rf(dir)
+        else
+          `sudo rm -rf #{dir}`
+        end
+      end
+      FileUtils.mkdir_p(tmp)
+      FileUtils.mkdir_p(home)
+      Gem.sources = ["file://#{gem_repo1}/"]
+      Gem.configuration.write
+    end
+
+    attr_reader :out, :err, :exitstatus
+
+    def in_app_root(&blk)
+      Dir.chdir(bundled_app, &blk)
+    end
+
+    def in_app_root2(&blk)
+      Dir.chdir(bundled_app2, &blk)
+    end
+
+    def run(cmd, *args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      expect_err = opts.delete(:expect_err)
+      env = opts.delete(:env)
+      groups = args.map {|a| a.inspect }.join(", ")
+      setup = "require 'rubygems' ; require 'bundler' ; Bundler.setup(#{groups})\n"
+      @out = ruby(setup + cmd, :expect_err => expect_err, :env => env)
+    end
+
+    def lib
+      File.expand_path('../../../lib', __FILE__)
+    end
+
+    def bundle(cmd, options = {})
+      expect_err  = options.delete(:expect_err)
+      exitstatus = options.delete(:exitstatus)
+      options["no-color"] = true unless options.key?("no-color") || cmd.to_s[0..3] == "exec"
+
+      bundle_bin = File.expand_path('../../../bin/bundle', __FILE__)
+      fake_file = options.delete(:fakeweb)
+      fakeweb = fake_file ? "-r#{File.expand_path('../fakeweb/'+fake_file+'.rb', __FILE__)}" : nil
+      artifice_file = options.delete(:artifice)
+      artifice = artifice_file ? "-r#{File.expand_path('../artifice/'+artifice_file+'.rb', __FILE__)}" : nil
+
+      env = (options.delete(:env) || {}).map{|k,v| "#{k}='#{v}' "}.join
+      args = options.map do |k,v|
+        v == true ? " --#{k}" : " --#{k} #{v}" if v
+      end.join
+
+      cmd = "#{env}#{Gem.ruby} -I#{lib} #{fakeweb} #{artifice} #{bundle_bin} #{cmd}#{args}"
+
+      if exitstatus
+        sys_status(cmd)
+      else
+        sys_exec(cmd, expect_err){|i| yield i if block_given? }
+      end
+    end
+
+    def ruby(ruby, options = {})
+      expect_err = options.delete(:expect_err)
+      env = (options.delete(:env) || {}).map{|k,v| "#{k}='#{v}' "}.join
+      ruby.gsub!(/["`\$]/) {|m| "\\#{m}" }
+      lib_option = options[:no_lib] ? "" : " -I#{lib}"
+      sys_exec(%{#{env}#{Gem.ruby}#{lib_option} -e "#{ruby}"}, expect_err)
+    end
+
+    def gembin(cmd)
+      lib = File.expand_path("../../../lib", __FILE__)
+      old, ENV['RUBYOPT'] = ENV['RUBYOPT'], "#{ENV['RUBYOPT']} -I#{lib}"
+      cmd = bundled_app("bin/#{cmd}") unless cmd.to_s.include?("/")
+      sys_exec(cmd.to_s)
+    ensure
+      ENV['RUBYOPT'] = old
+    end
+
+    def sys_exec(cmd, expect_err = false)
+      Open3.popen3(cmd.to_s) do |stdin, stdout, stderr|
+        @in_p, @out_p, @err_p = stdin, stdout, stderr
+
+        yield @in_p if block_given?
+        @in_p.close
+
+        @out = @out_p.read_available_bytes.strip
+        @err = @err_p.read_available_bytes.strip
+      end
+
+      puts @err unless expect_err || @err.empty? || !$show_err
+      @out
+    end
+
+    def sys_status(cmd)
+      @err = nil
+      @out = %x{#{cmd}}.strip
+      @exitstatus = $?.exitstatus
+    end
+
+    def config(config = nil)
+      path = bundled_app('.bundle/config')
+      return YAML.load_file(path) unless config
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') do |f|
+        f.puts config.to_yaml
+      end
+      config
+    end
+
+    def gemfile(*args)
+      path = bundled_app("Gemfile")
+      path = args.shift if Pathname === args.first
+      str  = args.shift || ""
+      path.dirname.mkpath
+      File.open(path.to_s, 'w') do |f|
+        f.puts str
+      end
+    end
+
+    def lockfile(*args)
+      path = bundled_app("Gemfile.lock")
+      path = args.shift if Pathname === args.first
+      str  = args.shift || ""
+
+      # Trim the leading spaces
+      spaces = str[/\A\s+/, 0] || ""
+      str.gsub!(/^#{spaces}/, '')
+
+      File.open(path.to_s, 'w') do |f|
+        f.puts str
+      end
+    end
+
+    def install_gemfile(*args)
+      gemfile(*args)
+      opts = args.last.is_a?(Hash) ? args.last : {}
+      bundle :install, opts
+    end
+
+    def install_gems(*gems)
+      gems.each do |g|
+        path = "#{gem_repo1}/gems/#{g}.gem"
+
+        raise "OMG `#{path}` does not exist!" unless File.exist?(path)
+
+        gem_command :install, "--no-rdoc --no-ri --ignore-dependencies #{path}"
+      end
+    end
+
+    alias install_gem install_gems
+
+    def with_gem_path_as(path)
+      gem_home, gem_path = ENV['GEM_HOME'], ENV['GEM_PATH']
+      ENV['GEM_HOME'], ENV['GEM_PATH'] = path.to_s, path.to_s
+      yield
+    ensure
+      ENV['GEM_HOME'], ENV['GEM_PATH'] = gem_home, gem_path
+    end
+
+    def break_git!
+      FileUtils.mkdir_p(tmp("broken_path"))
+      File.open(tmp("broken_path/git"), "w", 0755) do |f|
+        f.puts "#!/usr/bin/env ruby\nSTDERR.puts 'This is not the git you are looking for'\nexit 1"
+      end
+
+      ENV["PATH"] = "#{tmp("broken_path")}:#{ENV["PATH"]}"
+    end
+
+    def fake_groff!
+      FileUtils.mkdir_p(tmp("fake_groff"))
+      File.open(tmp("fake_groff/groff"), "w", 0755) do |f|
+        f.puts "#!/usr/bin/env ruby\nputs ARGV.inspect\n"
+      end
+
+      ENV["PATH"] = "#{tmp("fake_groff")}:#{ENV["PATH"]}"
+    end
+
+    def kill_path!
+      ENV["PATH"] = ""
+    end
+
+    def system_gems(*gems)
+      gems = gems.flatten
+
+      FileUtils.rm_rf(system_gem_path)
+      FileUtils.mkdir_p(system_gem_path)
+
+      Gem.clear_paths
+
+      gem_home, gem_path, path = ENV['GEM_HOME'], ENV['GEM_PATH'], ENV['PATH']
+      ENV['GEM_HOME'], ENV['GEM_PATH'] = system_gem_path.to_s, system_gem_path.to_s
+
+      install_gems(*gems)
+      if block_given?
+        begin
+          yield
+        ensure
+          ENV['GEM_HOME'], ENV['GEM_PATH'] = gem_home, gem_path
+          ENV['PATH'] = path
+        end
+      end
+    end
+
+    def cache_gems(*gems)
+      gems = gems.flatten
+
+      FileUtils.rm_rf("#{bundled_app}/vendor/cache")
+      FileUtils.mkdir_p("#{bundled_app}/vendor/cache")
+
+      gems.each do |g|
+        path = "#{gem_repo1}/gems/#{g}.gem"
+        raise "OMG `#{path}` does not exist!" unless File.exist?(path)
+        FileUtils.cp(path, "#{bundled_app}/vendor/cache")
+      end
+    end
+
+    def simulate_new_machine
+      system_gems []
+      FileUtils.rm_rf default_bundle_path
+      FileUtils.rm_rf bundled_app('.bundle')
+    end
+
+    def simulate_platform(platform)
+      old, ENV['BUNDLER_SPEC_PLATFORM'] = ENV['BUNDLER_SPEC_PLATFORM'], platform.to_s
+      yield if block_given?
+    ensure
+      ENV['BUNDLER_SPEC_PLATFORM'] = old if block_given?
+    end
+
+    def simulate_bundler_version(version)
+      old, ENV['BUNDLER_SPEC_VERSION'] = ENV['BUNDLER_SPEC_VERSION'], version.to_s
+      yield if block_given?
+    ensure
+      ENV['BUNDLER_SPEC_VERSION'] = old if block_given?
+    end
+
+    def revision_for(path)
+      Dir.chdir(path) { `git rev-parse HEAD`.strip }
+    end
+  end
+end

data/spec/support/indexes.rb

@@ -0,0 +1,112 @@
+module Spec
+  module Indexes
+    def dep(name, reqs = nil)
+      @deps ||= []
+      @deps << Bundler::Dependency.new(name, :version => reqs)
+    end
+
+    def platform(*args)
+      @platforms ||= []
+      @platforms.concat args.map { |p| Gem::Platform.new(p) }
+    end
+
+    alias platforms platform
+
+    def resolve
+      @platforms ||= ['ruby']
+      deps = []
+      @deps.each do |d|
+        @platforms.each do |p|
+          deps << Bundler::DepProxy.new(d, p)
+        end
+      end
+      Bundler::Resolver.resolve(deps, @index)
+    end
+
+    def should_resolve_as(specs)
+      got = resolve
+      got = got.map { |s| s.full_name }.sort
+      got.should == specs.sort
+    end
+
+    def should_conflict_on(names)
+      begin
+        got = resolve
+        flunk "The resolve succeeded with: #{got.map { |s| s.full_name }.sort.inspect}"
+      rescue Bundler::VersionConflict => e
+        Array(names).sort.should == e.conflicts.sort
+      end
+    end
+
+    def gem(*args, &blk)
+      build_spec(*args, &blk).first
+    end
+
+    def an_awesome_index
+      build_index do
+        gem "rack", %w(0.8 0.9 0.9.1 0.9.2 1.0 1.1)
+        gem "rack-mount", %w(0.4 0.5 0.5.1 0.5.2 0.6)
+
+        # --- Rails
+        versions "1.2.3 2.2.3 2.3.5 3.0.0.beta 3.0.0.beta1" do |version|
+          gem "activesupport", version
+          gem "actionpack", version do
+            dep "activesupport", version
+            if version >= v('3.0.0.beta')
+              dep "rack", '~> 1.1'
+              dep "rack-mount", ">= 0.5"
+            elsif version > v('2.3')   then dep "rack", '~> 1.0.0'
+            elsif version > v('2.0.0') then dep "rack", '~> 0.9.0'
+            end
+          end
+          gem "activerecord", version do
+            dep "activesupport", version
+            dep "arel", ">= 0.2" if version >= v('3.0.0.beta')
+          end
+          gem "actionmailer", version do
+            dep "activesupport", version
+            dep "actionmailer",  version
+          end
+          if version < v('3.0.0.beta')
+            gem "railties", version do
+              dep "activerecord",  version
+              dep "actionpack",    version
+              dep "actionmailer",  version
+              dep "activesupport", version
+            end
+          else
+            gem "railties", version
+            gem "rails", version do
+              dep "activerecord",  version
+              dep "actionpack",    version
+              dep "actionmailer",  version
+              dep "activesupport", version
+              dep "railties",      version
+            end
+          end
+        end
+
+        versions '1.0 1.2 1.2.1 1.2.2 1.3 1.3.0.1 1.3.5 1.4.0 1.4.2 1.4.2.1' do |version|
+          platforms "ruby java mswin32 mingw32" do |platform|
+            next if version == v('1.4.2.1') && platform != pl('x86-mswin32')
+            next if version == v('1.4.2') && platform == pl('x86-mswin32')
+            gem "nokogiri", version, platform do
+              dep "weakling", ">= 0.0.3" if platform =~ pl('java')
+            end
+          end
+        end
+
+        versions '0.0.1 0.0.2 0.0.3' do |version|
+          gem "weakling", version
+        end
+
+        # --- Rails related
+        versions '1.2.3 2.2.3 2.3.5' do |version|
+          gem "activemerchant", version do
+            dep "activesupport", ">= #{version}"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,89 @@
+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+/)
+        check Gem::Version.new(actual_version).should == Gem::Version.new(version)
+        actual_platform.should == 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"
+          out.should == "WIN"
+        else
+          Gem::Version.new(out).should_not == Gem::Version.new(version)
+        end
+      end
+    end
+
+    def should_be_locked
+      bundled_app("Gemfile.lock").should exist
+    end
+
+    RSpec::Matchers.define :be_with_diff do |expected|
+      spaces = expected[/\A\s+/, 0] || ""
+      expected.gsub!(/^#{spaces}/, '')
+
+      failure_message_for_should do |actual|
+        "The lockfile did not match.\n=== Expected:\n" <<
+          expected << "\n=== Got:\n" << actual << "\n===========\n"
+      end
+
+      match do |actual|
+        expected == actual
+      end
+    end
+
+    def lockfile_should_be(expected)
+      lock = File.read(bundled_app("Gemfile.lock"))
+      lock.should be_with_diff(expected)
+    end
+  end
+end