Wed Jun 1 12:34:00 2011 Kenta Murata <[email protected]>

* NEWS: add new features of bigdecimal.

require 'rubygems/defaults'

require "rubygems/dependency_list"

require 'rbconfig'

##

# RubyGems is the Ruby standard for publishing and managing third party

# -The RubyGems Team

module Gem

##

# Raised when RubyGems is unable to load or activate a gem. Contains the

end

end

RubyGemsPackageVersion = VERSION

RUBYGEMS_DIR = File.dirname File.expand_path(__FILE__)

@configuration = nil

@loaded_specs = {}

@platforms = []

@ruby = nil

@post_build_hooks ||= []

@post_install_hooks ||= []

@post_uninstall_hooks ||= []

@pre_uninstall_hooks ||= []

@pre_install_hooks ||= []

##

# Try to activate a gem containing +path+. Returns true if

# activated. Returns false if it can't find the path in a gem.

def self.try_activate path

# finds the _latest_ version... regardless of loaded specs and their deps

# TODO: use find_all and bork if ambiguous

return false unless spec

begin

rescue Gem::LoadError # this could fail due to gem dep collisions, go lax

end

return true

# Gem::Requirement and Gem::Version documentation.

def self.activate(dep, *requirements)

end

def self.unresolved_deps

Gem.path.each do |gemdir|

each_load_path all_partials(gemdir) do |load_path|

end

end

# Return all the partial paths in +gemdir+.

def self.all_partials(gemdir)

end

private_class_method :all_partials

##

# See if a given gem is available.

requirements = Gem::Requirement.default if requirements.empty?

end

end

##

# you to specify specific gem versions.

def self.bin_path(name, exec_name = nil, *requirements)

requirements = Gem::Requirement.default if

requirements.empty?

raise Gem::GemNotFoundException,

"can't find gem #{name} (#{requirements})" if specs.empty?

unless spec = specs.last

msg = "can't find gem #{name} (#{requirements}) with executable #{exec_name}"

raise Gem::GemNotFoundException, msg

end

end

##

# The path where gem executables are to be installed.

def self.bindir(install_dir=Gem.dir)

Gem.default_bindir

end

# mainly used by the unit tests to provide test isolation.

def self.clear_paths

@@source_index = nil

end

##

# The path to standard location of the user's .gemrc file.

def self.config_file

end

##

# package is not available as a gem, return nil.

def self.datadir(gem_name)

spec = @loaded_specs[gem_name]

return nil if spec.nil?

end

##

Zlib::Deflate.deflate data

end

##

# The path where gems are to be installed.

def self.dir

end

##

def self.each_load_path(partials)

partials.each do |gp|

spec.require_paths.each do |rp|

end

else

end

end

end

private_class_method :each_load_path

##

# Quietly ensure the named Gem directory contains all the proper

# subdirectories. If we can't create a directory due to a permission

# problem, then we will silently continue.

require 'fileutils'

end

end

}.flatten.select { |file| File.file? file.untaint }

end

# $LOAD_PATH might contain duplicate entries or reference

# the spec dirs directly, so we prune.

# it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at

# least on Win32).

#++

def self.find_home

end

if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then

end

end

rescue

else

end

end

# Zlib::GzipReader wrapper that unzips +data+.

def self.gunzip(data)

require 'stringio'

require 'zlib'

data = StringIO.new data

# Zlib::GzipWriter wrapper that zips +data+.

def self.gzip(data)

require 'stringio'

require 'zlib'

zipped = StringIO.new

# A Zlib::Inflate#inflate wrapper

def self.inflate(data)

require 'zlib'

Zlib::Inflate.inflate data

end

# <tt>https://rubygems.org</tt>.

def self.host

@host ||= "https://rubygems.org"

end

## Set the default RubyGems API host.

def self.host= host

@host = host

end

Gem.path.each do |gemdir|

each_load_path(latest_partials(gemdir)) do |load_path|

end

end

def self.latest_partials(gemdir)

latest = {}

all_partials(gemdir).each do |gp|

name, version = $1, $2

ver = Gem::Version.new(version)

if latest[name].nil? || ver > latest[name][0]

file = $1

lineno = $2.to_i

[file, lineno]

end

end

##

# Get the appropriate cache path.

#

# Pass a string to use a different base path, or nil/false (default) for

#

def self.cache_dir(custom_dir=false)

end

##

# nil/false (default) for Gem.dir.

def self.cache_gem(filename, user_dir=false)

end

##

end

##

# Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance

# and the spec that was uninstalled when Gem::Uninstaller#uninstall is

# called

end

##

# Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance

# and the spec that will be uninstalled when Gem::Uninstaller#uninstall is

# called

raise ArgumentError, "gem #{gem_name} is not activated" if gem.nil?

raise ArgumentError, "gem #{over_name} is not activated" if over.nil?

over_paths = over.require_paths.map do |path|

end

over_paths.each do |path|

# Refresh source_index from disk and clear searcher.

def self.refresh

@searcher = nil

end

# any version by the requested name.

def self.report_activate_error(gem)

if matches.empty? then

error = Gem::LoadError.new(

def self.required_location(gemname, libfile, *requirements)

requirements = Gem::Requirement.default if requirements.empty?

return nil if matches.empty?

spec = matches.last

spec.require_paths.each do |path|

end

nil

def self.ruby

if @ruby.nil? then

@ruby = File.join(ConfigMap[:bindir],

end

@ruby

end

##

# Returns the Gem::SourceIndex of specifications that are in the Gem.path

def self.source_index

end

##

# default_sources if it is not installed.

def self.sources

end

##

# Need to be able to set the sources without calling

# Gem.sources.replace since that would cause an infinite loop.

@sources = new_sources

end

# by the unit tests to provide environment isolation.

def self.use_paths(home, paths=[])

end

##

attr_reader :post_install_hooks

##

# The list of hooks to be run before Gem::Uninstall#uninstall does any

# work

attr_reader :pre_install_hooks

##

# The list of hooks to be run after Gem::Uninstall#uninstall is finished

attr_reader :pre_uninstall_hooks

end

def self.cache # :nodoc:

source_index

end

MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/"

autoload :GemPathSearcher, 'rubygems/gem_path_searcher'

end

module Kernel

def gem(gem_name, *requirements) # :doc:

skip_list = (ENV['GEM_SKIP'] || "").split(/:/)

raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name

end

private :gem

require 'rbconfig/datadir'

end

require 'rubygems/exceptions'

Gem.clear_paths

@signer = sign

write_package

say success if Gem.configuration.verbose

end

def success

Successfully built RubyGem

Name: #{@spec.name}

Version: #{@spec.version}

EOM

end

end

def write_package

Gem::Package.open gem_io, 'w', @signer do |pkg|

yaml = @spec.to_yaml

pkg.metadata = yaml

@spec.files.each do |file|

mode = stat.mode & 0777

size = stat.size

end

end

end

if description then

end

##

# Register all the subcommands supported by the gem command.

def initialize

end

##

# Return the registered command from the command name.

def [](command_name)

retried = false

begin

rescue NameError

raise if retried

Gem.configuration.backtrace

end

retry

end

end

def execute

gemspec = get_one_gem_name

Gem::Builder.new(spec).build

end

else

alert_error "Gemspec file not found: #{gemspec}"

end

end

if yaml?(filename)

open(filename) do |f|

begin

rescue Gem::EndOfYAMLException

end

end

else

end

end

def yaml?(filename)

'Build private key and self-signed',

'certificate for EMAIL_ADDR.') do |value, options|

vals = Gem::Security.build_self_signed_cert(value)

say "Public Cert: #{vals[:cert_path]}"

say "Private Key: #{vals[:key_path]}"

say "Don't forget to move the key file to somewhere private..."

######################################################################

require 'rubygems/command'

require 'rubygems/dependency_list'

require 'rubygems/uninstaller'

say "Cleaning up installed gems..."

primary_gems = {}

if primary_gems[spec.name].nil? or

primary_gems[spec.name].version < spec.version then

primary_gems[spec.name] = spec

end

end

gems_to_cleanup = gems_to_cleanup.select { |spec|

primary_gems[spec.name].version != spec.version

:version => "= #{spec.version}",

}

end

uninstaller = Gem::Uninstaller.new spec.name, uninstall_options

end.flatten

path_kind = if spec_dirs.empty? then

"default gem paths"

else

"specified path"

end

gem_names = if options[:all] then

else

get_all_gem_names

end

gem_names.each do |name|

say "Unable to find gem '#{name}' in #{path_kind}"

if Gem.configuration.verbose then

terminate_interaction 1 if gem_names.length == 1

end

end

end

end

end

def execute

end

pattern = if options[:args].length == 1 and

options[:args].first =~ /\A\/(.*)\/(i)?\z/m then

flags = $2 ? Regexp::IGNORECASE : nil

/\A#{Regexp.union(*options[:args])}/

end

dependency.prerelease = options[:prerelease]

if remote? and not options[:reverse_dependencies] then

fetcher = Gem::SpecFetcher.fetcher

dependency.prerelease?)

