Class: Gem::TestCase (Ruby 2.7.2)
Description: Class : Gem::TestCase - Ruby 2.7.2

### Home Classes Methods

### In Files

- rubygems/test_case.rb
- rubygems/test_utilities.rb

### Parent

(defined?(Minitest::Test) ? Minitest::Test : MiniTest::Unit::TestCase)

### Namespace

- CLASS Gem::TestCase::SpecFetcherSetup
- CLASS Gem::TestCase::StaticSet

### Methods

- ::java_platform?
- ::make_command
- ::process_based_port
- ::rubybin
- ::vc_windows?
- ::win_platform?
- #add_to_fetcher
- #all_spec_names
- #ask_if_ok
- #assert_activate
- #assert_contains_make_command
- #assert_directory_exists
- #assert_path_exists
- #bindir
- #build_rake_in
- #common_installer_setup
- #common_installer_teardown
- #enable_shared
- #exeext
- #git_gem
- #have_git?
- #install_default_gems
- #install_default_specs
- #install_gem
- #install_gem_user
- #install_specs
- #java_platform?
- #loaded_spec_names
- #make_command
- #mu_pp
- #new_default_spec
- #nmake_found?
- #parse_make_command_line
- #process_based_port
- #quick_gem
- #read_binary
- #read_cache
- #refute_path_exists
- #save_loaded_features
- #scan_make_command_lines
- #setup
- #teardown
- #uninstall_gem
- #unresolved_names
- #util_build_gem
- #util_clear_RUBY_VERSION
- #util_clear_gems
- #util_gem
- #util_gzip
- #util_make_gems
- #util_remove_gem
- #util_restore_RUBY_VERSION
- #util_set_RUBY_VERSION
- #util_set_arch
- #util_setup_spec_fetcher
- #util_spec
- #util_zip
- #vc_windows?
- #vendordir
- #wait_for_child_process_to_exit
- #win_platform?
- #with_clean_path_to_ruby
- #write_file

### Included Modules

- Gem::DefaultUserInteraction

### Class/Module Index

Quicksearch

