-required_version = Gem::Requirement.new ">= 1.8.6"

-require 'thread' # HACK: remove me for 1.5 - this is here just for rails

- RubyGemsVersion = VERSION = '1.5.0'

- def version_requirement

- warn "#{Gem.location_of_caller.join ':'}:Warning: " \

- "Gem::LoadError#version_requirement is deprecated " \

- "and will be removed on or after January 2011. " \

- "Use #requirement."

-

- requirement

- end

-

- def version_requirement= requirement

- warn "#{Gem.location_of_caller.join ':'}:Warning: " \

- "Gem::LoadError#version_requirement= is deprecated " \

- "and will be removed on or after January 2011. " \

- "Use #requirement."

- self.requirement = requirement

- end

- end

- Gem.activate spec.name, "= #{spec.version}"

- # Activates an installed gem matching +gem+. The gem must satisfy

- # Gem#activate adds the library paths in +gem+ to $LOAD_PATH. Before a Gem

- def self.activate(gem, *requirements)

- sources = options[:sources] || []

-

- if requirements.empty? then

- requirements = Gem::Requirement.default

- end

-

- unless gem.respond_to?(:name) and

- gem.respond_to?(:requirement) then

- gem = Gem::Dependency.new(gem, requirements)

- end

- matches = Gem.source_index.find_name(gem.name, gem.requirement)

- report_activate_error(gem) if matches.empty?

- if @loaded_specs[gem.name] then

- existing_spec = @loaded_specs[gem.name]

- sources_message = sources.map { |spec| spec.full_name }

- stack_message = @loaded_stacks[gem.name].map { |spec| spec.full_name }

- msg = "can't activate #{gem} for #{sources_message.inspect}, "

- msg << "already activated #{existing_spec.full_name} for "

- msg << "#{stack_message.inspect}"

- e = Gem::LoadError.new msg

- e.name = gem.name

- e.requirement = gem.requirement

- raise e

- # new load

- @loaded_specs[spec.name] = spec

- # Load dependent gems first

- spec.runtime_dependencies.each do |dep_gem|

- activate dep_gem, :sources => [spec, *sources]

- # The directory prefix this RubyGems was installed at.

- dir = File.dirname File.expand_path(__FILE__)

- prefix = File.dirname dir

- if prefix == File.expand_path(ConfigMap[:sitelibdir]) or

- prefix == File.expand_path(ConfigMap[:libdir]) or

- 'lib' != File.basename(dir) then

- nil

- else

- # :stopdoc:

-

- alias cache source_index # an alias for the old name

- # :startdoc:

- request.add_field "Authorization", Gem.configuration.rubygems_api_key

- request.add_field "Authorization", Gem.configuration.rubygems_api_key

- gem = Dir[File.join(Gem.dir, 'cache', spec.file_name)].first

- alert_error "Cached gem for #{spec.full_name} not found, use `gem install` to restore"

- next

-

- say "Pushing gem to #{options[:host] || Gem.host}..."

-

- request.add_field "Authorization", Gem.configuration.rubygems_api_key

- 'Install into vendorlibdir not sitelibdir',

- '(Requires Ruby 1.8.7)' do |vendor, options|

- if vendor and Gem.ruby_version < Gem::Version.new('1.8.7') then

- raise OptionParser::InvalidOption,

- "requires ruby 1.8.7+ (you have #{Gem.ruby_version})"

- end

-

- required_version = Gem::Requirement.new '>= 1.8.6'

- args << '--quiet'

- def download dependency

- found = Gem::SpecFetcher.fetcher.fetch dependency

-

- return if found.empty?

-

- spec, source_uri = found.first

-

- Gem::RemoteFetcher.fetcher.download spec, source_uri

- end

-

- Gem.path.each do |gem_dir|

- this_path = File.join gem_dir, 'cache', filename

- return download(dependency) if selected.nil?

-

- path = find_in_cache(selected.file_name)

- return download(dependency) unless path