end

patterns = options[:args].join ','

say "No gems found matching #{patterns} (#{options[:version]})" if

Gem.configuration.verbose

terminate_interaction 1

end

reverse = Hash.new { |h, k| h[k] = [] }

if options[:reverse_dependencies] then

reverse[spec.full_name] = find_reverse_dependencies spec

end

end

if options[:pipe_format] then

unless spec.dependencies.empty?

spec.dependencies.sort_by { |dep| dep.name }.each do |dep|

say "#{dep.name} --version '#{dep.requirement}'"

else

response = ''

response << print_dependencies(spec)

unless reverse[spec.full_name].empty? then

response << " Used by\n"

def find_reverse_dependencies(spec)

result = []

sp.dependencies.each do |dep|

dep = Gem::Dependency.new(*dep) unless Gem::Dependency === dep

result

end

end

version = options[:version] || Gem::Requirement.default

all = Gem::Requirement.default != version

gem_names = get_all_gem_names

gem_names.each do |gem_name|

dep = Gem::Dependency.new gem_name, version

dep.prerelease = options[:prerelease]

specs_and_sources, errors =

Gem::SpecFetcher.fetcher.fetch_with_errors(dep, all, true,

dep.prerelease?)

spec, source_uri = specs_and_sources.sort_by { |s,| s.version }.last

if spec.nil? then

end

path = Gem::RemoteFetcher.fetcher.download spec, source_uri

say "Downloaded #{spec.full_name}"

end

get_all_gem_names.each do |gem_name|

begin

inst = Gem::DependencyInstaller.new options

inst.install gem_name, options[:version]

spec.runtime_dependencies.each do |dep|

next if locked[dep.name]

if candidates.empty? then

complain "Unable to satisfy '#{dep}' from currently installed gems"

end

def spec_path(gem_full_name)

File.join path, "specifications", "#{gem_full_name}.gemspec"

end

end

end

def execute

dep = Gem::Dependency.new local.name, ">= #{local.version}"

remotes = Gem::SpecFetcher.fetcher.fetch dep

say "#{local.name} (#{local.version} < #{remote.version})"

end

end

end

def initialize

super 'pristine',

'Restores installed gems to pristine condition from files located in the gem cache',

add_option('--all',

'Restore all installed gems to pristine',

options[:all] = value

end

add_version_option('restore to', 'pristine condition')

end

end

def defaults_str # :nodoc:

end

def description # :nodoc:

If the cached gem cannot be found, you will need to use `gem install` to

revert the gem.

EOF

end

end

def execute

specs = if options[:all] then

else

end

raise Gem::Exception,

end

install_dir = Gem.dir # TODO use installer option

raise Gem::FilePermissionError.new(install_dir) unless

File.writable?(install_dir)

specs.each do |spec|

say "Cached gem for #{spec.full_name} not found, attempting to fetch..."

dep = Gem::Dependency.new spec.name, spec.version

Gem::RemoteFetcher.fetcher.download_to_cache dep

end

# TODO use installer options

installer.install

say "Restored #{spec.full_name}"

end

end

end

exit_code |= 1

end

end

if local? then

if prerelease and not both? then

say

end

spec_tuples = specs.map do |spec|

[[spec.name, spec.version, spec.original_platform, spec], :local]

##

# Check if gem +name+ version +version+ is installed.

end

def output_query_results(spec_tuples)

options[:addresses].push(*address)

end

'launches a browser window',

"COMMAND defaults to 'start' on Windows",

"and 'open' on all other platforms" do |launch, options|

args << '--main' << 'README.rdoc' << '--quiet'

args << '.'

args << 'README.rdoc' << 'UPGRADING.rdoc'

r = RDoc::RDoc.new

r.document args

field = get_one_optional_argument

if local? then

if File.exist? gem then

end

if specs.empty? then

end

end

terminate_interaction 1

end

s = s.send field if field

say case options[:format]

say "\n"

end

end

end

def execute

gem_to_atime = {}

Dir["#{spec.full_gem_path}/**/*.*"].each do |file|

next if File.directory?(file)

stat = File.stat(file)

options[:target] = value

end

add_version_option

end

dependency = Gem::Dependency.new name, options[:version]

path = get_path dependency

basename = File.basename path, '.gem'

target_dir = File.expand_path basename, options[:target]

FileUtils.mkdir_p target_dir

Gem::Installer.new(path, :unpack => true).unpack target_dir

say "Unpacked gem: '#{target_dir}'"

end

end

end

# TODO: see comments in get_path() about general service.

def find_in_cache(filename)

Gem.path.each do |path|

return this_path if File.exist? this_path

end

def get_path dependency

return dependency.name if dependency.name =~ /\.gem$/i

return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless

selected

# We expect to find (basename).gem in the 'cache' directory. Furthermore,

# the name match must be exact (ignoring case).

return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless path

path

end

end

hig = {} # highest installed gems

if hig[spec.name].nil? or hig[spec.name].version < spec.version then

hig[spec.name] = spec

end

end

end

updated = update_gems gems_to_update

end

def update_gems gems_to_update

end

@updated

options[:user_install] = false

version = options[:system]

if version == true then

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

'rubygems-update' => rubygems_update

}

say "Latest version currently installed. Aborting."

terminate_interaction

end

version = installed_gems.last.version

args = []

end

end

result = []

highest_installed_gems.each do |l_name, l_spec|

version

end.last

end

end

######################################################################

require 'rubygems/command'

class Gem::Commands::WhichCommand < Gem::Command

def initialize

super 'which', 'Find the location of a library file you can require',

:search_gems_first => false, :show_all => false

end

def execute

found = false

options[:args].each do |arg|

dirs = $LOAD_PATH

if spec then

if options[:search_gems_first] then

end

end

paths = find_paths arg, dirs

if paths.empty? then

result = []

dirs.each do |dir|

full_path = File.join dir, "#{package_name}#{ext}"

if File.exist? full_path then

result << full_path

# Location of RubyGems.org credentials

def credentials_path

end

def load_api_keys

if @api_keys.key? :rubygems_api_key then

@rubygems_api_key = @api_keys[:rubygems_api_key]

@api_keys[:rubygems] = @api_keys.delete :rubygems_api_key unless @api_keys.key? :rubygems

def rubygems_api_key=(api_key)

config = load_file(credentials_path).merge(:rubygems_api_key => api_key)

Gem.load_yaml

def load_file(filename)

Gem.load_yaml

begin

YAML.load(File.read(filename))

rescue ArgumentError

protected