- Bundler
- Gem::AvailableSet
- Gem::BasicSpecification
- Gem::BundlerVersionFinder
- Gem::Command
- Gem::CommandLineError
- Gem::CommandManager
- Gem::Commands
- Gem::Commands::BuildCommand
- Gem::Commands::CertCommand
- Gem::Commands::CheckCommand
- Gem::Commands::CleanupCommand
- Gem::Commands::ContentsCommand
- Gem::Commands::DependencyCommand
- Gem::Commands::EnvironmentCommand
- Gem::Commands::FetchCommand
- Gem::Commands::GenerateIndexCommand
- Gem::Commands::HelpCommand
- Gem::Commands::InfoCommand
- Gem::Commands::InstallCommand
- Gem::Commands::ListCommand
- Gem::Commands::LockCommand
- Gem::Commands::MirrorCommand
- Gem::Commands::OpenCommand
- Gem::Commands::OutdatedCommand
- Gem::Commands::OwnerCommand
- Gem::Commands::PristineCommand
- Gem::Commands::PushCommand
- Gem::Commands::QueryCommand
- Gem::Commands::RdocCommand
- Gem::Commands::SearchCommand
- Gem::Commands::ServerCommand
- Gem::Commands::SetupCommand
- Gem::Commands::SetupCommand::MakeDirs
- Gem::Commands::SigninCommand
- Gem::Commands::SignoutCommand
- Gem::Commands::SourcesCommand
- Gem::Commands::SpecificationCommand
- Gem::Commands::StaleCommand
- Gem::Commands::UninstallCommand
- Gem::Commands::UnpackCommand
- Gem::Commands::UpdateCommand
- Gem::Commands::WhichCommand
- Gem::Commands::YankCommand
- Gem::ConfigFile
- Gem::ConflictError
- Gem::ConsoleUI
- Gem::DefaultUserInteraction
- Gem::Dependency
- Gem::DependencyError
- Gem::DependencyInstaller
- Gem::DependencyList
- Gem::DependencyRemovalException
- Gem::DependencyResolutionError
- Gem::Deprecate
- Gem::Doctor
- Gem::DocumentError
- Gem::EndOfYAMLException
- Gem::ErrorReason
- Gem::Exception
- Gem::Ext
- Gem::Ext::BuildError
- Gem::Ext::Builder
- Gem::Ext::CmakeBuilder
- Gem::Ext::ConfigureBuilder
- Gem::Ext::ExtConfBuilder
- Gem::Ext::RakeBuilder
- Gem::FakeFetcher
- Gem::FilePermissionError
- Gem::FormatException
- Gem::GemNotFoundException
- Gem::GemNotInHomeException
- Gem::GemRunner
- Gem::GemcutterUtilities
- Gem::ImpossibleDependenciesError
- Gem::Indexer
- Gem::InstallError
- Gem::InstallUpdateOptions
- Gem::Installer
- Gem::Installer::FakePackage
- Gem::InstallerTestCase
- Gem::InvalidSpecificationException
- Gem::Licenses
- Gem::List
- Gem::LoadError
- Gem::LocalRemoteOptions
- Gem::MissingSpecError
- Gem::MissingSpecVersionError
- Gem::MockGemUi
- Gem::MockGemUi::InputEOFError
- Gem::MockGemUi::SystemExitException
- Gem::MockGemUi::TTY
- Gem::MockGemUi::TermError
- Gem::NameTuple
- Gem::NoAliasYAMLTree
- Gem::OperationNotSupportedError
- Gem::Package::DigestIO
- Gem::Package::Error
- Gem::Package::FormatError
- Gem::Package::NonSeekableIO
- Gem::Package::Old
- Gem::Package::PathError
- Gem::Package::TarHeader
- Gem::Package::TarInvalidError
- Gem::Package::TarReader
- Gem::Package::TarReader::Entry
- Gem::Package::TarReader::UnexpectedEOF
- Gem::Package::TarTestCase
- Gem::Package::TarWriter
- Gem::Package::TarWriter::BoundedStream
- Gem::Package::TarWriter::FileOverflow
- Gem::Package::TarWriter::RestrictedStream
- Gem::Package::TooLongFileName
- Gem::PackageTask
- Gem::PathSupport
- Gem::Platform
- Gem::PlatformMismatch
- Gem::RemoteError
- Gem::RemoteFetcher
- Gem::RemoteFetcher::FetchError
- Gem::RemoteFetcher::UnknownHostError
- Gem::RemoteInstallationCancelled
- Gem::RemoteInstallationSkipped
- Gem::RemoteSourceException
- Gem::Request::ConnectionPools
- Gem::Request::ConnectionPools::Net
- Gem::RequestSet
- Gem::RequestSet::GemDependencyAPI
- Gem::RequestSet::Lockfile
- Gem::RequestSet::Lockfile::ParseError
- Gem::RequestSet::Lockfile::Parser
- Gem::RequestSet::Lockfile::Tokenizer
- Gem::Requirement
- Gem::Requirement::BadRequirementError
- Gem::Resolver
- Gem::Resolver::APISet
- Gem::Resolver::APISpecification
- Gem::Resolver::ActivationRequest
- Gem::Resolver::BestSet
- Gem::Resolver::ComposedSet
- Gem::Resolver::Conflict
- Gem::Resolver::CurrentSet
- Gem::Resolver::DependencyRequest
- Gem::Resolver::GitSet
- Gem::Resolver::GitSpecification
- Gem::Resolver::IndexSet
- Gem::Resolver::IndexSpecification
- Gem::Resolver::InstalledSpecification
- Gem::Resolver::InstallerSet
- Gem::Resolver::LocalSpecification
- Gem::Resolver::LockSet
- Gem::Resolver::LockSpecification
- Gem::Resolver::Molinillo
- Gem::Resolver::Molinillo::CircularDependencyError
- Gem::Resolver::Molinillo::Delegates
- Gem::Resolver::Molinillo::Delegates::ResolutionState
- Gem::Resolver::Molinillo::Delegates::SpecificationProvider
- Gem::Resolver::Molinillo::DependencyGraph
- Gem::Resolver::Molinillo::DependencyGraph::Action
- Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular
- Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge
- Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed
- Gem::Resolver::Molinillo::DependencyGraph::Log
- Gem::Resolver::Molinillo::DependencyGraph::Tag
- Gem::Resolver::Molinillo::DependencyGraph::Vertex
- Gem::Resolver::Molinillo::DependencyState
- Gem::Resolver::Molinillo::NoSuchDependencyError
- Gem::Resolver::Molinillo::PossibilityState
- Gem::Resolver::Molinillo::ResolutionState
- Gem::Resolver::Molinillo::Resolver
- Gem::Resolver::Molinillo::Resolver::Resolution
- Gem::Resolver::Molinillo::ResolverError
- Gem::Resolver::Molinillo::SpecificationProvider
- Gem::Resolver::Molinillo::UI
- Gem::Resolver::Molinillo::VersionConflict
- Gem::Resolver::RequirementList
- Gem::Resolver::Set
- Gem::Resolver::SourceSet
- Gem::Resolver::SpecSpecification
- Gem::Resolver::Specification
- Gem::Resolver::Stats
- Gem::Resolver::VendorSet
- Gem::Resolver::VendorSpecification
- Gem::RubyVersionMismatch
- Gem::RuntimeRequirementNotMetError
- Gem::S3URISigner
- Gem::S3URISigner::ConfigurationError
- Gem::S3URISigner::InstanceProfileError
- Gem::SafeYAML
- Gem::Security
- Gem::Security::Exception
- Gem::Security::Policy
- Gem::Security::Signer
- Gem::Security::TrustDir
- Gem::SecurityOption
- Gem::Server
- Gem::SilentUI
- Gem::Source
- Gem::Source::Git
- Gem::Source::Installed
- Gem::Source::Local
- Gem::Source::Lock
- Gem::Source::SpecificFile
- Gem::Source::Vendor
- Gem::SourceFetchProblem
- Gem::SourceList
- Gem::SpecFetcher
- Gem::SpecificGemNotFoundException
- Gem::Specification
- Gem::SpecificationPolicy
- Gem::StreamUI
- Gem::StreamUI::SilentDownloadReporter
- Gem::StreamUI::SilentProgressReporter
- Gem::StreamUI::SimpleProgressReporter
- Gem::StreamUI::ThreadedDownloadReporter
- Gem::StreamUI::VerboseProgressReporter
- Gem::StubSpecification
- Gem::SystemExitException
- Gem::TestCase
- Gem::TestCase::SpecFetcherSetup
- Gem::TestCase::StaticSet
- Gem::Text
- Gem::UninstallError
- Gem::Uninstaller
- Gem::UnsatisfiableDependencyError
- Gem::UriFormatter
- Gem::UriParser
- Gem::UriParsing
- Gem::UserInteraction
- Gem::Util
- Gem::Validator
- Gem::VerificationError
- Gem::Version
- Gem::VersionOption
- Kernel
- Object
- OpenSSL
- TempIO
- YAML::Syck
- YAML::Syck

No matching classes.

# Gem::TestCase

RubyGemTestCase provides a variety of methods for testing rubygems and gem-related behavior in a sandbox. Through RubyGemTestCase you can install and uninstall gems, fetch remote gems through a stub fetcher and be assured your normal set of gems is not affected.

### Constants

SPECIFICATIONS
TEST_PATH

### Public Class Methods

java_platform?() click to toggle source

Is this test being run on a Java platform?

                   # File rubygems/test_case.rb, line 1132
    def self.java_platform?
      Gem.java_platform?
    end

make_command() click to toggle source

Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ or Borland it will return ‘nmake’. On all other platforms, including Cygwin, it will return ‘make’.

                   # File rubygems/test_case.rb, line 1164
    def self.make_command
      ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
    end

process_based_port() click to toggle source

Allows tests to use a random (but controlled) port number instead of a hardcoded one. This helps CI tools when running parallels builds on the same builder slave.

                   # File rubygems/test_case.rb, line 1197
    def self.process_based_port
      @@process_based_port ||= 8000 + $$ % 1000
    end

rubybin() click to toggle source