- add_option('--system',

- say "Updating RubyGems"

-

- unless options[:args].empty? then

- raise "No gem names are allowed with the --system option"

- end

-

- rubygems_update = Gem::Specification.new

- rubygems_update.name = 'rubygems-update'

- rubygems_update.version = Gem::Version.new Gem::VERSION

- hig['rubygems-update'] = rubygems_update

-

- options[:user_install] = false

-

- Gem.source_index.refresh!

-

- update_gems = Gem.source_index.find_name 'rubygems-update'

-

- latest_update_gem = update_gems.sort_by { |s| s.version }.last

-

- say "Updating RubyGems to #{latest_update_gem.version}"

- installed = do_rubygems_update latest_update_gem.version

-

- say "RubyGems system software updated" if installed

-

- updated = []

-

- installer = Gem::DependencyInstaller.new options

-

- gems_to_update.uniq.sort.each do |name|

- next if updated.any? { |spec| spec.name == name }

- success = false

-

- say "Updating #{name}"

- begin

- installer.install name

- success = true

- rescue Gem::InstallError => e

- alert_error "Error installing #{name}:\n\t#{e.message}"

- success = false

- end

-

- installer.installed_gems.each do |spec|

- updated << spec

- say "Successfully installed #{spec.full_name}" if success

- end

- end

- # Update the RubyGems software to +version+.

- def do_rubygems_update(version)

- args.push '--prefix', Gem.prefix unless Gem.prefix.nil?

- ENV.delete("RUBYOPT")

- system setup_cmd

- load_rubygems_api_key

- def load_rubygems_api_key

- api_key_hash = File.exists?(credentials_path) ? load_file(credentials_path) : @hash

-

- @rubygems_api_key = api_key_hash[:rubygems_api_key] if api_key_hash.key? :rubygems_api_key

- def require(path) # :doc:

- gem_original_require path

- # Dependency type.

-

- attr_reader :type

-

- ##

- [self.class, @type, @name, requirement.to_s]

- "#{name} (#{requirement}, #{type})"

- @name <=> other.name

- @cache_dir = options[:cache_dir] || @install_dir

- # FIX: throw in everything that satisfies, and let

- # FIX: dependencylist reduce to the chosen few

- next if seen[dep_spec.name]

- # FIX: this is the bug

- # HACK is this test for full_name acceptable?

- @specs.all? do |spec|

- spec.runtime_dependencies.all? do |dep|

- @specs.find { |s| s.satisfies_requirement? dep }

- args << '--quiet'

- ui.errs.puts "... RDOC args: #{args.join(' ')}"

- Gem.configuration.backtrace

- ui.errs.puts "(continuing with the rest of the installation)"

- !matching_files(spec, path).empty?

- # HACK remove? Isn't this done in multiple places?

- cached_gem = File.join @gem_home, "cache", @gem.split(/\//).pop

- FileUtils.cp @gem, File.join(@gem_home, "cache")

- rubycode = @spec.to_ruby

- mode = File.stat(bin_path).mode | 0111

- File.chmod mode, bin_path

- File.open bin_script_path, 'w', 0755 do |file|

- def util_gem_bindir(version = '2')

- File.join util_gem_dir(version), "bin"

- def util_gem_dir(version = '2')

- File.join @gemhome, "gems", "a-#{version}" # HACK

- def util_make_exec(version = '2', shebang = "#!/usr/bin/ruby")

- @spec.executables = ["my_exec"]

- FileUtils.mkdir_p util_gem_bindir(version)

- exec_path = File.join util_gem_bindir(version), "my_exec"

- File.open exec_path, 'w' do |f|

- f.puts shebang

- @spec.files = File.join('lib', 'code.rb')

- @spec.executables << 'executable'

- FileUtils.mv File.join(@gemhome, 'cache', spec.file_name),

- @tempdir

-

-# Copyright (C) 2004 Mauricio Julio Fern�ndez Pradier

- cache_dir = File.join install_dir, 'cache'

- cache_dir = File.join(Gem.user_dir, 'cache')

- remote_gem_path = File.join(path, 'gems', gem_file_name)

- path = uri.path

-

- # Deal with leading slash on Windows paths

- if path[0].chr == '/' && path[1].chr =~ /[a-zA-Z]/ && path[2].chr == ':'

- path = path[1..-1]

- end

-

- requirements.map { |op, version| "#{op} #{version}" }

- requirements.all? { |op, rv| OPS[op].call version, rv }

- def latest_specs

- next if curr_ver.prerelease?

- File.join @dir, "#{uri.host}%#{uri.port}", File.dirname(uri.path)

- specs = list.values.flatten(1) # flatten(1) is 1.8.7 and up

- dependencies.select { |d| d.type == :runtime || d.type == nil }

- result = "--- " + result unless result =~ /^--- /

- result

- return super if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?

-

- YAML.quick_emit object_id, opts do |out|

- out.map taguri, to_yaml_style do |map|

- encode_with map

- unless dependencies.empty? then

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK

- result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- end

- unless dependencies.empty? then

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- end

-require 'yaml'

-

-begin

- YAML::ENGINE.yamler = 'psych'

-rescue LoadError

-end if YAML.const_defined? :ENGINE

-

-begin

- gem 'rdoc'

-rescue Gem::LoadError

-end

-

-require 'rdoc/rdoc'

- Gem.ensure_gem_subdirectories @gemhome

-

- @private_key = File.expand_path('../../../test/rubygems/private_key.pem',

- __FILE__)

- @public_cert = File.expand_path('../../../test/rubygems/public_cert.pem',

- __FILE__)

-

- s.platform = Gem::Platform::RUBY

- s.name = name

- s.version = version

- s.author = 'A User'

- s.email = '[email protected]'

- s.homepage = 'http://example.com'

- s.has_rdoc = true

- s.summary = "this is a summary"

- File.join(@gemhome, 'cache', "#{spec.original_name}.gem")

- FileUtils.rm_r File.join(@gemhome, 'gems')

- FileUtils.rm_r File.join(@gemhome, 'specifications')

- FileUtils.mv File.join(@gemhome, 'cache', "#{spec.original_name}.gem"),

- cache_file

- @a2 = quick_gem('a', '2', &init)

- @a3a = quick_gem('a', '3.a', &init)

- @b2 = quick_gem('b', '2', &init)

- @c1_2 = quick_gem('c', '1.2', &init)

- write_file File.join(*%W[gems #{@a1.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@a2.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@a3a.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@b2.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@pl1.original_name} lib code.rb])

- ruby19_rake = File.expand_path("../../../bin/rake", __FILE__)

- path = File.join(install_dir, 'cache', name)

- FileUtils.rm_f File.join(bindir, exe_name)

- FileUtils.rm_f File.join(bindir, "#{exe_name}.bat")

- unless dependencies_ok? spec then

- raise Gem::DependencyRemovalException,

- "Uninstallation aborted due to dependent gem(s)"

- end

-

- cache_dir = File.join spec.installation_path, 'cache'

- gem = File.join cache_dir, spec.file_name

- gem = File.join cache_dir, "#{original_platform_name}.gem"

- deplist.ok_to_remove?(spec.full_name) || ask_if_ok(spec)

- qstr = case default

- when nil

- 'yn'

- when true

- 'Yn'

- else

- 'yN'

- end

- while result.nil?

- result = ask("#{question} [#{qstr}]")

- result = case result

- when /^[Yy].*/

- true

- when /^[Nn].*/

- false

- when /^$/

- default

- else

- nil

- end

-

-

- if Gem.win_platform?

- reader = File.open('nul', 'r')

- writer = File.open('nul', 'w')

- else

- gem_path = File.join install_dir, "cache", gem_spec.file_name

-TestGem::TEST_PLUGIN_LOAD = :loaded \ No newline at end of file

- quick_gem 'a', '2' do |s|

- quick_gem 'a', '1'

- quick_gem 'a', '10' do |s|

- foo = quick_gem 'foo' do |s| s.files = %w[data/foo.txt] end

- assert File.directory?(File.join(@gemhome, "cache"))

- assert File.directory?("#{gemdir}/cache")

- refute File.exist?("#{gemdir}/cache")

- refute File.exist?("#{gemdir}/cache")

- cwd = File.expand_path '..', __FILE__

- $LOAD_PATH.unshift cwd.dup

- File.expand_path('../sff/discover.rb', __FILE__),

- foo = quick_gem 'foo'

- file_name = File.expand_path __FILE__

-

- prefix = File.dirname File.dirname(file_name)

- prefix = File.dirname prefix if File.basename(prefix) == 'test'

-

- assert_equal prefix, Gem.prefix

-

- file_name = File.expand_path __FILE__

- prefix = File.dirname File.dirname(file_name)

- prefix = File.dirname prefix if File.basename(prefix) == 'test'

-

- Gem::ConfigMap[:libdir] = prefix

-

- file_name = File.expand_path __FILE__

- prefix = File.dirname File.dirname(file_name)

- prefix = File.dirname prefix if File.basename(prefix) == 'test'

-

- Gem::ConfigMap[:sitelibdir] = prefix

- fp.puts "TestGem::TEST_SPEC_PLUGIN_LOAD = :loaded"

- foo = quick_gem 'foo', '1' do |s|

- assert_equal :loaded, TEST_PLUGIN_LOAD

- assert_equal :loaded, TEST_PLUGIN_STANDARDERROR

- assert_equal :loaded, TEST_PLUGIN_EXCEPTION

- test_plugin_path = File.expand_path "../plugin/#{path}", __FILE__

- spec, _ = quick_gem 'a', '4' do |s|

-

- builder = Gem::Builder.new quick_gem('a')

- $: << "test/rubygems"

- $: << "test/rubygems"

- @gem = quick_gem 'some_gem' do |s|

- root = File.expand_path(File.dirname(__FILE__))

- assert_equal "Gem foo-2\n bar (> 1, runtime)\n baz (> 1, runtime)\n\n",

- quick_gem 'foo' do |gem|

- bar (> 1, runtime)

- baz-2 (foo (>= 0, runtime))

- assert_equal "Gem foo-2\n bar (> 1, runtime)\n\n", @ui.output

- File.read(File.join(@gemhome, 'cache', @a2.file_name))

- File.read(File.join(@gemhome, 'cache', @a2.file_name))

- File.read(File.join(@gemhome, 'cache', @a2_pre.file_name))

- File.read(File.join(@gemhome, 'cache', @a1.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2_pre.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2_pre.file_name))

- @cmd.handle_options [@a2_pre.name, '--version', @a2_pre.version.to_s]

- FileUtils.mv File.join(@gemhome, 'cache', @a2.file_name),

- File.join(@tempdir)

- FileUtils.mv File.join(@gemhome, 'cache', @a2.file_name),

- File.join(@tempdir)

- util_setup_spec_fetcher quick_gem(correctly_spelled, '2')

- read_binary(File.join(@gemhome, 'cache', @a2.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2_pre.file_name))

- read_binary(File.join(@gemhome, 'cache', @a2.file_name))

- FileUtils.mv File.join(@gemhome, 'cache', @a2.file_name),

- File.join(@tempdir)

- FileUtils.mv File.join(@gemhome, 'cache', @b2.file_name),

- File.join(@tempdir)

- read_binary(File.join(@gemhome, 'cache', @b2.file_name))

-# Unable to satisfy 'z (>= 0, runtime)' from currently installed gems

- remote_10 = quick_gem 'foo', '1.0'

- remote_20 = quick_gem 'foo', '2.0'

- FileUtils.rm remote_spec_file

-

- FileUtils.rm remote_spec_file

- a = quick_gem 'a' do |s| s.executables = %w[foo] end

- a = quick_gem 'a' do |s| s.executables = %w[foo] end

- a = quick_gem 'a' do |s| s.executables = %w[foo] end

- FileUtils.rm File.join(@gemhome, 'cache', a.file_name)

- assert_equal "Restoring gem\(s\) to pristine condition...", out.shift

- assert_empty out, out.inspect

- assert_equal "ERROR: Cached gem for #{a.full_name} not found, use `gem install` to restore\n",

- @ui.error

- @gems_dir = File.join @tempdir, 'gems'

- @cache_dir = File.join @gemhome, 'cache'

- Gem.configuration.rubygems_api_key = "ed244fbf2b1a52e012da8616c512fa47f9aa5250"

- @spec, @path = util_gem("freewill", "1.0.0")

-end

- foo = quick_gem 'foo'

- quick_gem 'foo', '0.0.1'

- quick_gem 'foo', '0.0.2'

- quick_gem 'foo'

- quick_gem 'foo_bar'

- foo = quick_gem 'foo'

- foo = quick_gem 'foo'

- foo = quick_gem 'foo'

- foo_bar = quick_gem 'foo_bar' do |gem|

- bar_baz = quick_gem 'bar_baz' do |gem|

- if win_platform?

- open(@executable, "wb+") {|f| f.puts "binary"}

- @cmd.options[:args] = Array(@spec.name)

- @spec = quick_gem "pre", "2.b"

- File.join(@gemhome, 'cache', @a1.file_name),

- open File.join(@gemhome, 'cache', @a1.file_name), 'rb' do |fp|

- File.join(@gemhome, 'cache', @a1.file_name),

- FileUtils.rm File.join(@gemhome, 'cache', @a1.file_name)

- File.join(@gemhome, 'cache', @a1.file_name),

- open File.join(@gemhome, 'cache', @a2.file_name), 'rb' do |fp|

- foo_spec = quick_gem 'foo'

- foo_bar_spec = quick_gem 'foo_bar'

- @a1_path = File.join @gemhome, 'cache', @a1.file_name

- @a2_path = File.join @gemhome, 'cache', @a2.file_name

- @cmd.options[:generate_rdoc] = true

- @cmd.options[:generate_ri] = true

- assert_equal "Installing ri documentation for a-2...", out.shift

- assert_equal "Installing RDoc documentation for a-2...", out.shift

- @c2 = quick_gem 'c', '2' do |s|

- @b2_path = File.join @gemhome, 'cache', @b2.file_name

- @c1_2_path = File.join @gemhome, 'cache', @c1_2.file_name

- @c2_path = File.join @gemhome, 'cache', @c2.file_name

- @foo_bar = quick_gem 'foo_bar' do |gem|

- @gems_dir = File.join @tempdir, 'gems'

- @cache_dir = File.join @gemhome, 'cache'

- FileUtils.mkdir @gems_dir

- write_file File.join('gems', 'a-1', 'bin', 'a_bin') do |fp|

- fp.puts "#!/usr/bin/ruby"

- end

- @a1, @a1_gem = util_gem 'a', '1' do |s| s.executables << 'a_bin' end

- @aa1, @aa1_gem = util_gem 'aa', '1'

-

- @b1, @b1_gem = util_gem 'b', '1' do |s|

- s.add_dependency 'a'

- s.add_development_dependency 'aa'

- end

-

- @b1_pre, @b1_pre_gem = util_gem 'b', '1.a' do |s|

- @c1_pre, @c1_pre_gem = util_gem 'c', '1.a' do |s|

- s.add_dependency 'a', '1.a'

- s.add_dependency 'b', '1'

- end

-

- @d1, @d1_gem = util_gem 'd', '1'

- @d2, @d2_gem = util_gem 'd', '2'

-

- @x1_m, @x1_m_gem = util_gem 'x', '1' do |s|

- s.platform = Gem::Platform.new %w[cpu my_platform 1]

- end

-

- @x1_o, @x1_o_gem = util_gem 'x', '1' do |s|

- s.platform = Gem::Platform.new %w[cpu other_platform 1]

- end

-

- @w1, @w1_gem = util_gem 'w', '1', 'x' => nil

-

- @y1, @y1_gem = util_gem 'y', '1'

- @y1_1_p, @y1_1_p_gem = util_gem 'y', '1.1' do |s|

- s.platform = Gem::Platform.new %w[cpu my_platform 1]

- end

-

- @z1, @z1_gem = util_gem 'z', '1', 'y' => nil

-

- @fetcher = Gem::FakeFetcher.new

- Gem::RemoteFetcher.fetcher = @fetcher

-

- util_setup_spec_fetcher(@a1, @a1_pre, @b1, @b1_pre, @c1_pre, @d1, @d2,

- @x1_m, @x1_o, @w1, @y1, @y1_1_p, @z1)

- util_clear_gems

- assert File.exist?(File.join(@tempdir, 'cache', @a1.file_name))

- assert File.exist?(File.join(@tempdir, 'cache', @b1.file_name))

- assert File.exist?(File.join(gemhome2, 'cache', @a1.file_name))

- e = assert_raises Gem::InstallError do

- assert_equal 'b requires a (>= 0, runtime)', e.message

- def test_install_domain_remote_platform_newer

- def test_install_reinstall

- Gem::Installer.new(@a1_gem).install

- FileUtils.mv @a1_gem, @tempdir

- inst = nil

-

- Dir.chdir @tempdir do

- inst = Gem::DependencyInstaller.new

- inst.install 'a'

- end

-

- assert_equal Gem::SourceIndex.new(@a1.full_name => @a1),

- Gem::SourceIndex.from_installed_gems

-

- assert_equal %w[a-1], inst.installed_gems.map { |s| s.full_name }

- end

-

- inst.find_spec_by_name_and_version 'a'

- inst = Gem::DependencyInstaller.new

- inst.find_spec_by_name_and_version 'w'

- inst.gather_dependencies

-

- assert_equal %w[x-1-cpu-my_platform-1 w-1],

- inst.gems_to_install.map { |s| s.full_name }

- inst = Gem::DependencyInstaller.new

- inst.find_spec_by_name_and_version 'z'

- inst.gather_dependencies

- assert_equal %w[y-1 z-1], inst.gems_to_install.map { |s| s.full_name }

- inst = Gem::DependencyInstaller.new :prerelease => true

- inst.find_spec_by_name_and_version 'c', '1.a'

- inst.gather_dependencies

- assert_equal %w[a-1.a b-1 c-1.a],

- inst.gems_to_install.map { |s| s.full_name }

- e1, = util_gem 'e', '1', 'd' => '= 1'

-

- util_setup_spec_fetcher @d1, @d2, e1

- inst = Gem::DependencyInstaller.new

- inst.find_spec_by_name_and_version 'e'

- inst.gather_dependencies

- assert_equal %w[d-1 e-1], inst.gems_to_install.map { |s| s.full_name }

-end

- @a1 = quick_gem 'a', '1'

- @a2 = quick_gem 'a', '2'

- @a3 = quick_gem 'a', '3'

- @b1 = quick_gem 'b', '1' do |s| s.add_dependency 'a', '>= 1' end

- @b2 = quick_gem 'b', '2' do |s| s.add_dependency 'a', '>= 1' end

- @c1 = quick_gem 'c', '1' do |s| s.add_dependency 'b', '>= 1' end

- @c2 = quick_gem 'c', '2'

- @d1 = quick_gem 'd', '1' do |s| s.add_dependency 'c', '>= 1' end

- e1 = quick_gem 'e', '1'

- f1 = quick_gem 'f', '1'

- g1 = quick_gem 'g', '1'

- e1 = quick_gem 'e', '1'

- a1 = quick_gem 'a', '1'

- a2 = quick_gem 'a', '2'

- b = quick_gem 'b', '1' do |s| s.add_dependency 'a', '= 1' end

- c = quick_gem 'c', '1' do |s| s.add_dependency 'a', '= 2' end

- d = quick_gem 'd', '1' do |s|

- @spec = quick_gem 'a'

- orig_mode = File.stat(@spec.installation_path).mode

- File.chmod(0, @spec.installation_path)

- File.chmod orig_mode, @spec.installation_path

-require 'test/rubygems/simple_gem'

- gems = Dir[File.join(@gemhome, 'cache', '*.gem')]

- @d2_0 = quick_gem 'd', '2.0' do |s|

- @d2_0_a = quick_gem 'd', '2.0.a'

- @d2_0_b = quick_gem 'd', '2.0.b'

- cache_gems = File.join @gemhome, 'cache', '*.gem'

- FileUtils.mv Dir[cache_gems], gems

- spec = quick_gem 'd', '2.0'

- @d2_1 = quick_gem 'd', '2.1'

- @d2_1_a = quick_gem 'd', '2.2.a'

- FileUtils.mv File.join(@gemhome, 'cache', @d2_1.file_name), gems

- FileUtils.mv File.join(@gemhome, 'cache', @d2_1_a.file_name), gems

-

-

- util_make_exec '2', ''

-load Gem.bin_path('a', 'my_exec', version)

- wrapper = @installer.app_script_text 'my_exec'

- assert_equal 'a requires b (> 2, runtime)', e.message

- @spec.executables = ["my_exec"]

- exec_file = @installer.formatted_program_filename "my_exec"

- exec_path = File.join util_gem_dir(@spec.version), exec_file

- installed_exec = File.join(util_inst_bindir, "my_exec")

- installed_exec = File.join(util_inst_bindir, "my_exec")

- installed_exec = File.join util_inst_bindir, 'foo-my_exec-bar'

- installed_exec = File.join util_inst_bindir, 'my_exec'

- @spec.executables = ["my_exec"]

- File.open File.join(gem_bindir, "my_exec"), 'w' do |f|

- installed_exec = File.join("#{@gemhome}2", 'bin', 'my_exec')

- assert_equal false, File.exist?(util_inst_bindir)

- @spec.executables = ["my_exec"]

- File.open File.join(gem_bindir, "my_exec"), 'w' do |f|

- installed_exec = File.join @gemhome, 'bin', 'my_exec'

- installed_exec = File.join(util_inst_bindir, "my_exec")

- real_exec = File.join util_gem_dir, 'bin', 'my_exec'

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_dir, "bin", "my_exec"),

- assert_equal false, File.exist?(util_inst_bindir)

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_dir, "bin", "my_exec"),

- util_make_exec '3'

- @installer.gem_dir = File.join util_gem_dir('3')

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_bindir('3'), "my_exec"),

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_dir, "bin", "my_exec"),