attr_reader :hash

end

if Gem.unresolved_deps.empty? or Gem.loaded_path? path then

gem_original_require path

else

unless spec then

unless found_specs.empty? then

found_specs = [found_specs.last]

else

end

found_specs.each do |found_spec|

end

end

module Gem

@post_install_hooks ||= []

@post_uninstall_hooks ||= []

@pre_uninstall_hooks ||= []

# specified in the environment

def self.default_dir

end

##

# The default system-wide source info cache directory

def self.default_system_source_cache_dir

end

##

# The default user-specific source info cache directory

def self.default_user_source_cache_dir

end

##

'ruby'

end

end

end

# <tt>:runtime</tt>.

def initialize name, *requirements

type = Symbol === requirements.last ? requirements.pop : :runtime

requirements = requirements.first if 1 == requirements.length # unpack

self.class.new name, self_req.as_list.concat(other_req.as_list)

end

attr_reader :installed_gems

DEFAULT_OPTIONS = {

:ignore_dependencies => false,

}

##

def initialize(options = {})

if options[:install_dir] then

end

options = DEFAULT_OPTIONS.merge options

@ignore_dependencies = options[:ignore_dependencies]

@installed_gems = []

if @domain == :both or @domain == :remote then

begin

requirements = dep.requirement.requirements.map do |req, ver|

req

end

add_found_dependencies to_do, dependency_list unless @ignore_dependencies

dependency_list.specs.reject! { |spec|

}

unless dependency_list.ok? or @ignore_dependencies or @force then

to_do.push dep_spec

# already locally installed

dep.name == installed_spec.name and

dep.requirement.satisfied_by? installed_spec.version

end

local_gems = Dir["#{glob}*"].sort.reverse

end

end

dep = Gem::Dependency.new gem_name, version

dep.prerelease = true if prerelease

spec_and_sources = find_gems_with_sources(dep).reverse

spec_and_source = spec_and_sources.find { |spec, source|

Gem::Platform.match spec.platform

}

gather_dependencies

# TODO: make this sorta_verbose so other users can benefit from it

say "Installing gem #{spec.full_name}" if Gem.configuration.really_verbose

:ignore_dependencies => @ignore_dependencies,

:install_dir => @install_dir,

:security_policy => @security_policy,

:user_install => @user_install,

:wrappers => @wrappers

@installed_gems

end

end

#++

require 'tsort'

##

# Gem::DependencyList is used for installing and uninstalling gems in the

attr_accessor :development

##

list = new

end

##

def why_not_ok? quick = false

unsatisfied = Hash.new { |h,k| h[k] = [] }

each do |spec|

spec.runtime_dependencies.each do |dep|

dep.name == installed_spec.name and

dep.requirement.satisfied_by? installed_spec.version

}

end

end

end

unsatisfied

end

def active_count(specs, ignored)

specs.count { |spec| ignored[spec.full_name].nil? }

end

end

def initialize(spec, rdoc_args="")

require 'fileutils'

@spec = spec

@rdoc_args = rdoc_args.nil? ? [] : rdoc_args.split

end

# Remove RDoc and RI documentation

def uninstall_doc

@spec.name, @spec.version, @spec.original_platform].join '-'

unless File.directory? doc_dir then

end

unless File.directory? ri_dir then

end

FileUtils.rm_rf ri_dir

end

def self.make(dest_path, results)

unless File.exist? 'Makefile' then

end

mf = File.read('Makefile')

end

# Deal with possible spaces in the path, e.g. C:/Program Files

rake = ENV['rake']

rake ||= begin

rescue Gem::Exception

end

# File a instead and assign it to Ryan Davis or Eric Hodel.

######################################################################

##

# GemPathSearcher has the capability to find loadable files inside

# gems. It generates data up front to speed up searches later.

end

end

def find_active(glob)

# HACK violation of encapsulation

@gemspecs.find do |spec|

# in reverse version order. (bar-2, bar-1, foo-2)

def init_gemspecs

names = a.name <=> b.name

next names if names.nonzero?

b.version <=> a.version

spec.require_paths

end

# See LICENSE.txt for permissions.

#++

require 'rubygems/command_manager'

require 'rubygems/config_file'

require 'rubygems/doc_manager'

class Gem::GemRunner

def initialize(options={})

@command_manager_class = options[:command_manager] || Gem::CommandManager

@config_file_class = options[:config_file] || Gem::ConfigFile

@doc_manager_class = options[:doc_manager] || Gem::DocManager

def do_configuration(args)

Gem.configuration = @config_file_class.new(args)

Gem::Command.extra_args = Gem.configuration[:gem]

@doc_manager_class.configured_args = Gem.configuration[:rdoc]

end

@rss_gems_host = options[:rss_gems_host]

@dest_directory = directory

marshal_name = "Marshal.#{Gem.marshal_version}"

@marshal_index = File.join @directory, marshal_name

@quick_dir = File.join @directory, 'quick'

@quick_marshal_dir = File.join @quick_dir, marshal_name

@quick_index = File.join @quick_dir, 'index'

@latest_index = File.join @quick_dir, 'latest_index'

@specs_index = File.join @directory, "specs.#{Gem.marshal_version}"

@rss_index = File.join @directory, 'index.rss'

##

# Build various indicies

# Marshal gemspecs are used by both modern and legacy RubyGems

compress_indicies

end

##

# Builds indicies for RubyGems older than 1.2.x

say "Generating Marshal master index"

Gem.time 'Generated Marshal master index' do

##

# Builds Marshal quick index gemspecs.

"Complete"

files = []

Gem.time 'Generated Marshal quick index gemspecs' do

marshal_name = File.join @quick_marshal_dir, spec_file_name

marshal_zipped = Gem.deflate Marshal.dump(spec)

files << marshal_name

end

progress.done

Gem.time "Generated #{name} index" do

open(file, 'wb') do |io|

specs = index.map do |*spec|

spec = spec.flatten.last

platform = spec.original_platform

##

# Builds indicies for RubyGems 1.2 and newer. Handles full, latest, prerelease

'prerelease specs')

@files += [@specs_index,

# Builds an RSS feed for past two days gem releases according to the gem's

# date.

if @rss_host.nil? or @rss_gems_host.nil? then

if Gem.configuration.really_verbose then

alert_warning "no --rss-host or --rss-gems-host, RSS generation disabled"

today = Gem::Specification::TODAY

yesterday = today - 86400

spec_date = spec.date

end

description = spec.description || spec.summary || ''

authors = Array spec.authors

@files << @rss_index

end

##

# Collect specifications from .gem files from the gem directory.

def collect_specs(gems = gem_file_list)

end

end

end

##

# List of gem file names to index.

def gem_file_list

end

##

def generate_index

make_temp_directories

install_indicies

rescue SignalException

ensure

say "Moving index into production dir #{@dest_directory}" if verbose

files.delete @quick_marshal_dir if files.include? @quick_dir

files.delete @quick_marshal_dir

FileUtils.mkdir_p File.dirname(dst_name), :verbose => verbose

FileUtils.rm_rf dst_name, :verbose => verbose

end

files = files.map do |path|

end

files.each do |file|

dst_name = File.join @dest_directory, file

FileUtils.rm_rf dst_name, :verbose => verbose

end

end

# be replaced by their XML entity equivalent.

def sanitize(spec)

spec.post_install_message = sanitize_string(spec.post_install_message)

spec

end

terminate_interaction 0

end

Gem.time 'Updated indexes' do

@prerelease_specs_index)

end

files << "#{@prerelease_specs_index}.gz"

files = files.map do |path|

end

files.each do |file|

src_name = File.join @directory, file

FileUtils.mv src_name, dst_name, :verbose => verbose,

:force => true

def update_specs_index(index, source, dest)

specs_index = Marshal.load Gem.read_binary(source)