Finds the path to the Ruby executable

                   # File rubygems/test_case.rb, line 1230
    def self.rubybin
      ruby = ENV["RUBY"]
      return ruby if ruby
      ruby = "ruby"
      rubyexe = "#{ruby}.exe"

      3.times do
        if File.exist? ruby and File.executable? ruby and !File.directory? ruby
          return File.expand_path(ruby)
        end
        if File.exist? rubyexe and File.executable? rubyexe
          return File.expand_path(rubyexe)
        end
        ruby = File.join("..", ruby)
      end

      begin
        require "rbconfig"
        File.join(RbConfig::CONFIG["bindir"],
                  RbConfig::CONFIG["ruby_install_name"] +
                  RbConfig::CONFIG["EXEEXT"])
      rescue LoadError
        "ruby"
      end
    end

vc_windows?() click to toggle source

Returns whether or not we’re on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw, etc.

                   # File rubygems/test_case.rb, line 1147
    def self.vc_windows?
      RUBY_PLATFORM.match('mswin')
    end

win_platform?() click to toggle source

Is this test being run on a Windows platform?

                   # File rubygems/test_case.rb, line 1118
    def self.win_platform?
      Gem.win_platform?
    end

### Public Instance Methods

add_to_fetcher(spec, path=nil, repo=@gem_repo) click to toggle source

Add `spec` to +@fetcher+ serving the data in the file `path`. `repo` indicates which repo to make `spec` appear to be in.

                   # File rubygems/test_case.rb, line 997
    def add_to_fetcher(spec, path=nil, repo=@gem_repo)
      path ||= spec.cache_file
      @fetcher.data["#{@gem_repo}gems/#{spec.file_name}"] = read_binary(path)
    end

all_spec_names() click to toggle source

                   # File rubygems/test_case.rb, line 646
    def all_spec_names
      Gem::Specification.map(&:full_name)
    end

ask_if_ok(spec) click to toggle source

                   # File rubygems/test_case.rb, line 599
    def ask_if_ok(spec)
      true
    end

assert_activate(expected, *specs) click to toggle source

                   # File rubygems/test_case.rb, line 101
    def assert_activate(expected, *specs)
      specs.each do |spec|
        case spec
        when String then
          Gem::Specification.find_by_name(spec).activate
        when Gem::Specification then
          spec.activate
        else
          flunk spec.inspect
        end
      end

      loaded = Gem.loaded_specs.values.map(&:full_name)

      assert_equal expected.sort, loaded.sort if expected
    end

assert_contains_make_command(target, output, msg = nil) click to toggle source

                   # File rubygems/test_case.rb, line 251
    def assert_contains_make_command(target, output, msg = nil)
      if output.match(/\n/)
        msg = message(msg) do
          'Expected output containing make command "%s": %s' % [
            ('%s %s' % [make_command, target]).rstrip,
            output.inspect
          ]
        end
      else
        msg = message(msg) do
          'Expected make command "%s": %s' % [
            ('%s %s' % [make_command, target]).rstrip,
            output.inspect
          ]
        end
      end

      assert scan_make_command_lines(output).any? { |line|
        make = parse_make_command_line(line)

        if make[:targets].include?(target)
          yield make, line if block_given?
          true
        else
          false
        end
      }, msg
    end

assert_directory_exists(path, msg = nil) click to toggle source

                   # File rubygems/test_case.rb, line 124
    def assert_directory_exists(path, msg = nil)
      msg = message(msg) { "Expected path '#{path}' to be a directory" }
      assert_path_exists path
      assert File.directory?(path), msg
    end

assert_path_exists(path, msg = nil) click to toggle source

TODO: move to minitest

                   # File rubygems/test_case.rb, line 119
    def assert_path_exists(path, msg = nil)
      msg = message(msg) { "Expected path '#{path}' to exist" }
      assert File.exist?(path), msg
    end

bindir(value) click to toggle source

Sets the bindir entry in RbConfig::CONFIG to `value` and restores the original value when the block ends

                   # File rubygems/test_case.rb, line 173
    def bindir(value)
      with_clean_path_to_ruby do
        bindir = RbConfig::CONFIG['bindir']

        if value
          RbConfig::CONFIG['bindir'] = value
        else
          RbConfig::CONFIG.delete 'bindir'
        end

        begin
          yield
        ensure
          if bindir
            RbConfig::CONFIG['bindir'] = bindir
          else
            RbConfig::CONFIG.delete 'bindir'
          end
        end
      end
    end

build_rake_in(good=true) click to toggle source

Allows the proper version of `rake` to be used for the test.

                   # File rubygems/test_case.rb, line 1211
    def build_rake_in(good=true)
      gem_ruby = Gem.ruby
      Gem.ruby = @@ruby
      env_rake = ENV["rake"]
      rake = (good ? @@good_rake : @@bad_rake)
      ENV["rake"] = rake
      yield rake
    ensure
      Gem.ruby = gem_ruby
      if env_rake
        ENV["rake"] = env_rake
      else
        ENV.delete("rake")
      end
    end

common_installer_setup() click to toggle source

                   # File rubygems/test_case.rb, line 470
    def common_installer_setup
      common_installer_teardown

      Gem.post_build do |installer|
        @post_build_hook_arg = installer
        true
      end

      Gem.post_install do |installer|
        @post_install_hook_arg = installer
      end

      Gem.post_uninstall do |uninstaller|
        @post_uninstall_hook_arg = uninstaller
      end

      Gem.pre_install do |installer|
        @pre_install_hook_arg = installer
        true
      end

      Gem.pre_uninstall do |uninstaller|
        @pre_uninstall_hook_arg = uninstaller
      end
    end

common_installer_teardown() click to toggle source

                   # File rubygems/test_case.rb, line 496
    def common_installer_teardown
      Gem.post_build_hooks.clear
      Gem.post_install_hooks.clear
      Gem.done_installing_hooks.clear
      Gem.post_reset_hooks.clear
      Gem.post_uninstall_hooks.clear
      Gem.pre_install_hooks.clear
      Gem.pre_reset_hooks.clear
      Gem.pre_uninstall_hooks.clear
    end

enable_shared(value) click to toggle source