- util_make_exec '1'

- @installer.gem_dir = util_gem_dir('1')

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_dir('2'), "bin", "my_exec"),

- installed_exec = File.join(util_inst_bindir, "my_exec")

- util_make_exec '3'

- @installer.gem_dir = util_gem_dir '3'

- installed_exec = File.join(util_inst_bindir, "my_exec")

- assert_equal(File.join(util_gem_dir('3'), "bin", "my_exec"),

- installed_exec = File.join(util_inst_bindir, "my_exec")

- shebang_line = open("#{@gemhome}/bin/my_exec") { |f| f.readlines.first }

- spec = quick_gem 'a' do |s| s.platform = Gem::Platform.new 'mswin32' end

- FileUtils.mv File.join(@gemhome, 'cache', spec.file_name),

- @tempdir

- cache_file = File.join @gemhome, 'cache', @spec.file_name

- b2 = quick_gem 'b', 2

- FileUtils.rm_f File.join(Gem.dir, 'cache')

- File.directory? File.join(Gem.dir, 'cache')

- assert File.exist?(File.join(@gemhome, 'cache', @spec.file_name))

- spec = quick_gem 'old_rubygems_required', '1' do |s|

- gem = File.join @gemhome, 'cache', spec.file_name

- util_make_exec '2', "#!/usr/bin/ruby"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/ruby -ws"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', ''

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/env ruby"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/env ruby -ws"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', ''

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/opt/local/ruby/bin/ruby"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/opt/local/ruby/bin/ruby -ws"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/ruby18"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/ruby18 -ws"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/env ruby18"

- shebang = @installer.shebang 'my_exec'

- util_make_exec '2', "#!/usr/bin/env ruby18 -ws"

- shebang = @installer.shebang 'my_exec'

- spec = quick_gem 'old_ruby_required', '1' do |s|

- File.join @gemhome, 'cache', spec.file_name

- @cache_dir = File.join @gemhome, 'cache'

- a1_cache_gem = File.join(@gemhome, 'cache', @a1.file_name)

- assert_equal File.join(@gemhome, 'cache', @a1.file_name),

- assert_equal File.join(@gemhome, 'cache', @a1.file_name),

- assert_equal File.join(@gemhome, 'cache', @a1.file_name),

- a1_cache_gem = File.join install_dir, 'cache', @a1.file_name

- File.chmod 0555, File.join(@gemhome, 'cache')

- File.chmod 0755, File.join(@gemhome, 'cache')

- File.chmod 0555, File.join(@gemhome, 'cache')

- assert File.exist?(File.join(Gem.user_dir, 'cache', @a1.file_name))

- File.chmod 0755, File.join(@gemhome)

- File.chmod 0755, File.join(@gemhome, 'cache')

- e1_cache_gem = File.join(@gemhome, 'cache', e1.file_name)

- cache_path = File.join @gemhome, 'cache', @a1.file_name

- a1 = quick_gem 'a', '1' do |spec| spec.author = 'author 1' end

- a1 = quick_gem 'a', '1' do |spec| spec.author = 'author 1' end

- p1_ruby = quick_gem 'p', '1'

- p1_platform = quick_gem 'p', '1' do |spec|

- a1_platform = quick_gem @a1.name, (@a1.version) do |s|

- a2_platform = quick_gem @a2.name, (@a2.version) do |s|

- a2_platform_other = quick_gem @a2.name, (@a2.version) do |s|

- a3_platform_other = quick_gem @a2.name, (@a2.version.bump) do |s|

- a1 = quick_gem 'a', '1' do |spec| spec.author = 'author 1' end

- a2 = quick_gem 'a', '1' do |spec| spec.author = 'author 2' end

- updated = quick_gem @a2.name, (@a2.version.bump)

- updated_platform = quick_gem @a2.name, (updated.version.bump) do |s|

- gem_a1_alpha = quick_gem 'abba', '1.a'

- a1 = quick_gem 'a', '1'

- a1_mine = quick_gem 'a', '1' do |s|

- a1_other = quick_gem 'a', '1' do |s|

- @a_pre = quick_gem 'a', '1.a'

- gem = quick_gem "awesome", "1.0" do |awesome|

- def test_dependencies_scoped_by_type

- gem = quick_gem "awesome", "1.0" do |awesome|

- awesome.add_runtime_dependency "bonobo", []

- awesome.add_development_dependency "monkey", []

- end

- bonobo = Gem::Dependency.new("bonobo", [])

- monkey = Gem::Dependency.new("monkey", [], :development)

- assert_equal([bonobo, monkey], gem.dependencies)

- assert_equal([bonobo], gem.runtime_dependencies)

- assert_equal([monkey], gem.development_dependencies)

- g1 = quick_gem 'gem'

- g2 = quick_gem 'gem'

- @prerelease = quick_gem('tardis', '2.2.0.a')

- s1 = quick_gem 'a', '1'

- s2 = quick_gem 'b', '1'

- s1 = quick_gem 'a', '1'

- s2 = quick_gem 'a', '1' do |s|

- s1 = quick_gem 'a', '1'

- s2 = quick_gem 'a', '2'

- s.add_runtime_dependency(%q<pqa>, [\"> 0.4\", \"<= 0.6\"])

- s.add_dependency(%q<pqa>, [\"> 0.4\", \"<= 0.6\"])

- s.add_dependency(%q<pqa>, [\"> 0.4\", \"<= 0.6\"])

-

-

- @user_spec.executables = ["my_exec"]

- exec_path = File.join user_bin_dir, "my_exec"

- exec_path = File.join user_bin_dir, "my_exec"

- executable = File.join Gem.user_dir, 'bin', 'my_exec'

- assert File.exist? executable

- executable = File.join Gem.user_dir, 'bin', 'my_exec'

- assert File.exist? executable

- assert_equal "Removing my_exec\n", @ui.output

- exec_path = File.join Gem.user_dir, 'bin', 'my_exec'

- assert_equal "Removing my_exec\n", @ui.output

-require "test/rubygems/simple_gem"

- assert_match(/activate a \(= 2, runtime\)/, ex.message)