platform = spec.original_platform

platform = Gem::Platform::RUBY if platform.nil? or platform.empty?

specs_index << [spec.name, spec.version, platform]

Marshal.dump specs_index, io

end

end

end

include Gem::RequirePathsBuilder if Gem::QUICKLOADER_SUCKAGE

##

# The directory a gem's executables will be installed into

attr_reader :gem_home

##

# The options passed when the Gem::Installer was instantiated.

attr_reader :options

@gem = gem

@options = options

process_options

if options[:user_install] and not options[:unpack] then

@gem_home = Gem.user_dir

check_that_user_bin_dir_is_in_path

end

end

##

# specifications/<gem-version>.gemspec #=> the Gem::Specification

def install

# If we're forcing the install then disable security unless the security

# policy says that we only install signed gems.

@security_policy = nil if @force and @security_policy and

if result == false then

location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/

raise Gem::InstallError, message

end

end

# Completely remove any previous gem files

extract_files

build_extensions

result = hook.call self

if result == false then

location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/

raise Gem::InstallError, message

end

end

write_require_paths_file_if_needed if Gem::QUICKLOADER_SUCKAGE

Gem.post_install_hooks.each do |hook|

hook.call self

end

rescue Zlib::GzipFile::Error

end

##

# True if the gems in the source_index satisfy +dependency+.

def installation_satisfies_dependency?(dependency)

end

##

def unpack(directory)

@gem_dir = directory

extract_files

end

# specifications directory.

def write_spec

File.open(file_name, "w") do |file|

end

end

end

def generate_bin

# If the user has asked for the gem to be installed in a directory that is

# the system gem directory, then use the system bin directory, else create

# (or use) a new bin dir under the gem_home.

Dir.mkdir bindir unless File.exist? bindir

raise Gem::FilePermissionError.new(bindir) unless File.writable? bindir

filename.untaint

end

if @wrappers then

generate_bin_script filename, bindir

else

return

end

dst = File.join bindir, formatted_program_filename(filename)

if File.exist? dst then

if File.symlink? dst then

link = File.readlink(dst).split File::SEPARATOR

cur_version = Gem::Version.create(link[-3].sub(/^.*-/, ''))

end

File.unlink dst

end

def shebang(bin_file_name)

ruby_name = Gem::ConfigMap[:ruby_install_name] if @env_shebang

first_line = File.open(path, "rb") {|file| file.gets}

if /\A#!/ =~ first_line then

end

def ensure_required_ruby_version_met

unless rrv.satisfied_by? Gem.ruby_version then

end

end

end

def ensure_required_rubygems_version_met

unless rrgv.satisfied_by? Gem::Version.new(Gem::VERSION) then

raise Gem::InstallError,

"Try 'gem update --system' to update RubyGems itself."

end

end

end

def ensure_dependencies_met

deps.each do |dep_gem|

end

end

:exec_format => false,

:force => false,

:install_dir => Gem.dir,

}.merge options

@env_shebang = options[:env_shebang]

@force = options[:force]

@ignore_dependencies = options[:ignore_dependencies]

@format_executable = options[:format_executable]

@security_policy = options[:security_policy]

@wrappers = options[:wrappers]

@bin_dir = options[:bin_dir]

@development = options[:development]

end

def check_that_user_bin_dir_is_in_path

unless ENV['PATH'].split(File::PATH_SEPARATOR).include? user_bin_dir then

unless self.class.path_warning then

alert_warning "You don't have #{user_bin_dir} in your PATH,\n\t gem executables will not run."

end

def verify_gem_home(unpack = false)

end

##

# Return the text for an application file.

def app_script_text(bin_file_name)

#{shebang bin_file_name}

#

# This file was generated by RubyGems.

#

# this file is here to facilitate running it.

#

ARGV.shift

end

TEXT

end

# return the stub script text used to launch the true ruby script

def windows_stub_script(bindir, bin_file_name)

@ECHO OFF

IF NOT "%~f0" == "~f0" GOTO :WinNT

GOTO :EOF

:WinNT

TEXT

end

##

# configure scripts and rakefiles or mkrf_conf files.

def build_extensions

say "Building native extensions. This could take a while..."

ran_rake = false # only run rake once

break if ran_rake

results = []

extension_dir = begin

rescue TypeError # extension == nil

end

begin

Dir.chdir extension_dir do

say results.join("\n") if Gem.configuration.really_verbose

end

#{results}

Results logged to #{gem_make_out}

EOF

# Ensures that files can't be installed outside the gem directory.

def extract_files

raise ArgumentError, "format required to extract from" if @format.nil?

@format.file_entries.each do |entry, file_data|

path = entry['path'].untaint

end

raise Gem::InstallError, msg

end

File.open(path, "wb") do |out|

out.write file_data

end

end

end

##

# Available through requiring rubygems/installer_test_case

##

# Available through requiring rubygems/installer_test_case

def setup

super

@user_spec = quick_gem 'b'

util_make_exec @user_spec

end

def util_gem_bindir spec = @spec

end

def util_gem_dir spec = @spec

end

def util_inst_bindir

spec.executables = %w[executable]

spec.files << 'bin/executable'

io.puts shebang

end

io.puts shebang

end

end

use_ui ui do

FileUtils.rm @gem

end

end

@installer = Gem::Installer.new @gem

end

end

end

add_option(:"Local/Remote", '--clear-sources',

'Clear the gem sources') do |value, options|

options[:sources_cleared] = true

end

end

# Add the --update-sources option

def add_update_sources_option

'Update local source cache') do |value, options|

Gem.configuration.update_sources = value

end

# retrieval during tests.

class Gem::MockGemUi < Gem::StreamUI

module TTY

def terminate_interaction(status=0)

@terminated = true

end

end

require 'rubygems/specification'

module Gem::Package

class Error < StandardError; end

class TarInvalidError < Error; end

def self.open(io, mode = "r", signer = nil, &block)

tar_type = case mode

when 'r' then TarInput

sio.rewind

end

gzis = Zlib::GzipReader.new(sio || entry)

# YAML wants an instance of IO

@metadata = load_gemspec(gzis)

end

@tarreader.rewind

unless has_meta then

path = io.path if io.respond_to? :path

dest = File.join destdir, entry.full_name

if File.directory? dest then

else

end

fsync_dir dest

# it's a file

md5 = Digest::MD5.new if expected_md5sum

destdir = File.join destdir, File.dirname(entry.full_name)

destfile = File.join destdir, File.basename(entry.full_name)

open destfile, "wb", entry.header.mode do |os|

loop do

os.fsync

end

fsync_dir File.dirname(destfile)

fsync_dir File.join(File.dirname(destfile), "..")

name = newname

if name.size > 100 or prefix.size > 155 then

end

end

task :package => [:gem]

gem_path = File.join package_dir, gem_file

gem_dir = File.join package_dir, gem_spec.full_name

# File a instead and assign it to Ryan Davis or Eric Hodel.

######################################################################

##

# Available list of platforms for targeting Gem installations.

# the same CPU, OS and version.

def ==(other)

end

##

CURRENT = 'current'

end

when URI::HTTP then proxy

else URI.parse(proxy)

end

end

##

# larger, more emcompassing effort. -erikh

def download_to_cache dependency

return if found.empty?

Gem.ensure_gem_subdirectories(install_dir) rescue nil

if File.writable?(install_dir)

else

end

local_gem_path = File.join cache_dir, gem_file_name

FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir

# Always escape URI's to deal with potential spaces and such

unless URI::Generic === source_uri