Sets the ENABLE_SHARED entry in RbConfig::CONFIG to `value` and restores the original value when the block ends

                   # File rubygems/test_case.rb, line 134
    def enable_shared(value)
      enable_shared = RbConfig::CONFIG['ENABLE_SHARED']
      RbConfig::CONFIG['ENABLE_SHARED'] = value

      yield
    ensure
      if enable_shared
        RbConfig::CONFIG['enable_shared'] = enable_shared
      else
        RbConfig::CONFIG.delete 'enable_shared'
      end
    end

exeext(value) click to toggle source

Sets the EXEEXT entry in RbConfig::CONFIG to `value` and restores the original value when the block ends

                   # File rubygems/test_case.rb, line 199
    def exeext(value)
      exeext = RbConfig::CONFIG['EXEEXT']

      if value
        RbConfig::CONFIG['EXEEXT'] = value
      else
        RbConfig::CONFIG.delete 'EXEEXT'
      end

      yield
    ensure
      if exeext
        RbConfig::CONFIG['EXEEXT'] = exeext
      else
        RbConfig::CONFIG.delete 'EXEEXT'
      end
    end

git_gem(name = 'a', version = 1) click to toggle source

A #git_gem is used with a gem dependencies file. The gem created here has no files, just a gem specification for the given `name` and `version`.

Yields the `specification` to the block, if given

                   # File rubygems/test_case.rb, line 513
    def git_gem(name = 'a', version = 1)
      have_git?

      directory = File.join 'git', name
      directory = File.expand_path directory

      git_spec = Gem::Specification.new name, version do |specification|
        yield specification if block_given?
      end

      FileUtils.mkdir_p directory

      gemspec = "#{name}.gemspec"

      File.open File.join(directory, gemspec), 'w' do |io|
        io.write git_spec.to_ruby
      end

      head = nil

      Dir.chdir directory do
        unless File.exist? '.git'
          system @git, 'init', '--quiet'
          system @git, 'config', 'user.name',  'RubyGems Tests'
          system @git, 'config', 'user.email', 'rubygems@example'
        end

        system @git, 'add', gemspec
        system @git, 'commit', '-a', '-m', 'a non-empty commit message', '--quiet'
        head = Gem::Util.popen(@git, 'rev-parse', 'master').strip
      end

      return name, git_spec.version, directory, head
    end

have_git?() click to toggle source

Skips this test unless you have a git executable

                   # File rubygems/test_case.rb, line 551
    def have_git?
      return if in_path? @git

      skip 'cannot find git executable, use GIT environment variable to set'
    end

install_default_gems(*specs) click to toggle source

Installs the provided default specs including writing the spec file

                   # File rubygems/test_case.rb, line 746
    def install_default_gems(*specs)
      install_default_specs(*specs)

      specs.each do |spec|
        File.open spec.loaded_from, 'w' do |io|
          io.write spec.to_ruby_for_cache
        end
      end
    end

install_default_specs(*specs) click to toggle source

Install the provided default specs

                   # File rubygems/test_case.rb, line 759
    def install_default_specs(*specs)
      specs.each do |spec|
        installer = Gem::Installer.for_spec(spec, :install_as_default => true)
        installer.install
        Gem.register_default_spec(spec)
      end
    end

install_gem(spec, options = {}) click to toggle source

Builds and installs the Gem::Specification `spec`

                   # File rubygems/test_case.rb, line 568
    def install_gem(spec, options = {})
      require 'rubygems/installer'

      gem = File.join @tempdir, "gems", "#{spec.full_name}.gem"

      unless File.exist? gem
        use_ui Gem::MockGemUi.new do
          Dir.chdir @tempdir do
            Gem::Package.build spec
          end
        end

        gem = File.join(@tempdir, File.basename(spec.cache_file)).tap(&Gem::UNTAINT)
      end

      Gem::Installer.at(gem, options.merge({:wrappers => true})).install
    end

install_gem_user(spec) click to toggle source

Builds and installs the Gem::Specification `spec` into the user dir

                   # File rubygems/test_case.rb, line 589
    def install_gem_user(spec)
      install_gem spec, :user_install => true
    end

install_specs(*specs) click to toggle source

Install the provided specs

                   # File rubygems/test_case.rb, line 735
    def install_specs(*specs)
      specs.each do |spec|
        Gem::Installer.for_spec(spec).install
      end

      Gem.searcher = nil
    end

java_platform?() click to toggle source

Is this test being run on a Java platform?

                   # File rubygems/test_case.rb, line 1139
    def java_platform?
      Gem.java_platform?
    end

loaded_spec_names() click to toggle source

                   # File rubygems/test_case.rb, line 767
    def loaded_spec_names
      Gem.loaded_specs.values.map(&:full_name).sort
    end

make_command() click to toggle source

Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ or Borland it will return ‘nmake’. On all other platforms, including Cygwin, it will return ‘make’.

                   # File rubygems/test_case.rb, line 1173
    def make_command
      ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
    end

mu_pp(obj) click to toggle source

Enables pretty-print for all tests

                   # File rubygems/test_case.rb, line 608
    def mu_pp(obj)
      s = String.new
      s = PP.pp obj, s
      s = s.force_encoding(Encoding.default_external)
      s.chomp
    end

new_default_spec(name, version, deps = nil, *files) click to toggle source

                   # File rubygems/test_case.rb, line 785
    def new_default_spec(name, version, deps = nil, *files)
      spec = util_spec name, version, deps

      spec.loaded_from = File.join(@default_spec_dir, spec.spec_name)
      spec.files = files

      lib_dir = File.join(@tempdir, "default_gems", "lib")
      lib_dir.instance_variable_set(:@gem_prelude_index, lib_dir)
      $LOAD_PATH.unshift(lib_dir)
      files.each do |file|
        rb_path = File.join(lib_dir, file)
        FileUtils.mkdir_p(File.dirname(rb_path))
        File.open(rb_path, "w") do |rb|
          rb << "# #{file}"
        end
      end

      spec
    end

nmake_found?() click to toggle source

Returns whether or not the nmake command could be found.

                   # File rubygems/test_case.rb, line 1180
    def nmake_found?
      system('nmake /? 1>NUL 2>&1')
    end