source_uri = URI.parse(URI.const_defined?(:DEFAULT_PARSER) ?

end

scheme = source_uri.scheme

end

##

# Downloads +uri+ and returns it as a String.

def fetch_path(uri, mtime = nil, head = false)

data = Gem.gunzip data if data and not head and uri.to_s =~ /gz$/

data

rescue FetchError

raise

rescue Timeout::Error

rescue IOError, SocketError, SystemCallError => e

end

##

# read from the filesystem instead.

def open_uri_or_path(uri, last_modified = nil, head = false, depth = 0)

end

##

request.basic_auth uri.user, uri.password

end

request.add_field 'Connection', 'keep-alive'

request.add_field 'Keep-Alive', '30'

connection.start

end

end

requirements.all? { |op, rv| (OPS[op] || OPS["="]).call version, rv }

end

def to_s # :nodoc:

as_list.join ", "

end

:munge_re => Regexp.new(/[^a-z0-9_.-]+/),

# output directory for trusted certificate checksums

# default permissions for trust directory and certs

:perms => {

<dl>

<% values["specs"].each do |spec| %>

<% end %>

</dl>

spec_dir

end

end

def Marshal(req, res)

add_date res

if req.request_method == 'HEAD' then

res['content-length'] = index.length

end

def latest_specs(req, res)

res['content-type'] = 'application/x-gzip'

add_date res

[spec.name, spec.version, platform]

end

end

def quick(req, res)

res['content-type'] = 'text/plain'

add_date res

case req.request_uri.path

when %r|^/quick/(Marshal.#{Regexp.escape Gem.marshal_version}/)?(.*?)-([0-9.]+)(-.*?)?\.gemspec\.rz$| then

else

Gem::Platform::RUBY

end

end

def root(req, res)

add_date res

raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found." unless

specs = []

total_file_count = 0

total_file_count += spec.files.size

"type" => dep.type,

deps = deps.sort_by { |dep| [dep["name"].downcase, dep["version"]] }

deps.last["is_last"] = true unless deps.empty?

end

def specs(req, res)

add_date res

[spec.name, spec.version, platform]

end

def launch

listeners = @server.listeners.map{|l| l.addr[2] }

host = listeners.any?{|l| l == '0.0.0.0'} ? 'localhost' : listeners.first

say "Launching browser to http://#{host}:#{@port}"

system("#{@launch} http://#{host}:#{@port}")

end

end

#++

require 'rubygems/specification'

##

# The SourceIndex object indexes all the gems available from a

attr_accessor :spec_dirs

end

end

end

##

# Constructs a source index instance from the provided specifications, which

# is a Hash of gem full names and Gem::Specifications.

@gems = {}

@spec_dirs = nil

end

def all_gems

end

def prerelease_gems

end

def released_gems

end

##

@gems.clear

spec_dirs.reverse_each do |spec_dir|

spec_files.each do |spec_file|

add_spec gemspec if gemspec

end

end

result[name] << spec

end

result.values.flatten

end

def find_name(gem_name, requirement = Gem::Requirement.default)

dep = Gem::Dependency.new gem_name, requirement

end

##

# +gem_pattern+, and a Gem::Requirement for +platform_only+. This

# behavior is deprecated and will be removed.

requirement = nil

# TODO - Remove support and warning for legacy arguments after 2008/11

unless Gem::Dependency === gem_pattern

case gem_pattern

when Regexp then

when Gem::Dependency then

requirement = gem_pattern.requirement

gem_pattern = if Regexp === gem_pattern.name then

/^#{Regexp.escape gem_pattern.name}$/

end

else

gem_pattern = /#{gem_pattern}/i

end

requirement = Gem::Requirement.create requirement

end

spec.name =~ gem_pattern and

requirement.satisfied_by? spec.version

end

def dump

Marshal.dump(self)

end

end

# :stopdoc:

Cache = SourceIndex

end

all = false,

matching_platform = true,

prerelease = false)

specs_and_sources, errors = find_matching_with_errors(dependency,

all,

matching_platform,

# matching released versions are returned. If +matching_platform+

# is false, gems for all platforms are returned.

found = {}

rejected_specs = {}

loaded = false

if File.exist? local_file then

else

spec_dump = @fetcher.fetch_path spec_path

loaded = true

require 'rubygems/version'

require 'rubygems/requirement'

require 'rubygems/platform'

# :stopdoc:

class Date; end # for ruby_code if date.rb wasn't required

class Gem::Specification

##

# The the version number of a specification that does not specify one

# (i.e. RubyGems 0.7 or earlier).

# The specification version applied to any new Specification instances

# created. This should be bumped whenever something in the spec format

# changes.

#--

# When updating this number, be sure to also update #to_ruby.

#

CURRENT_SPECIFICATION_VERSION = 3

# :stopdoc:

MARSHAL_FIELDS = { -1 => 16, 1 => 16, 2 => 16, 3 => 17 }

# :startdoc:

##

##

##

##

##

##

##

##

##

##

##

##

#

##

##

##

##

##

##

##

end

end

##

end

##

end

end

end

##

##

##

end

##

end

end

##

end

##

end

##

end

##

end

end

##

# routine (#initialize). This method makes up for that and deals with

# gems of different ages.

#

def self.from_yaml(input)

input = normalize_yaml_input input

end

##

# Loads Ruby format gemspec from +file+.

def self.load file

spec = eval code, binding, file

if Gem::Specification === spec

return spec

end

end

##

# Make sure the YAML specification is properly formatted with dashes

def self.normalize_yaml_input(input)

result = input.respond_to?(:read) ? input.read : input

result = "--- " + result unless result =~ /\A--- /

end

##

end

##

end

##

##

end

##

end

##

end

end

end

##

end

##

end

##

end

end

end

end

end

end

##

end

end

end

end

##

#

end

end

end

end

##

end

##

def dependent_gems

out = []

if self.satisfies_requirement?(dep) then

sats = []

find_all_satisfiers(dep) do |sat|

sats << sat

end

end

end

end

out

end

end

##

end

end

##

end

##

end

##

##

##

##

#

##

#

#

##

##

##

##

##

##

##

##

# Deprecated and ignored, defaults to true.

#

# Formerly used to indicate this gem was RDoc-capable.

##

alias :has_rdoc? :has_rdoc

##

##

##

##

##

##

##

##

##

##

##

##

##

##

##

end

##

end

end

if @original_platform.nil? or

@original_platform == Gem::Platform::RUBY then

@original_platform = platform

@new_platform

end

end

end

end

end

end

end

end

end

# Handle the possibility that we have @test_suite_file but not

# @test_files. This will happen when an old gem is loaded via

# YAML.

end

end

end

end

end

trail = trail + [self]

runtime_dependencies.each do |dep|

trail.map(&:name).include? dep_spec.name

end

end

end

end

end

rescue Gem::LoadError

end

require 'minitest/autorun'

require 'fileutils'

require 'tmpdir'

require 'rubygems/test_utilities'

require 'pp'

require 'zlib'

Gem.load_yaml

require 'rubygems/mock_gem_ui'

# requiring 'rubygems/test_case'

def self.source_index=(si)

@@source_index = si

end

class Gem::TestCase < MiniTest::Unit::TestCase

include Gem::DefaultUserInteraction

undef_method :default_test if instance_methods.include? 'default_test' or

instance_methods.include? :default_test

##

# #setup prepares a sandboxed location to install gems. All installs are

@orig_gem_home = ENV['GEM_HOME']

@orig_gem_path = ENV['GEM_PATH']

@ui = Gem::MockGemUi.new

tmpdir = nil

Dir.chdir Dir.tmpdir do tmpdir = Dir.pwd end # HACK OSX /private/tmp

if ENV['KEEP_FILES'] then

else

end

@tempdir.untaint

@gemhome = File.join @tempdir, 'gemhome'

Gem.ensure_gem_subdirectories @gemhome

Dir.chdir @tempdir

@orig_ENV_HOME = ENV['HOME']

FileUtils.mkdir_p @userhome

Gem.use_paths(@gemhome)

Gem.loaded_specs.clear

Gem.unresolved_deps.clear

Gem.pre_uninstall do |uninstaller|

@pre_uninstall_hook_arg = uninstaller

end

end

##

Gem::RemoteFetcher.fetcher = nil

end

FileUtils.rm_rf @tempdir unless ENV['KEEP_FILES']

ENV['GEM_HOME'] = @orig_gem_home

ENV['GEM_PATH'] = @orig_gem_path

_ = @orig_ruby

Gem.class_eval { @ruby = _ } if _

end

end

Gem::Installer.new(gem, :wrappers => true).install

end

def uninstall_gem spec

require 'rubygems/uninstaller'

end

##

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

def write_file(path)

dir = File.dirname path

FileUtils.mkdir_p dir

path

end

##

# Creates a Gem::Specification with a minimum of extra work. +name+ and

# +version+ are the gem's name and version, platform, author, email,

s.author = 'A User'

s.email = '[email protected]'

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

s.summary = "this is a summary"

s.description = "This is a test description"

yield(s) if block_given?

end

end

return spec

end

def quick_spec name, version = '2'

require 'rubygems/specification'

spec = Gem::Specification.new do |s|

s.author = 'A User'

s.email = '[email protected]'

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

s.summary = "this is a summary"

s.description = "This is a test description"

yield(s) if block_given?

end

return spec

end

# 'cache'</tt>. Automatically creates files based on +spec.files+

def util_build_gem(spec)

FileUtils.mkdir_p dir

Dir.chdir dir do

Gem::Builder.new(spec).build

end

end

end

# Removes all installed gems from +@gemhome+.

def util_clear_gems

end

##

# Install the provided specs

def install_specs(*specs)

Gem.searcher = nil

end

# up properly. Use this instead of util_spec and util_gem.

def new_spec name, version, deps = nil, *files

spec

end

# Creates a spec with +name+, +version+ and +deps+.

def util_spec(name, version, deps = nil, &block)

raise "deps or block, not both" if deps and block

if deps then

# location are returned.

def util_gem(name, version, deps = nil, &block)

raise "deps or block, not both" if deps and block

if deps then

cache_file = File.join @tempdir, 'gems', "#{spec.original_name}.gem"

FileUtils.mkdir_p File.dirname cache_file

spec.loaded_from = nil

[spec, cache_file]

end

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:

DESC

end

util_build_gem spec

end

end

##

@fetcher = Gem::FakeFetcher.new

util_make_gems(prerelease)

@all_gems = [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2].sort

@all_gem_names = @all_gems.map { |gem| gem.full_name }

gem_names = [@a1.full_name, @a2.full_name, @a3a.full_name, @b2.full_name]

@gem_names = gem_names.sort.join("\n")

Gem::RemoteFetcher.fetcher = @fetcher

end

# Best used with +@all_gems+ from #util_setup_fake_fetcher.

def util_setup_spec_fetcher(*specs)

spec_fetcher = Gem::SpecFetcher.fetcher

spec_fetcher.specs[@uri] = []

spec_tuple = [spec.name, spec.version, spec.original_platform]

spec_fetcher.specs[@uri] << spec_tuple

end

spec_fetcher.latest_specs[@uri] = []

spec_tuple = [spec.name, spec.version, spec.original_platform]

spec_fetcher.latest_specs[@uri] << spec_tuple

end

spec_fetcher.prerelease_specs[@uri] = []

spec_tuple = [spec.name, spec.version, spec.original_platform]

spec_fetcher.prerelease_specs[@uri] << spec_tuple

end

data = Marshal.dump spec

data_deflate = Zlib::Deflate.deflate data

@fetcher.data[path] = data_deflate

end

end

##

end

def download spec, source_uri, install_dir = Gem.dir

Gem.ensure_gem_subdirectories install_dir

end

def download_to_cache dependency

return if found.empty?

while work.length > wrap do

if work =~ /^(.{0,#{wrap}})[ \n]/ then

work.slice!(0, $&.length)

else

result << work.slice!(0, wrap)

# Constructs an uninstaller that will uninstall +gem+

def initialize(gem, options = {})

@force_executables = options[:executables]

@format_executable = options[:format_executable]

# only add user directory if install_dir is not set

@user_install = false

@user_install = options[:user_install] unless options[:install_dir]

if @user_install then

end

end

# directory, and the cached .gem file.

def uninstall

if list.empty? then

raise Gem::InstallError, "cannot uninstall, check `gem list -d #{@gem}`"

elsif list.size > 1 and @force_all then

elsif list.size > 1 then

gem_names = list.collect {|gem| gem.full_name} + ["All versions"]

_, index = choose_from_list "Select gem to uninstall:", gem_names

if index == list.size then

elsif index >= 0 && index < list.size then

else

say "Error: must enter a number [1-#{list.size+1}]"

end

else

end

end

##

# Uninstalls gem +spec+

@spec = spec

unless dependencies_ok? spec

end

remove_executables @spec

Gem.post_uninstall_hooks.each do |hook|

hook.call self

def remove_executables(spec)

return if spec.nil? or spec.executables.empty?

}

executables = spec.executables.clone

unless remove then

say "Executables and scripts will remain installed."

else

raise Gem::FilePermissionError, bindir unless File.writable? bindir

spec.executables.each do |exe_name|

# NOTE: removes uninstalled gems from +list+.

def remove_all(list)

end

##

# Warning: this method modifies the +list+ parameter. Once it has

# uninstalled a gem, it is removed from that list.

unless path_ok?(@gem_home, spec) or

(@user_install and path_ok?(Gem.user_dir, spec)) then

e = Gem::GemNotInHomeException.new \

raise e

end

FileUtils.rm_rf spec.full_gem_path

unless File.exist? gemspec then

end

FileUtils.rm_rf gemspec

FileUtils.rm_rf gem

say "Successfully uninstalled #{spec.full_name}"

end

##

# Is +spec+ in +gem_dir+?

def path_ok?(gem_dir, spec)

original_path = File.join gem_dir, 'gems', spec.original_name

full_path == spec.full_gem_path || original_path == spec.full_gem_path

def dependencies_ok?(spec)

return true if @force_ignore

deplist.ok_to_remove?(spec.full_name)

end

msg = ['']

msg << 'You have requested to uninstall the gem:'

msg << "\t#{spec.full_name}"

msg <<

end

msg << 'If you remove this gems, one or more dependencies will not be met.'

msg << 'Continue with Uninstall?'

return ask_yes_no(msg.join("\n"), true)

filename

end

end

end

include Gem::DefaultUserInteraction

end

end

def assert_activate expected, *specs

specs.each do |spec|

case spec

else

end

end

Gem.unresolved_deps.values.map(&:to_s).sort

end

def test_self_activate_via_require

require "b/c"

assert_equal %w(a-1 b-1), loaded_spec_names

end

def test_self_activate_deep_unambiguous

a1 = new_spec "a", "1", "b" => "= 1"

b1 = new_spec "b", "1", "c" => "= 1"

install_specs a1, b1, b2, c1, c2

assert_equal %w(a-1 b-1 c-1), loaded_spec_names

end

$LOADED_FEATURES.replace old_loaded_features

end

def test_self_activate_ambiguous_direct

save_loaded_features do

a1 = new_spec "a", "1", "b" => "> 0"

c1 = new_spec "c", "1"

c2 = new_spec "c", "2"

install_specs a1, b1, b2, c1, c2

assert_equal %w(a-1), loaded_spec_names

assert_equal ["b (> 0)"], unresolved_names

end

end

def test_self_activate_ambiguous_indirect

save_loaded_features do

a1 = new_spec "a", "1", "b" => "> 0"

install_specs a1, b1, b2, c1, c2

assert_equal %w(a-1), loaded_spec_names

assert_equal ["b (> 0)"], unresolved_names

end

end

def test_self_activate_ambiguous_unrelated

save_loaded_features do

a1 = new_spec "a", "1", "b" => "> 0"

install_specs a1, b1, b2, c1, c2, d1

assert_equal %w(a-1), loaded_spec_names

assert_equal ["b (> 0)"], unresolved_names

end

end

def test_self_activate_ambiguous_indirect_conflict

save_loaded_features do

a1 = new_spec "a", "1", "b" => "> 0"

install_specs a1, a2, b1, b2, c1, c2

assert_equal %w(a-2), loaded_spec_names

assert_equal ["b (> 0)"], unresolved_names

end

end

def test_require_already_activated

save_loaded_features do

a1 = new_spec "a", "1", nil, "lib/d.rb"

install_specs a1 # , a2, b1, b2, c1, c2

assert_equal %w(a-1), loaded_spec_names

assert_equal [], unresolved_names

end

end

def test_require_already_activated_indirect_conflict

save_loaded_features do

a1 = new_spec "a", "1", "b" => "> 0"

install_specs a1, a2, b1, b2, c1, c2

assert_equal %w(a-1 c-1), loaded_spec_names

assert_equal ["b (> 0)"], unresolved_names

end

end

def test_self_activate_loaded

end

##

# [B] ~> 1.0

#

# and should resolve using b-1.0

def test_self_activate_over

util_spec 'b', '1.0'

util_spec 'b', '1.1'

util_spec 'b', '2.0'

util_spec 'c', '1.0', 'b' => '~> 1.0'

assert_equal %w[a-1.0 c-1.0], loaded_spec_names

assert_equal ["b (>= 1.0, ~> 1.0)"], unresolved_names

assert_activate %w[d-1 e-1], e1, "d"

end

util_make_gems

end

end

def test_self_bin_path_bin_name

assert_equal @abin_path, Gem.bin_path('a', 'abin', '4')

end

def test_self_bin_path_nonexistent_binfile

quick_spec 'a', '2' do |s|

s.executables = ['exec']

def test_self_bin_path_no_bin_file

quick_spec 'a', '1'

Gem.bin_path('a', nil, '1')

end

end

def test_self_bin_path_not_found

assert_raises(Gem::GemNotFoundException) do

end

end

util_exec_gem

quick_spec 'a', '10' do |s|

s.executables = []

end

# Should not find a-10's non-abin (bug)

assert_equal @abin_path, Gem.bin_path('a', 'abin')

end

def test_self_clear_paths

Gem.clear_paths

end

def test_self_configuration

install_gem foo

end

gem 'foo'

expected = File.join @gemhome, 'gems', foo.full_name, 'data', 'foo'

Gem.ensure_gem_subdirectories @gemhome

end

def test_self_ensure_gem_directories_missing_parents

Gem.ensure_gem_subdirectories gemdir

end

unless win_platform? then # only for FS that support write protection

Gem.ensure_gem_subdirectories gemdir

ensure

FileUtils.chmod 0600, gemdir

end

Gem.ensure_gem_subdirectories gemdir

ensure

FileUtils.chmod 0600, parent

end

end

def test_self_find_files

cwd = File.expand_path("test/rubygems", @@project_dir)

$LOAD_PATH.unshift cwd

Gem.searcher = nil

expected = [

File.expand_path('test/rubygems/sff/discover.rb', @@project_dir),

assert_equal cwd, $LOAD_PATH.shift

end

def test_self_loaded_specs

foo = quick_spec 'foo'

install_gem foo

assert_equal true, Gem.loaded_specs.keys.include?('foo')

end

orig_APPLE_GEM_HOME = APPLE_GEM_HOME

Object.send :remove_const, :APPLE_GEM_HOME

end

ensure

Object.const_set :APPLE_GEM_HOME, orig_APPLE_GEM_HOME

end

end

def test_self_path_ENV_PATH

path_count = Gem.path.size

Gem.clear_paths

def test_self_refresh

util_make_gems

Gem.refresh

end

def test_self_ruby_escaping_spaces_in_path

util_restore_RUBY_VERSION

end

other = File.join @tempdir, 'other'

path = [@userhome, other].join File::PATH_SEPARATOR

assert_equal [@userhome, other, @gemhome], Gem.path

end

ENV['GEM_HOME'] = @gemhome

Gem.clear_paths

ENV['HOME'] = other

assert_equal [other, @gemhome], Gem.path

end

def test_self_source_index

end

def test_self_sources

assert_equal %w[http://gems.example.com/], Gem.sources

end

def test_ssl_available_eh

orig_Gem_ssl_available = Gem.ssl_available?

end

end

if Gem.win_platform? then

def test_self_user_home_userprofile

skip 'Ruby 1.9 properly handles ~ path expansion' unless '1.9' > RUBY_VERSION

install_gem foo

end

Gem.searcher = nil

gem 'foo'

def util_ensure_gem_dirs

Gem.ensure_gem_subdirectories @gemhome

@additional.each do |dir|

Gem.ensure_gem_subdirectories @gemhome

end

def util_exec_gem

spec, _ = quick_spec 'a', '4' do |s|

s.executables = ['exec', 'abin']

end

Gem::Commands.send :remove_const, :InterruptCommand if

Gem::Commands.const_defined? :InterruptCommand

end

end

require 'rubygems/test_case'

require 'rubygems/builder'

class TestGemBuilder < Gem::TestCase

end

end

end

ensure

$:.replace old_load_path

end

def test_run_crash_command

end

ensure

$:.replace old_load_path

end

def test_process_args_bad_arg

util_test_build_gem @gem, gemspec_file

end

@cmd.options[:args] = %w[some_gem]

use_ui @ui do

end

assert_equal '', @ui.output

assert_equal [], output

assert_equal '', @ui.error

assert File.exist?(gem_file)

spec = Gem::Format.from_file_by_path(gem_file).spec

@cmd = Gem::Commands::ContentsCommand.new

end

def test_execute

@cmd.options[:args] = %w[foo]

use_ui @ui do

@cmd.execute

def test_execute_all

@cmd.options[:all] = true

use_ui @ui do

@cmd.execute

def test_execute_exact_match

@cmd.options[:args] = %w[foo]

use_ui @ui do

@cmd.execute

@cmd.options[:args] = %w[foo]

@cmd.options[:lib_only] = true

use_ui @ui do

@cmd.execute

def test_execute_multiple

@cmd.options[:args] = %w[foo bar]

use_ui @ui do

@cmd.execute

@cmd.options[:args] = %w[foo]

@cmd.options[:prefix] = false

use_ui @ui do

@cmd.execute

end

expected = <<-EOF

Rakefile

EOF

assert_equal expected, @ui.output

gem.add_dependency 'baz', '> 1'

end

@cmd.options[:args] = %w[foo]

use_ui @ui do

end

def test_execute_no_args

@cmd.options[:args] = []

use_ui @ui do

end

def test_execute_regexp

@cmd.options[:args] = %w[/[ab]/]

use_ui @ui do

gem.add_dependency 'foo'

end

@cmd.options[:args] = %w[foo]

@cmd.options[:reverse_dependencies] = true

assert_equal '', @ui.error

end

def test_execute_prerelease

@fetcher = Gem::FakeFetcher.new

Gem::RemoteFetcher.fetcher = @fetcher

util_setup_spec_fetcher @a2_pre

@cmd.options[:args] = %w[a]

@cmd.options[:domain] = :remote

@cmd.options[:prerelease] = true

util_setup_spec_fetcher @a2

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@cmd.options[:args] = [@a2.name]

def test_execute_prerelease

util_setup_fake_fetcher true

util_setup_spec_fetcher @a2, @a2_pre

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@fetcher.data["#{@gem_repo}gems/#{@a2_pre.file_name}"] =

@cmd.options[:args] = [@a2.name]

@cmd.options[:prerelease] = true

util_setup_spec_fetcher @a1, @a2

@fetcher.data["#{@gem_repo}gems/#{@a1.file_name}"] =

@cmd.options[:args] = [@a2.name]

@cmd.options[:version] = Gem::Requirement.new '1'

end

def test_execute_exclude_prerelease

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@fetcher.data["#{@gem_repo}gems/#{@a2_pre.file_name}"] =

@cmd.options[:args] = [@a2.name]

end

def test_execute_explicit_version_includes_prerelease

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@fetcher.data["#{@gem_repo}gems/#{@a2_pre.file_name}"] =

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

"--no-ri", "--no-rdoc"]

util_setup_fake_fetcher

@cmd.options[:domain] = :local

@cmd.options[:args] = [@a2.name]

util_setup_fake_fetcher

@cmd.options[:user_install] = false

@cmd.options[:args] = [@a2.name]

use_ui @ui do

orig_dir = Dir.pwd

begin

Dir.chdir @tempdir

assert_raises Gem::FilePermissionError do

end

ensure

Dir.chdir orig_dir

end

end

end

end

def test_execute_prerelease

util_setup_spec_fetcher @a2, @a2_pre

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@fetcher.data["#{@gem_repo}gems/#{@a2_pre.file_name}"] =

@cmd.options[:prerelease] = true

@cmd.options[:args] = [@a2_pre.name]

@cmd.options[:generate_ri] = true

util_setup_fake_fetcher

@fetcher.data["#{@gem_repo}gems/#{@a2.file_name}"] =

@cmd.options[:args] = [@a2.name]

util_setup_fake_fetcher

@cmd.options[:domain] = :local

@cmd.options[:args] = [@a2.name, @b2.name]

def test_execute_conservative

util_setup_fake_fetcher

@fetcher.data["#{@gem_repo}gems/#{@b2.file_name}"] =

uninstall_gem(@b2)

orig_dir = Dir.pwd

begin

Dir.chdir @tempdir

@cmd.execute

end

ensure

Dir.chdir orig_dir

end

end

out = @ui.output.split "\n"

assert_equal "Successfully installed #{@b2.full_name}", out.shift

assert_equal "1 gem installed", out.shift

assert out.empty?, out.inspect

def test_execute_installed

@cmd.handle_options %w[c --installed]

use_ui @ui do

@cmd.execute

end

end

assert_equal "true\n", @ui.output

assert_equal '', @ui.error

end

end

def test_execute

remote_10 = quick_spec 'foo', '1.0'

remote_20 = quick_spec 'foo', '2.0'

util_setup_spec_fetcher remote_10, remote_20

assert_equal "foo (0.2 < 2.0)\n", @ui.output

assert_equal "", @ui.error

end

end

def test_execute

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

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

end

foo_path = File.join @gemhome, 'gems', a.full_name, 'bin', 'foo'

io.puts 'I changed it!'

end

out = @ui.output.split "\n"

assert_equal "Restored #{a.full_name}", out.shift

assert_empty out, out.inspect

end

def test_execute_all

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

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

end

out = @ui.output.split "\n"

assert_equal "Restored #{a.full_name}", out.shift

assert_empty out, out.inspect

end

end

end

install_gem a

end

util_setup_fake_fetcher

@cmd.options[:args] = %w[a]

out = @ui.output.split "\n"

[

"Restored a-1",

"Cached gem for a-2 not found, attempting to fetch...",

"Restored a-2",

].each do |line|

assert_equal line, out.shift

end

end

end

end

end

super

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

FileUtils.mkdir @gems_dir

@cmd = Gem::Commands::QueryCommand.new

util_setup_fake_fetcher

@fetcher.data["#{@gem_repo}Marshal.#{Gem.marshal_version}"] = proc do

raise Gem::RemoteFetcher::FetchError

@a1.platform = 'x86-linux'

@a2.platform = 'universal-darwin'

@cmd.handle_options %w[-r -a]

@a2.homepage = 'http://a.example.com/'

@a2.rubyforge_project = 'rubygems'

@cmd.handle_options %w[-r -d]

@a2.rubyforge_project = 'rubygems'

@a2.platform = 'universal-darwin'

@cmd.handle_options %w[-r -d]

end

def test_execute_installed

use_ui @ui do

@cmd.execute

end

end

assert_equal "true\n", @ui.output

assert_equal '', @ui.error

end

def test_execute_installed_no_name

@cmd.handle_options %w[--installed]

use_ui @ui do

@cmd.execute

end

def test_execute_installed_not_installed

@cmd.handle_options %w[-n not_installed --installed]

use_ui @ui do

@cmd.execute

end

end

def test_execute_installed_version

use_ui @ui do

@cmd.execute

end

assert_equal "true\n", @ui.output

assert_equal '', @ui.error

end

def test_execute_installed_version_not_installed

@cmd.handle_options %w[-n c --installed --version 2]

use_ui @ui do

@cmd.execute

end

assert_equal 1, e.exit_code

end

def test_execute_local_notty

@cmd.handle_options %w[]

expected = <<-EOF

a (3.a, 2, 1)

pl (1 i386-linux)

EOF

*** LOCAL GEMS ***

a (3.a, 2, 1)

pl (1 i386-linux)

EOF

def test_execute_add

util_setup_fake_fetcher

[spec.name, spec.version, spec.original_platform]

specs_dump_gz = StringIO.new

Zlib::GzipWriter.wrap specs_dump_gz do |io|

@cmd.handle_options %w[--update]

util_setup_fake_fetcher

[spec.name, spec.version, spec.original_platform]

@fetcher.data["#{@gem_repo}specs.#{Gem.marshal_version}.gz"] =

util_gzip Marshal.dump(specs)

[spec.name, spec.version, spec.original_platform]

@fetcher.data["#{@gem_repo}latest_specs.#{Gem.marshal_version}.gz"] =

util_gzip Marshal.dump(latest_specs)

def test_execute

foo = quick_spec 'foo'

@cmd.options[:args] = %w[foo]

end

def test_execute_field

@cmd.options[:args] = %w[foo name]

end

def test_execute_marshal

@cmd.options[:args] = %w[foo]

@cmd.options[:format] = :marshal

def test_execute_ruby

foo = quick_spec 'foo'

@cmd.options[:args] = %w[foo]

@cmd.options[:format] = :ruby

end

files.each do |file|

FileUtils.touch(filename, :mtime => Time.now)

FileUtils.touch(filename, :mtime => Time.now - 86400)

end

util_make_gems

assert_equal(

'found a-1.gem in the cache'

)

end

def test_get_path

util_setup_fake_fetcher

util_setup_spec_fetcher @a1

a1_data = nil

a1_data = fp.read

end

dep = Gem::Dependency.new(@a1.name, @a1.version)

assert_equal(

@cmd.get_path(dep),

'fetches a-1 and returns the cache path'

)

assert_equal(

@cmd.get_path(dep),

'when removed from cache, refetches a-1'

)

end

end

def test_execute_gem_path

util_setup_fake_fetcher

Gem.clear_paths

gemhome2 = File.join @tempdir, 'gemhome2'

@cmd.options[:args] = %w[a]

end

def test_execute_gem_path_missing

util_setup_spec_fetcher

Gem.clear_paths

gemhome2 = File.join @tempdir, 'gemhome2'

@cmd.options[:args] = %w[z]

util_clear_gems

a2_data = nil

a2_data = fp.read

end

assert File.exist?(File.join(@tempdir, 'a-2')), 'a should be unpacked'

end

def test_execute_sudo

util_make_gems

@cmd.options[:args] = %w[b]

assert File.exist?(File.join(@tempdir, 'b-2')), 'b should be unpacked'

ensure