parse_make_command_line(line) click to toggle source

                   # File rubygems/test_case.rb, line 227
    def parse_make_command_line(line)
      command, *args = line.shellsplit

      targets = []
      macros = {}

      args.each do |arg|
        case arg
        when /\A(\w+)=/
          macros[$1] = $'
        else
          targets << arg
        end
      end

      targets << '' if targets.empty?

      {
        :command => command,
        :targets => targets,
        :macros => macros,
      }
    end

process_based_port() click to toggle source

See ::process_based_port

                   # File rubygems/test_case.rb, line 1204
    def process_based_port
      self.class.process_based_port
    end

quick_gem(name, version='2') click to toggle source

Creates a Gem::Specification with a minimum of extra work. `name` and `version` are the gem’s name and version, platform, author, email, homepage, summary and description are defaulted. The specification is yielded for customization.

The gem is added to the installed gems in +@gemhome+ and the runtime.

Use this with write_file to build an installed gem.

                   # File rubygems/test_case.rb, line 660
    def quick_gem(name, version='2')
      require 'rubygems/specification'

      spec = Gem::Specification.new do |s|
        s.platform    = Gem::Platform::RUBY
        s.name        = name
        s.version     = version
        s.author      = 'A User'
        s.email       = 'example@example.com'
        s.homepage    = 'http://example.com'
        s.summary     = "this is a summary"
        s.description = "This is a test description"

        yield(s) if block_given?
      end

      Gem::Specification.map # HACK: force specs to (re-)load before we write

      written_path = write_file spec.spec_file do |io|
        io.write spec.to_ruby_for_cache
      end

      spec.loaded_from = written_path

      Gem::Specification.reset

      return spec
    end

read_binary(path) click to toggle source

Reads a binary file at `path`

                   # File rubygems/test_case.rb, line 627
    def read_binary(path)
      Gem.read_binary path
    end

read_cache(path) click to toggle source

Reads a Marshal file at `path`

                   # File rubygems/test_case.rb, line 618
    def read_cache(path)
      File.open path.dup.tap(&Gem::UNTAINT), 'rb' do |io|
        Marshal.load io.read
      end
    end

refute_path_exists(path, msg = nil) click to toggle source

TODO: move to minitest

                   # File rubygems/test_case.rb, line 218
    def refute_path_exists(path, msg = nil)
      msg = message(msg) { "Expected path '#{path}' to not exist" }
      refute File.exist?(path), msg
    end

save_loaded_features() click to toggle source

                   # File rubygems/test_case.rb, line 775
    def save_loaded_features
      old_loaded_features = $LOADED_FEATURES.dup
      yield
    ensure
      prefix = File.dirname(__FILE__) + "/"
      new_features = ($LOADED_FEATURES - old_loaded_features)
      old_loaded_features.concat(new_features.select {|f| f.rindex(prefix, 0)})
      $LOADED_FEATURES.replace old_loaded_features
    end

scan_make_command_lines(output) click to toggle source

                   # File rubygems/test_case.rb, line 223
    def scan_make_command_lines(output)
      output.scan(/^#{Regexp.escape make_command}(?:[[:blank:]].*)?$/)
    end

setup() click to toggle source

setup prepares a sandboxed location to install gems. All installs are directed to a temporary directory. All install plugins are removed.

If the `RUBY` environment variable is set the given path is used for Gem.ruby. The local platform is set to `i386-mswin32` for Windows or `i686-darwin8.10.1` otherwise.

                   # File rubygems/test_case.rb, line 293
    def setup
      super

      @orig_env = ENV.to_hash

      ENV['GEM_VENDOR'] = nil
      ENV['GEMRC'] = nil
      ENV['SOURCE_DATE_EPOCH'] = nil

      @current_dir = Dir.pwd
      @fetcher     = nil

      @back_ui                       = Gem::DefaultUserInteraction.ui
      @ui                            = Gem::MockGemUi.new
      # This needs to be a new instance since we call use_ui(@ui) when we want to
      # capture output
      Gem::DefaultUserInteraction.ui = Gem::MockGemUi.new

      tmpdir = File.realpath Dir.tmpdir
      tmpdir.tap(&Gem::UNTAINT)

      @tempdir = File.join(tmpdir, "test_rubygems_#{$$}")
      @tempdir.tap(&Gem::UNTAINT)

      FileUtils.mkdir_p @tempdir

      # This makes the tempdir consistent on Windows.
      # Dir.tmpdir may return short path name, but Dir[Dir.tmpdir] returns long
      # path name. https://bugs.ruby-lang.org/issues/10819
      # File.expand_path or File.realpath doesn't convert path name to long path
      # name. Only Dir[] (= Dir.glob) works.
      # Short and long path name is specific to Windows filesystem.
      if win_platform?
        @tempdir = Dir[@tempdir][0]
        @tempdir.tap(&Gem::UNTAINT)
      end

      @gemhome  = File.join @tempdir, 'gemhome'
      @userhome = File.join @tempdir, 'userhome'
      ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache'

      @orig_ruby = if ENV['RUBY']
                     ruby = Gem.ruby
                     Gem.ruby = ENV['RUBY']
                     ruby
                   end

      @git = ENV['GIT'] || 'git'

      Gem.ensure_gem_subdirectories @gemhome

      @orig_LOAD_PATH = $LOAD_PATH.dup
      $LOAD_PATH.map! do |s|
        expand_path = File.realpath(s) rescue File.expand_path(s)
        if expand_path != s
          expand_path.tap(&Gem::UNTAINT)
          if s.instance_variable_defined?(:@gem_prelude_index)
            expand_path.instance_variable_set(:@gem_prelude_index, expand_path)
          end
          expand_path.freeze if s.frozen?
          s = expand_path
        end
        s
      end

      Dir.chdir @tempdir

      ENV['HOME'] = @userhome
      Gem.instance_variable_set :@user_home, nil
      Gem.instance_variable_set :@gemdeps, nil
      Gem.instance_variable_set :@env_requirements_by_name, nil
      Gem.send :remove_instance_variable, :@ruby_version if
        Gem.instance_variables.include? :@ruby_version

      FileUtils.mkdir_p @gemhome
      FileUtils.mkdir_p @userhome

      ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = PRIVATE_KEY_PASSPHRASE

      @default_dir = File.join @tempdir, 'default'
      @default_spec_dir = File.join @default_dir, "specifications", "default"
      if Gem.java_platform?
        @orig_default_gem_home = RbConfig::CONFIG['default_gem_home']
        RbConfig::CONFIG['default_gem_home'] = @default_dir
      else
        Gem.instance_variable_set(:@default_dir, @default_dir)
      end
      FileUtils.mkdir_p @default_spec_dir

      Gem::Specification.unresolved_deps.clear
      Gem.use_paths(@gemhome)

      Gem::Security.reset

      Gem.loaded_specs.clear
      Gem.clear_default_specs
      Bundler.reset!

      Gem.configuration.verbose = true
      Gem.configuration.update_sources = true

      Gem::RemoteFetcher.fetcher = Gem::FakeFetcher.new

      @gem_repo = "http://gems.example.com/"
      @uri = URI.parse @gem_repo
      Gem.sources.replace [@gem_repo]

      Gem.searcher = nil
      Gem::SpecFetcher.fetcher = nil

      @orig_arch = RbConfig::CONFIG['arch']

      if win_platform?
        util_set_arch 'i386-mswin32'
      else
        util_set_arch 'i686-darwin8.10.1'
      end

      @orig_hooks = {}
      %w[post_install_hooks done_installing_hooks post_uninstall_hooks pre_uninstall_hooks pre_install_hooks pre_reset_hooks post_reset_hooks post_build_hooks].each do |name|
        @orig_hooks[name] = Gem.send(name).dup
      end

      @marshal_version = "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
      @orig_LOADED_FEATURES = $LOADED_FEATURES.dup
    end

teardown() click to toggle source

teardown restores the process to its original state and removes the tempdir

                   # File rubygems/test_case.rb, line 424
    def teardown
      $LOAD_PATH.replace @orig_LOAD_PATH if @orig_LOAD_PATH
      if @orig_LOADED_FEATURES
        if @orig_LOAD_PATH
          paths = @orig_LOAD_PATH.map {|path| File.join(File.expand_path(path), "/")}
          ($LOADED_FEATURES - @orig_LOADED_FEATURES).each do |feat|
            unless paths.any? {|path| feat.start_with?(path)}
              $LOADED_FEATURES.delete(feat)
            end
          end
        else
          $LOADED_FEATURES.replace @orig_LOADED_FEATURES
        end
      end

      RbConfig::CONFIG['arch'] = @orig_arch

      if defined? Gem::RemoteFetcher
        Gem::RemoteFetcher.fetcher = nil
      end

      Dir.chdir @current_dir

      FileUtils.rm_rf @tempdir

      ENV.replace(@orig_env)

      Gem.ruby = @orig_ruby if @orig_ruby

      if Gem.java_platform?
        RbConfig::CONFIG['default_gem_home'] = @orig_default_gem_home
      else
        Gem.instance_variable_set :@default_dir, nil
      end

      Gem::Specification._clear_load_cache
      Gem::Specification.unresolved_deps.clear
      Gem::refresh

      @orig_hooks.each do |name, hooks|
        Gem.send(name).replace hooks
      end

      @back_ui.close
    end

uninstall_gem(spec) click to toggle source

Uninstalls the Gem::Specification `spec`

                   # File rubygems/test_case.rb, line 595
    def uninstall_gem(spec)
      require 'rubygems/uninstaller'

      Class.new(Gem::Uninstaller) do
        def ask_if_ok(spec)
          true
        end
      end.new(spec.name, :executables => true, :user_install => true).uninstall
    end

unresolved_names() click to toggle source

                   # File rubygems/test_case.rb, line 771
    def unresolved_names
      Gem::Specification.unresolved_deps.values.map(&:to_s).sort
    end

util_build_gem(spec) click to toggle source

Builds a gem from `spec` and places it in `File.join @gemhome, 'cache'`. Automatically creates files based on `spec.files`

                   # File rubygems/test_case.rb, line 693
    def util_build_gem(spec)
      dir = spec.gem_dir
      FileUtils.mkdir_p dir

      Dir.chdir dir do
        spec.files.each do |file|
          next if File.exist? file
          FileUtils.mkdir_p File.dirname(file)

          File.open file, 'w' do |fp|
            fp.puts "# #{file}"
          end
        end

        use_ui Gem::MockGemUi.new do
          Gem::Package.build spec
        end

        cache = spec.cache_file
        FileUtils.mv File.basename(cache), cache
      end
    end

util_clear_RUBY_VERSION() click to toggle source

                   # File rubygems/test_case.rb, line 1106
    def util_clear_RUBY_VERSION
      Object.send :remove_const, :RUBY_VERSION
      Object.send :remove_const, :RUBY_PATCHLEVEL     if defined?(RUBY_PATCHLEVEL)
      Object.send :remove_const, :RUBY_REVISION       if defined?(RUBY_REVISION)
      Object.send :remove_const, :RUBY_DESCRIPTION    if defined?(RUBY_DESCRIPTION)
      Object.send :remove_const, :RUBY_ENGINE
      Object.send :remove_const, :RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)
    end

util_clear_gems() click to toggle source

Removes all installed gems from +@gemhome+.

                   # File rubygems/test_case.rb, line 724
    def util_clear_gems
      FileUtils.rm_rf File.join(@gemhome, "gems")
      FileUtils.mkdir File.join(@gemhome, "gems")
      FileUtils.rm_rf File.join(@gemhome, "specifications")
      FileUtils.mkdir File.join(@gemhome, "specifications")
      Gem::Specification.reset
    end

util_gem(name, version, deps = nil, &block) click to toggle source

Creates a gem with `name`, `version` and `deps`. The specification will be yielded before gem creation for customization. The gem will be placed in `File.join @tempdir, 'gems'`. The specification and .gem file location are returned.

                   # File rubygems/test_case.rb, line 857
    def util_gem(name, version, deps = nil, &block)
      if deps
        block = proc do |s|
          # Since Hash#each is unordered in 1.8, sort
          # the keys and iterate that way so the tests are
          # deterministic on all implementations.
          deps.keys.sort.each do |n|
            s.add_dependency n, (deps[n] || '>= 0')
          end
        end
      end

      spec = quick_gem(name, version, &block)

      util_build_gem spec

      cache_file = File.join @tempdir, 'gems', "#{spec.original_name}.gem"
      FileUtils.mkdir_p File.dirname cache_file
      FileUtils.mv spec.cache_file, cache_file
      FileUtils.rm spec.spec_file

      spec.loaded_from = nil

      [spec, cache_file]
    end

util_gzip(data) click to toggle source

Gzips `data`.

                   # File rubygems/test_case.rb, line 886
    def util_gzip(data)
      out = StringIO.new

      Zlib::GzipWriter.wrap out do |io|
        io.write data
      end

      out.string
    end

util_make_gems(prerelease = false) click to toggle source

Creates several default gems which all have a lib/code.rb file. The gems are not installed but are available in the cache dir.

+@a1+

  gem a version 1, this is the best-described gem.

+@a2+

  gem a version 2

+@a3a

  gem a version 3.a

+@a_evil9+

  gem a_evil version 9, use this to ensure similarly-named gems don’t collide with a.

+@b2+

  gem b version 2

+@c1_2+

  gem c version 1.2

+@pl1+

  gem pl version 1, this gem has a legacy platform of i386-linux.

Additional `prerelease` gems may also be created:

+@a2_pre+

  gem a version 2.a

TODO: nuke this and fix tests. this should speed up a lot

                   # File rubygems/test_case.rb, line 914
      def util_make_gems(prerelease = false)
        @a1 = quick_gem 'a', '1' do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.date = Gem::Specification::TODAY - 86400
          s.homepage = 'http://a.example.com'
          s.email = %w[example@example.com example2@example.com]
          s.authors = %w[Example Example2]
          s.description = <<-DESC
    This line is really, really long.  So long, in fact, that it is more than eighty characters long!  The purpose of this line is for testing wrapping behavior because sometimes people don't wrap their text to eighty characters.  Without the wrapping, the text might not look good in the RSS feed.

    Also, a list:
      * An entry that\'s actually kind of sort
      * an entry that\'s really long, which will probably get wrapped funny.  That's ok, somebody wasn't thinking straight when they made it more than eighty characters.
          DESC
        end

        init = proc do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
        end

        @a2      = quick_gem('a', '2',      &init)
        @a3a     = quick_gem('a', '3.a',    &init)
        @a_evil9 = quick_gem('a_evil', '9', &init)
        @b2      = quick_gem('b', '2',      &init)
        @c1_2    = quick_gem('c', '1.2',    &init)
        @x       = quick_gem('x', '1',      &init)
        @dep_x   = quick_gem('dep_x', '1') do |s|
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.add_dependency 'x', '>= 1'
        end

        @pl1 = quick_gem 'pl', '1' do |s| # l for legacy
          s.files = %w[lib/code.rb]
          s.require_paths = %w[lib]
          s.platform = Gem::Platform.new 'i386-linux'
          s.instance_variable_set :@original_platform, 'i386-linux'
        end

        if prerelease
          @a2_pre = quick_gem('a', '2.a', &init)
          write_file File.join(*%W[gems #{@a2_pre.original_name} lib code.rb])
          util_build_gem @a2_pre
        end

        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 #{@a_evil9.original_name} lib code.rb])
        write_file File.join(*%W[gems #{@b2.original_name}      lib code.rb])
        write_file File.join(*%W[gems #{@c1_2.original_name}    lib code.rb])
        write_file File.join(*%W[gems #{@pl1.original_name}     lib code.rb])
        write_file File.join(*%W[gems #{@x.original_name}       lib code.rb])
        write_file File.join(*%W[gems #{@dep_x.original_name}   lib code.rb])

        [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2, @pl1, @x, @dep_x].each do |spec|
          util_build_gem spec
        end

        FileUtils.rm_r File.join(@gemhome, "gems", @pl1.original_name)
      end

util_remove_gem(spec) click to toggle source

                   # File rubygems/test_case.rb, line 716
    def util_remove_gem(spec)
      FileUtils.rm_rf spec.cache_file
      FileUtils.rm_rf spec.spec_file
    end

util_restore_RUBY_VERSION() click to toggle source

                   # File rubygems/test_case.rb, line 1091
    def util_restore_RUBY_VERSION
      util_clear_RUBY_VERSION

      Object.const_set :RUBY_VERSION,        @RUBY_VERSION
      Object.const_set :RUBY_PATCHLEVEL,     @RUBY_PATCHLEVEL  if
        defined?(@RUBY_PATCHLEVEL)
      Object.const_set :RUBY_REVISION,       @RUBY_REVISION    if
        defined?(@RUBY_REVISION)
      Object.const_set :RUBY_DESCRIPTION,    @RUBY_DESCRIPTION if
        defined?(@RUBY_DESCRIPTION)
      Object.const_set :RUBY_ENGINE,         @RUBY_ENGINE
      Object.const_set :RUBY_ENGINE_VERSION, @RUBY_ENGINE_VERSION if
        defined?(@RUBY_ENGINE_VERSION)
    end

util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil, description = nil, engine = "ruby", engine_version = nil) click to toggle source

                   # File rubygems/test_case.rb, line 1069
    def util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil, description = nil, engine = "ruby", engine_version = nil)
      if Gem.instance_variables.include? :@ruby_version
        Gem.send :remove_instance_variable, :@ruby_version
      end

      @RUBY_VERSION        = RUBY_VERSION
      @RUBY_PATCHLEVEL     = RUBY_PATCHLEVEL     if defined?(RUBY_PATCHLEVEL)
      @RUBY_REVISION       = RUBY_REVISION       if defined?(RUBY_REVISION)
      @RUBY_DESCRIPTION    = RUBY_DESCRIPTION    if defined?(RUBY_DESCRIPTION)
      @RUBY_ENGINE         = RUBY_ENGINE
      @RUBY_ENGINE_VERSION = RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)

      util_clear_RUBY_VERSION

      Object.const_set :RUBY_VERSION,        version
      Object.const_set :RUBY_PATCHLEVEL,     patchlevel     if patchlevel
      Object.const_set :RUBY_REVISION,       revision       if revision
      Object.const_set :RUBY_DESCRIPTION,    description    if description
      Object.const_set :RUBY_ENGINE,         engine
      Object.const_set :RUBY_ENGINE_VERSION, engine_version if engine_version
    end

util_set_arch(arch) click to toggle source

Set the platform to `arch`

                   # File rubygems/test_case.rb, line 981
    def util_set_arch(arch)
      RbConfig::CONFIG['arch'] = arch
      platform = Gem::Platform.new arch

      Gem.instance_variable_set :@platforms, nil
      Gem::Platform.instance_variable_set :@local, nil

      yield if block_given?

      platform
    end

util_setup_spec_fetcher(*specs) click to toggle source

Sets up Gem::SpecFetcher to return information from the gems in `specs`.

                   # File rubygems/test_case.rb, line 1005
    def util_setup_spec_fetcher(*specs)
      all_specs = Gem::Specification.to_a + specs
      Gem::Specification._resort! all_specs

      spec_fetcher = Gem::SpecFetcher.fetcher

      prerelease, all = all_specs.partition { |spec| spec.version.prerelease?  }
      latest = Gem::Specification._latest_specs all_specs

      spec_fetcher.specs[@uri] = []
      all.each do |spec|
        spec_fetcher.specs[@uri] << spec.name_tuple
      end

      spec_fetcher.latest_specs[@uri] = []
      latest.each do |spec|
        spec_fetcher.latest_specs[@uri] << spec.name_tuple
      end

      spec_fetcher.prerelease_specs[@uri] = []
      prerelease.each do |spec|
        spec_fetcher.prerelease_specs[@uri] << spec.name_tuple
      end

      # HACK for test_download_to_cache
      unless Gem::RemoteFetcher === @fetcher
        v = Gem.marshal_version

        specs = all.map { |spec| spec.name_tuple }
        s_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic specs

        latest_specs = latest.map do |spec|
          spec.name_tuple
        end

        l_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic latest_specs

        prerelease_specs = prerelease.map { |spec| spec.name_tuple }
        p_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic prerelease_specs

        @fetcher.data["#{@gem_repo}specs.#{v}.gz"]            = s_zip
        @fetcher.data["#{@gem_repo}latest_specs.#{v}.gz"]     = l_zip
        @fetcher.data["#{@gem_repo}prerelease_specs.#{v}.gz"] = p_zip

        v = Gem.marshal_version

        all_specs.each do |spec|
          path = "#{@gem_repo}quick/Marshal.#{v}/#{spec.original_name}.gemspec.rz"
          data = Marshal.dump spec
          data_deflate = Zlib::Deflate.deflate data
          @fetcher.data[path] = data_deflate
        end
      end

      nil # force errors
    end

util_spec(name, version = 2, deps = nil, *files) click to toggle source

Creates a spec with `name`, `version`. `deps` can specify the dependency or a `block` can be given for full customization of the specification.

                   # File rubygems/test_case.rb, line 809
    def util_spec(name, version = 2, deps = nil, *files) # :yields: specification
      raise "deps or block, not both" if deps and block_given?

      spec = Gem::Specification.new do |s|
        s.platform    = Gem::Platform::RUBY
        s.name        = name
        s.version     = version
        s.author      = 'A User'
        s.email       = 'example@example.com'
        s.homepage    = 'http://example.com'
        s.summary     = "this is a summary"
        s.description = "This is a test description"

        s.files.push(*files) unless files.empty?

        yield s if block_given?
      end

      if deps
        # Since Hash#each is unordered in 1.8, sort the keys and iterate that
        # way so the tests are deterministic on all implementations.
        deps.keys.sort.each do |n|
          spec.add_dependency n, (deps[n] || '>= 0')
        end
      end

      unless files.empty?
        write_file spec.spec_file do |io|
          io.write spec.to_ruby_for_cache
        end

        util_build_gem spec

        cache_file = File.join @tempdir, 'gems', "#{spec.full_name}.gem"
        FileUtils.mkdir_p File.dirname cache_file
        FileUtils.mv spec.cache_file, cache_file
        FileUtils.rm spec.spec_file
      end

      return spec
    end

util_zip(data) click to toggle source

Deflates `data`

                   # File rubygems/test_case.rb, line 1065
    def util_zip(data)
      Zlib::Deflate.deflate data
    end

vc_windows?() click to toggle source

Returns whether or not we’re on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw, etc.

                   # File rubygems/test_case.rb, line 1155
    def vc_windows?
      RUBY_PLATFORM.match('mswin')
    end

vendordir(value) click to toggle source

Sets the vendordir entry in RbConfig::CONFIG to `value` and restores the original value when the block ends

                   # File rubygems/test_case.rb, line 151
    def vendordir(value)
      vendordir = RbConfig::CONFIG['vendordir']

      if value
        RbConfig::CONFIG['vendordir'] = value
      else
        RbConfig::CONFIG.delete 'vendordir'
      end

      yield
    ensure
      if vendordir
        RbConfig::CONFIG['vendordir'] = vendordir
      else
        RbConfig::CONFIG.delete 'vendordir'
      end
    end

wait_for_child_process_to_exit() click to toggle source

In case we’re building docs in a background process, this method waits for that process to exit (or if it’s already been reaped, or never happened, swallows the Errno::ECHILD error).

                   # File rubygems/test_case.rb, line 1187
    def wait_for_child_process_to_exit
      Process.wait if Process.respond_to?(:fork)
    rescue Errno::ECHILD
    end

win_platform?() click to toggle source

Is this test being run on a Windows platform?

                   # File rubygems/test_case.rb, line 1125
    def win_platform?
      Gem.win_platform?
    end

with_clean_path_to_ruby() click to toggle source

                   # File rubygems/test_case.rb, line 1256
    def with_clean_path_to_ruby
      orig_ruby = Gem.ruby

      Gem.instance_variable_set :@ruby, nil

      yield
    ensure
      Gem.instance_variable_set :@ruby, orig_ruby
    end

write_file(path) click to toggle source

Writes a binary file to `path` which is relative to +@gemhome+

                   # File rubygems/test_case.rb, line 634
    def write_file(path)
      path = File.join @gemhome, path unless Pathname.new(path).absolute?
      dir = File.dirname path
      FileUtils.mkdir_p dir unless File.directory? dir

      File.open path, 'wb' do |io|
        yield io if block_given?
      end

      path
    end