Tue Jan 18 23:31:01 2011 Yusuke Endoh <[email protected]>

* parse.y: avoid NULL reference. [ruby-dev:43067]

Output#encoding and Source#encoding) return an Encoding

object instead of an encoding name.

* stringio

* extended method:

* StringIO#set_encoding can get 2nd argument and optional hash.

# See LICENSE.txt for permissions.

#++

# See LICENSE.txt for permissions.

#++

require 'rubygems/defaults'

##

# 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

attr_accessor :name

# Version requirement of gem

##

# Default directories in a gem repository

DIRECTORIES = %w[cache doc gems specifications] unless defined?(DIRECTORIES)

RubyGemsPackageVersion = VERSION

# :startdoc:

@pre_install_hooks ||= []

##

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

#

# Returns true if the gem is activated, false if it is already

# loaded, or an exception otherwise.

# More information on version requirements can be found in the

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

else

options = {}

end

sources = options[:sources] || []

end

unless gem.respond_to?(:name) and

gem.respond_to?(:requirement) then

end

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

e = Gem::LoadError.new msg

e.name = gem.name

raise e

end

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

end

require_paths = spec.require_paths.map do |path|

File.join spec.full_gem_path, path

end

##

# Find the full path to the executable for gem +name+. If the +exec_name+

# is not given, the gem's default_executable is chosen, otherwise the

# you to specify specific gem versions.

raise Gem::GemNotFoundException,

end

raise Gem::Exception, msg

end

@@source_index = nil

end

##

def self.dir

@gem_home ||= nil

@gem_home

end

end

##

# up features from other gems. For example:

#

# Gem.find_files('rdoc/discover').each do |path| load path end

#

#

# Note that find_files will return all files even if they are from different

# versions of the same gem.

end

##

# Finds the user's home directory.

def self.find_home

File.expand_path "~"

rescue

if File::ALT_SEPARATOR then

else

"/"

end

end

##

# Return a list of all possible load paths for the latest version for all

# gems in the Gem installation.

# so you can override the gem_prelude.rb default $LOAD_PATH paths.

def self.load_path_insert_index

end

end

##

@gem_path ||= nil

unless @gem_path then

if defined?(APPLE_GEM_HOME) and not ENV['GEM_PATH'] then

paths << APPLE_GEM_HOME

def self.refresh

source_index.refresh!

end

##

end

error.name = gem.name

raise error

end

# The GemPathSearcher object used to search for matching installed gems.

def self.searcher

end

##

# Suffixes for require-able paths.

def self.suffixes

##

# Prints the amount of time the supplied block takes to run using the debug

end

##

plugins.each do |plugin|

# Skip older versions of the GemCutter plugin: Its commands are in

end

end

class << self

##

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

end

module Kernel

##

# Use Kernel#gem to activate a specific version of +gem_name+.

#

# specified gem must match, most commonly "= example.version.number". See

# Gem::Requirement for how to specify a version requirement.

#

#

# GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb

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

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

end

private :gem

# "#{ConfigMap[:datadir]}/#{package_name}".

def RbConfig.datadir(package_name)

Gem.datadir(package_name) ||

File.join(Gem::ConfigMap[:datadir], package_name)

end

require 'rubygems/exceptions'

begin

##

rescue LoadError

end

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

require 'rubygems/user_interaction'

##

# The Builder class processes RubyGem specification files

# to produce a .gem file.

# spec:: [Gem::Specification] The specification instance

def initialize(spec)

@spec = spec

end

def write_package

open @spec.file_name, 'wb' do |gem_io|

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

@spec.files.each do |file|

next if File.directory? file

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

end

##

# Display to the user that a gem couldn't be found and reasons why

if errors and !errors.empty?

alert_error "Could not find a valid gem '#{gem_name}' (#{version}), here is why:"

errors.each { |x| say " #{x.wordy}" }

else

alert_error "Could not find a valid gem '#{gem_name}' (#{version}) in any repository"

end

end

##

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/command'

require 'rubygems/user_interaction'

# Register all the subcommands supported by the gem command.

def initialize

@commands = {}

register_command :build

register_command :cert

register_command :install

register_command :list

register_command :lock

register_command :outdated

register_command :owner

register_command :pristine

require 'rubygems/command'

require 'rubygems/builder'

require 'rubygems/command'

require 'rubygems/security'

add_option('-C', '--certificate CERT',

'Certificate for --sign command.') do |value, options|

cert = OpenSSL::X509::Certificate.new(File.read(value))

end

add_option('-K', '--private-key KEY',

'Private key for --sign command.') do |value, options|

key = OpenSSL::PKey::RSA.new(File.read(value))

end

add_option('-s', '--sign NEWCERT',

'Sign a certificate with my key and',

'certificate.') do |value, options|

cert = OpenSSL::X509::Certificate.new(File.read(value))

cert = Gem::Security.sign_cert(cert, my_key, my_cert)

File.open(value, 'wb') { |file| file.write(cert.to_pem) }

end

require 'rubygems/command'

require 'rubygems/version_option'

require 'rubygems/validator'

options[:alien] = true

end

end

def execute

if options[:alien]

say "Performing the 'alien' operation"

say

say " #{error_entry.problem}"

end

else

end

say

end

require 'rubygems/command'

require 'rubygems/source_index'

require 'rubygems/dependency_list'

def initialize

super 'cleanup',

'Clean up old versions of installed gems in the local repository',

add_option('-d', '--dryrun', "") do |value, options|

options[:dryrun] = true

require 'rubygems/command'

require 'rubygems/version_option'

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/version_option'

if remote? and not options[:reverse_dependencies] then

fetcher = Gem::SpecFetcher.fetcher

end

end

require 'rubygems/command'

class Gem::Commands::EnvironmentCommand < Gem::Command

gempath display path used to search for gems

version display the gem format version

remotesources display the remote gem servers

<omitted> display everything

EOF

return args.gsub(/^\s+/, '')

levels

:update_sources: Enable/disable automatic updating of repository metadata

:backtrace: Print backtrace when RubyGems encounters an error

:gempath: The paths in which to look for gems

gem_command: A string containing arguments for the specified gem command

out << Gem.path.join(File::PATH_SEPARATOR)

when /^remotesources/ then

out << Gem.sources.join("\n")

when nil then

out = "RubyGems Environment:\n"

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/version_option'

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

if spec.nil? then

next

end

require 'rubygems/command'

require 'rubygems/indexer'

end

add_option '--[no-]legacy',

unless options[:build_modern] or value then

raise OptionParser::InvalidOption, 'no indicies will be built'

end

quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file

# these files support legacy RubyGems

Marshal.<version>

Marshal.<version>.Z # Marshal full index

The .Z and .rz extension files are compressed with the inflate algorithm.

The Marshal version number comes from ruby's Marshal::MAJOR_VERSION and

Marshal::MINOR_VERSION constants. It is used to ensure compatibility.

If --rss-host and --rss-gem-host are given an RSS feed will be generated at

index.rss containing gems released in the last two days.

require 'rubygems/command'

class Gem::Commands::HelpCommand < Gem::Command

gem install rake --remote

* Install 'rake', but only version 0.3.1, even if dependencies

are not met, and into a user-specific directory:

require 'rubygems/command'

require 'rubygems/doc_manager'

require 'rubygems/install_update_options'

:generate_rdoc => true,

:generate_ri => true,

:format_executable => false,

:version => Gem::Requirement.default,

})

def defaults_str # :nodoc:

"--both --version '#{Gem::Requirement.default}' --rdoc --ri --no-force\n" \

end

def description # :nodoc:

get_all_gem_names.each do |gem_name|

begin

inst = Gem::DependencyInstaller.new options

inst.install gem_name, options[:version]

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

exit_code |= 1

rescue Gem::GemNotFoundException => e

exit_code |= 2

end

Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc

end

end

end

raise Gem::SystemExitException, exit_code

require 'rubygems/command'

require 'rubygems/commands/query_command'

require 'rubygems/command'

class Gem::Commands::LockCommand < Gem::Command

until pending.empty? do

full_name = pending.shift

if spec.nil? then

complain "Could not find gem #{full_name}, try using the full name"

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/spec_fetcher'

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/gemcutter_utilities'

require 'rubygems/command'

require 'rubygems/format'

require 'rubygems/installer'

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/gemcutter_utilities'

def initialize

super 'push', description

add_proxy_option

end

def execute

end

def send_gem name

request.body = Gem.read_binary name

request.add_field "Content-Length", request.body.size

request.add_field "Content-Type", "application/octet-stream"

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/spec_fetcher'

all = options[:all]

output_query_results spec_tuples

end

require 'rubygems/command'

require 'rubygems/version_option'

require 'rubygems/doc_manager'

require 'rubygems/command'

require 'rubygems/commands/query_command'

require 'rubygems/command'

require 'rubygems/server'

options[:addresses] ||= []

options[:addresses].push(*address)

end

end

def defaults_str # :nodoc:

require 'rubygems/command'

##

# Installs RubyGems itself. This command is ordinarily only available from a

class Gem::Commands::SetupCommand < Gem::Command

def initialize

super 'setup', 'Install RubyGems',

:format_executable => true, :rdoc => true, :ri => true,

:site_or_vendor => :sitelibdir,

check_ruby_version

if Gem.configuration.really_verbose then

extend FileUtils::Verbose

else

require 'rubygems/command'

require 'rubygems/remote_fetcher'

require 'rubygems/source_info_cache'

include Gem::LocalRemoteOptions

def initialize

super 'sources',

'Manage the sources and cache file RubyGems uses to search for gems'

rescue URI::Error, ArgumentError

say "#{source_uri} is not a URI"

rescue Gem::RemoteFetcher::FetchError => e

end

end

if options[:update] then

fetcher = Gem::SpecFetcher.fetcher

end

say "source cache successfully updated"

require 'rubygems/command'

require 'rubygems/local_remote_options'

require 'rubygems/version_option'

include Gem::VersionOption

def initialize

super 'specification', 'Display gem specification (in yaml)',

:domain => :local, :version => Gem::Requirement.default,

:format => :yaml

require 'rubygems/command'

class Gem::Commands::StaleCommand < Gem::Command

require 'rubygems/command'

require 'rubygems/version_option'

require 'rubygems/uninstaller'

require 'rubygems/command'

require 'rubygems/installer'

require 'rubygems/version_option'

include Gem::VersionOption

def initialize

super 'unpack', 'Unpack an installed gem to the current directory',

:version => Gem::Requirement.default,

:target => Dir.pwd

require 'rubygems/command'

require 'rubygems/command_manager'

require 'rubygems/install_update_options'

'Update the named gems (or all installed gems) in the local repository',

:generate_rdoc => true,

:generate_ri => true,

add_install_update_options

end

def defaults_str # :nodoc:

end

def usage # :nodoc:

hig['rubygems-update'] = rubygems_update

options[:user_install] = false

else

say "Updating installed gems"

end

end

else

end

end

end

end

dependency = Gem::Dependency.new l_spec.name, "> #{l_spec.version}"

matching_gems = spec_tuples.select do |(name, _, platform),|

name == l_name and Gem::Platform.match platform

require 'rubygems/command'

require 'rubygems/gem_path_searcher'

found = false

options[:args].each do |arg|

dirs = $LOAD_PATH

spec = searcher.find arg

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

system_config_path =

begin

Etc.sysconfdir

end

SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'gemrc'

dirname = File.dirname(credentials_path)

Dir.mkdir(dirname) unless File.exists?(dirname)

File.open(credentials_path, 'w') do |f|

f.write config.to_yaml

end

def load_file(filename)

return {} unless filename and File.exists?(filename)

begin

YAML.load(File.read(filename))

rescue ArgumentError

warn "Failed to load #{config_file_name}"

# Writes out this config file, replacing its source.

def write

open config_file_name, 'w' do |io|

io.write to_yaml

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

def require(path) # :doc:

gem_original_require path

rescue LoadError => load_error

end

raise load_error

private :require

private :gem_original_require

module Gem

@post_install_hooks ||= []

require "rubygems/requirement"

##

class Gem::Dependency

##

# Valid dependency types.

#--

unless TYPES.include? type

raise ArgumentError, "Valid types are #{TYPES.inspect}, "

end

@name = name

@prerelease || requirement.prerelease?

end

q.group 1, 'Gem::Dependency.new(', ')' do

q.pp name

q.text ','

@requirement = @version_requirements if defined?(@version_requirements)

end

def requirements_list

requirement.as_list

end

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

end

def == other # :nodoc:

Gem::Dependency === other &&

self.name == other.name &&

# Dependencies are ordered by name.

def <=> other

end

##

def =~ other

unless Gem::Dependency === other

end

reqs = other.requirement.requirements

requirement.satisfied_by? version

end

end

end

require 'rubygems'

require 'rubygems/dependency_list'

require 'rubygems/installer'

dependency_list = Gem::DependencyList.new @development

dependency_list.add(*specs)

end

end

end

end

end

##

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

begin

yield spec

rescue TSort::Cyclic

end

break

end

# +ignored+.

def active_count(specs, ignored)

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems'

##

# RDoc (template etc.) as a String.

def initialize(spec, rdoc_args="")

@spec = spec

@doc_dir = File.join(spec.installation_path, "doc", spec.full_name)

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

class Gem::ErrorReason; end

# Generated when trying to lookup a gem to indicate that the gem

##

# Base exception class for RubyGems. All exception raised by RubyGems are a

# subclass of this one.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

File.open('Makefile', 'wb') {|f| f.print mf}

unless make_program then

make_program = (/mswin/ =~ RUBY_PLATFORM) ? 'nmake' : 'make'

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

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

dest_path = '"' + dest_path + '"' if dest_path.include?(' ')

cmd += " RUBYARCHDIR=#{dest_path} RUBYLIBDIR=#{dest_path}" # ENV is frozen

run cmd, results

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/package'

##

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# Reference a constant defined in the .rb portion of ssl (just to

# make sure that part is loaded too).

class OpenSSL::X509::Certificate # :nodoc:

# Check the validity of this certificate.

##

# GemPathSearcher has the capability to find loadable files inside

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

end

##

# Return the _gemspec_ of the gem where it was found. If no match

# is found, return nil.

#

# This method doesn't care about the full filename that matches;

# only that there is a match.

end

##

@gemspecs.select do |spec|

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

require 'rubygems/doc_manager'

##

# Run an instance of the gem program.

#

# Gem::GemRunner is only intended for internal use by RubyGems itself. It

end

require 'rubygems/remote_fetcher'

module Gem::GemcutterUtilities

end

end

uri = URI.parse "#{host}/#{path}"

request_method = Net::HTTP.const_get method.to_s.capitalize

require 'rubygems'

require 'rubygems/format'

# Create an indexer that will index the gems in +directory+.

def initialize(directory, options = {})

unless ''.respond_to? :to_xs then

raise "Gem::Indexer requires that the XML Builder library be installed:" \

"\n\tgem install builder"

# Builds indicies for RubyGems older than 1.2.x

def build_legacy_indicies(index)

say "Generating Marshal master index"

Gem.time 'Generated Marshal master index' do

end

end

@files << @marshal_index

@files << "#{@marshal_index}.Z"

end

Gem.time 'Compressed indicies' do

if @build_legacy then

compress @marshal_index, 'Z'

paranoid @marshal_index, 'Z'

end

if @build_modern then

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

options[:force] = value

end

add_option(:"Install/Update", '-w', '--[no-]wrappers',

'Use bin wrappers for executables',

'Not available on dosish platforms') do |value, options|

"dependencies") do |value, options|

options[:development] = true

end

end

##

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/format'

require 'rubygems/ext'

require 'rubygems/require_paths_builder'

include Gem::UserInteraction

##

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

# :wrappers:: Install wrappers if true, symlinks if false.

def initialize(gem, options={})

@gem = gem

options = {

build_extensions

write_spec

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

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

def generate_bin_script(filename, bindir)

bin_script_path = File.join bindir, formatted_program_filename(filename)

end

##

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

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

path = entry['path'].untaint

end

FileUtils.rm_rf(path) if File.exists?(path)

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

out.write file_data

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

end

add_bulk_threshold_option

add_source_option

add_proxy_option

add_update_sources_option

end

##

# Add the --http-proxy option

def add_proxy_option

accept_uri_http

add_option(:"Local/Remote", '--source URL', URI::HTTP,

source << '/' if source !~ /\/\z/

else

end

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#++

require 'rubygems'

##

# The format class knows the guts of the RubyGem .gem file format and provides

# gem:: [String] The file name of the gem

def initialize(gem_path)

@gem_path = gem_path

end

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

# See LICENSE.txt for additional licensing information.

#++

require 'rubygems/security'

require 'rubygems/specification'

class Gem::FileOperations

def initialize(logger = nil)

@logger = logger

end

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

# -*- coding: iso-8859-1 -*-

#++

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

# See LICENSE.txt for additional licensing information.

#--

class Gem::Package::TarInput

include Gem::Package::FSyncDir

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

#++

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

# See LICENSE.txt for additional licensing information.

# -*- coding: utf-8 -*-

#--

# Copyright (C) 2004 Mauricio Julio Fernández Pradier

# Copyright (c) 2003, 2004 Jim Weirich, 2009 Eric Hodel

#

# Permission is hereby granted, free of charge, to any person obtaining

Gem.configuration.verbose = trace

file gem_path => [package_dir, gem_dir] + @gem_spec.files do

end

end

end

end

end

##

# Available list of platforms for targeting Gem installations.

when /hpux(\d+)/ then [ 'hpux', $1 ]

when /^java$/, /^jruby$/ then [ 'java', nil ]

when /^java([\d.]*)/ then [ 'java', $1 ]

when /^dotnet([\d.]*)/ then [ 'dotnet', $1 ]

when /linux/ then [ 'linux', $1 ]

when /mingw32/ then [ 'mingw32', nil ]

require 'rubygems'

##

# RemoteFetcher handles the details of fetching gems and gem information from

# * <tt>:no_proxy</tt>: ignore environment variables and _don't_ use a proxy

def initialize(proxy = nil)

Socket.do_not_reverse_lookup = true

@connections = {}

# always replaced.

def download(spec, source_uri, install_dir = Gem.dir)

if File.writable?(install_dir)

cache_dir = File.join install_dir, 'cache'

else

source_uri.path

end

begin

FileUtils.cp source_path, local_gem_path unless

def escape(str)

return unless str

end

def unescape(str)

return unless str

end

##

]

end

@connections[connection_id] ||= Net::HTTP.new(*net_http_args)

connection = @connections[connection_id]

say "#{request.method} #{uri}" if

Gem.configuration.really_verbose

say "#{response.code} #{response.message}" if

Gem.configuration.really_verbose

require 'rubygems'

module Gem::RequirePathsBuilder

def write_require_paths_file_if_needed(spec = @spec, gem_home = @gem_home)

end

end

require "rubygems/version"

##

"<" => lambda { |v, r| v < r },

">=" => lambda { |v, r| v >= r },

"<=" => lambda { |v, r| v <= r },

}

quoted = OPS.keys.map { |k| Regexp.quote k }.join "|"

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/gem_openssl'

# = Signed Gems README

#

# == Table of Contents

# A more detailed description of each options is available in the walkthrough

# above.

#

#

# == OpenSSL Reference

#

module Gem::Security

class Exception < Gem::Exception; end

OPT = {

# private key options

:key_algo => Gem::SSL::PKEY_RSA,

'basicConstraints' => 'CA:FALSE',

'subjectKeyIdentifier' => 'hash',

'keyUsage' => 'keyEncipherment,dataEncipherment,digitalSignature',

}

# A Gem::Security::Policy object encapsulates the settings for verifying

# signed gem files. This is the base class. You can either declare an

# instance of this or use one of the preset security policies below.

class Policy

attr_accessor :verify_data, :verify_signer, :verify_chain,

:verify_root, :only_trusted, :only_signed

end

end

# No security policy: all package signature checks are disabled.

NoSecurity = Policy.new(

:verify_data => false,

:verify_signer => false,

:only_signed => false

)

# AlmostNo security policy: only verify that the signing certificate is the

# one that actually signed the data. Make no attempt to verify the signing

# certificate chain.

#

# This policy is basically useless. better than nothing, but can still be

# easily spoofed, and is not recommended.

AlmostNoSecurity = Policy.new(

:verify_data => true,

:verify_signer => false,

:only_signed => false

)

# Low security policy: only verify that the signing certificate is actually

# the gem signer, and that the signing certificate is valid.

#

# This policy is better than nothing, but can still be easily spoofed, and

# is not recommended.

LowSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:only_signed => false

)

# Medium security policy: verify the signing certificate, verify the signing

# certificate chain all the way to the root certificate, and only trust root

# certificates that we have explicitly allowed trust for.

# This security policy is reasonable, but it allows unsigned packages, so a

# malicious person could simply delete the package signature and pass the

# gem off as unsigned.

MediumSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:only_signed => false

)

# High security policy: only allow signed gems to be installed, verify the

# signing certificate, verify the signing certificate chain all the way to

# the root certificate, and only trust root certificates that we have

#

# This security policy is significantly more difficult to bypass, and offers

# a reasonable guarantee that the contents of the gem have not been altered.

HighSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:only_signed => true

)

# Hash of configured security policies

Policies = {

'NoSecurity' => NoSecurity,

'AlmostNoSecurity' => AlmostNoSecurity,

'HighSecurity' => HighSecurity,

}

# Sign the cert cert with @signing_key and @signing_cert, using the digest

# algorithm opt[:dgst_algo]. Returns the newly signed certificate.

def self.sign_cert(cert, signing_key, signing_cert, opt = {})

opt = OPT.merge(opt)

cert.issuer = signing_cert.subject

cert

end

# Make sure the trust directory exists. If it does exist, make sure it's

# actually a directory. If not, then create it with the appropriate

# permissions.

def self.verify_trust_dir(path, perms)

# if the directory exists, then make sure it is in fact a directory. if

# it doesn't exist, then create it with the appropriate permissions

end

end

# Build a certificate from the given DN and private key.

def self.build_cert(name, key, opt = {})

Gem.ensure_ssl_available

end

# Build a self-signed certificate for the given email address.

def self.build_self_signed_cert(email_addr, opt = {})

Gem.ensure_ssl_available

opt = OPT.merge(opt)

path = { :key => nil, :cert => nil }

path[:key] = opt[:save_key_path] || (opt[:output_fmt] % 'private_key')

end

end

path[:cert] = opt[:save_cert_path] || (opt[:output_fmt] % 'public_cert')

end

end

{ :key => key, :cert => cert,

:key_path => path[:key], :cert_path => path[:cert] }

end

# Add certificate to trusted cert list.

#

# Note: At the moment these are stored in OPT[:trust_dir], although that

# directory may change in the future.

def self.add_trusted_cert(cert, opt = {})

opt = OPT.merge(opt)

nil

end

# Basic OpenSSL-based package signing class.

class Signer

def initialize(key, cert_chain)

Gem.ensure_ssl_available

end

end

# Sign data with given digest algorithm

def sign(data)

@key.sign(@algo.new, data)

end

end

end

require 'webrick'

require 'zlib'

require 'erb'

# * legacy indexes:

# * "/Marshal.#{Gem.marshal_version}" - Full SourceIndex dump of metadata

# for installed gems

#

# == Usage

#

def self.run(options)

new(options[:gemdir], options[:port], options[:daemon],

end

##

# Only the first directory in gem_dirs is used for serving gems

Socket.do_not_reverse_lookup = true

@gem_dirs = Array gem_dirs

@port = port

@daemon = daemon

@addresses = addresses

logger = WEBrick::Log.new nil, WEBrick::BasicLog::FATAL

@server = WEBrick::HTTPServer.new :DoNotListen => true, :Logger => logger

add_date res

case req.request_uri.path

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

dep = Gem::Dependency.new $2, $3

specs = @source_index.search dep

elsif marshal_format then

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

res.body << Gem.deflate(Marshal.dump(specs.first))

end

else

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

values = { "gem_count" => specs.size.to_s, "specs" => specs,

"total_file_count" => total_file_count.to_s }

result = template.result binding

res.body = result

end

WEBrick::Daemon.start if @daemon

@server.mount_proc "/Marshal.#{Gem.marshal_version}", method(:Marshal)

@server.mount_proc "/Marshal.#{Gem.marshal_version}.Z", method(:Marshal)

trap("INT") { @server.shutdown; exit! }

trap("TERM") { @server.shutdown; exit! }

@server.start

end

end

end

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/specification'

##

# The SourceIndex object indexes all the gems available from a

# particular source (e.g. a list of gem directories, or a remote

include Enumerable

attr_reader :gems # :nodoc:

##

attr_accessor :spec_dirs

class << self

##

# Factory method to construct a source index instance for a given

# path.

# loaded spec.

def load_specification(file_name)

end

end

spec_files = Dir.glob File.join(spec_dir, '*.gemspec')

spec_files.each do |spec_file|

add_spec gemspec if gemspec

end

end

##

# Find a gem by an exact match on the short name.

search dep

end

# behavior is deprecated and will be removed.

def search(gem_pattern, platform_only = false)

only_platform = false

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

case gem_pattern

when Regexp then

when Gem::Dependency then

only_platform = platform_only

gem_pattern = if Regexp === gem_pattern.name then

gem_pattern.name

elsif gem_pattern.name.empty? then

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

end

else

gem_pattern = /#{gem_pattern}/i

end

end

specs = all_gems.values.select do |spec|

spec.name =~ gem_pattern and

end

if only_platform then

latest_specs.each do |local|

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

latest = remotes.sort.last

outdateds

end

def ==(other) # :nodoc:

self.class === other and @gems == other.gems

end

Marshal.dump(self)

end

end

# :stopdoc:

require 'rubygems/remote_fetcher'

require 'rubygems/user_interaction'

require 'rubygems/errors'

##

# SpecFetcher handles metadata updates from remote gem repositories.

class Gem::SpecFetcher

include Gem::UserInteraction

##

# The SpecFetcher cache dir.

end

def initialize

@dir = File.join Gem.user_home, '.gem', 'specs'

@update_cache = File.stat(Gem.user_home).uid == Process.uid

@latest_specs = {}

@prerelease_specs = {}

@fetcher = Gem::RemoteFetcher.fetcher

end

end

return [ss, errors]

end

def fetch(*args)

end

##

end

##

:latest

end

Gem.sources.each do |source_uri|

source_uri = URI.parse source_uri

specs

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

end

##

end

##

def hash # :nodoc:

@@attributes.inject(0) { |hash_code, (name, _)|

}

end

result << nil

result << " if s.respond_to? :specification_version then"

result << " s.specification_version = #{specification_version}"

result << nil

# Warnings

value = self.send attribute

alert_warning "no #{attribute} specified" if value.nil? or value.empty?

end

require 'tempfile'

require 'rubygems'

require 'rubygems/remote_fetcher'

require 'rubygems'

##

result.join("\n").gsub(/^/, " " * indent)

end

end

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

result

end

end

##

end

end

end

##

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

# See LICENSE.txt for permissions.

#++

require 'rubygems/format'

require 'rubygems/installer'

##

# Validator performs various gem file and gem database validation

include Gem::UserInteraction

##

# Given a gem file's contents, validates against its own MD5 checksum

# gem_data:: [String] Contents of the gem file

errors

end

def remove_leading_dot_dir(path)

path.sub(/^\.\//, "")

end

##

# The Version class processes string versions into comparable

# values. A version string should normally be a series of numbers

#

# If any part contains letters (currently only a-z are supported) then

# that version is considered prerelease. Versions with a prerelease

#

# Prereleases sort between real releases (newest to oldest):

#

# 1. 1.0

# 4. 0.9

#

# == How Software Changes

# "~> 3.5.0" 3.5.0 ... 3.6

class Gem::Version

include Comparable

VERSION_PATTERN = '[0-9]+(\.[0-9a-zA-Z]+)*' # :nodoc:

@version = version.to_s

@version.strip!

end

##

# Return a new version object where the next to the last revision

# number is one greater (e.g., 5.3.1 => 5.4).

#

def bump

segments = self.segments.dup

# same precision. Version "1.0" is not the same as version "1".

def eql? other

end

def hash # :nodoc:

# A version is considered a prerelease if it contains a letter.

def prerelease?

end

def pretty_print q # :nodoc:

def segments # :nodoc:

/^\d+$/ =~ s ? s.to_i : s

end

end

end

##

def <=> other

limit = (lhsize > rhsize ? lhsize : rhsize) - 1

end

return 0

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

#--

# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.

# All rights reserved.

require 'rubygems'

require 'minitest/unit'

require 'test/insure_session'

require 'rubygems/installer'

class Gem::Installer

require 'rubygems/package'

class TarTestCase < RubyGemTestCase

def util_entry(tar)

io = TempIO.new tar

header = Gem::Package::TarHeader.from io

end

def util_dir_entry

at_exit { $SAFE = 1 }

require 'fileutils'

require 'minitest/autorun'

require 'tmpdir'

require 'rubygems/test_utilities'

require 'pp'

require 'yaml'

begin

YAML::ENGINE.yamler = 'psych'

rescue LoadError

require 'rdoc/rdoc'

module Gem

def self.searcher=(searcher)

end

def self.source_index=(si)

@@win_platform = val

end

module DefaultUserInteraction

@ui = MockGemUi.new

end

def setup

super

@ui = MockGemUi.new

tmpdir = nil

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

@tempdir.untaint

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

Gem.ensure_gem_subdirectories @gemhome

FileUtils.mkdir_p @gemhome

FileUtils.mkdir_p @userhome

Gem.use_paths(@gemhome)

Gem.loaded_specs.clear

Gem.pre_uninstall do |uninstaller|

@pre_uninstall_hook_arg = uninstaller

end

end

def teardown

Gem::ConfigMap[:BASERUBY] = @orig_BASERUBY

Gem::ConfigMap[:arch] = @orig_arch

Gem::RemoteFetcher.fetcher = nil

end

Gem.clear_paths

if @orig_ENV_HOME then

ENV['HOME'] = @orig_ENV_HOME

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

end

def mu_pp(obj)

s = ''

s = PP.pp obj, s

Gem.source_index.refresh!

end

spec = quick_gem(name, version, &block)

util_build_gem spec

def build_rake_in

gem_ruby = Gem.ruby

env_rake = ENV["rake"]

ENV["rake"] = @@rake

yield @@rake

ensure

if env_rake

ENV["rake"] = env_rake

else

end

def self.rubybin

ruby = "ruby"

3.times do

if File.exist? ruby and File.executable? ruby and !File.directory? ruby

return File.expand_path(ruby)

end

ruby = File.join("..", ruby)

end

begin

require "rbconfig"

rescue LoadError

"ruby"

end

require 'rubygems'

def install_session

require 'stringio'

require 'rubygems/user_interaction'

TestGem::TEST_PLUGIN_EXCEPTION = :loaded

raise Exception.new('boom') \ No newline at end of file

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

TestGem::TEST_PLUGIN_STANDARDERROR = :loaded

raise StandardError.new('boom') \ No newline at end of file

class Gem::Commands::CrashCommand < Gem::Command

raise "crash"

require 'rubygems/command_manager'

##

SIMPLE_GEM = <<-GEMDATA

MD5SUM = "b12a4d48febeb2289c539c2574c4b6f8"

if $0 == __FILE__

require 'rubygems'

class TestConfig < RubyGemTestCase

def test_datadir

end

end

require 'rubygems'

require 'rubygems/gem_openssl'

require 'rubygems/installer'

assert_equal @exec_path, Gem.bin_path('a', nil, '4')

end

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

s.executables = ['exec']

end

end

end

def test_self_bin_path_no_bin_file

quick_gem 'a', '1'

assert_raises(Gem::Exception) do

end

end

end

end

def test_self_bindir

assert_equal File.join(@gemhome, 'bin'), Gem.bindir

assert_equal File.join(@gemhome, 'bin'), Gem.bindir(Gem.dir)

end

def test_self_find_files

cwd = File.expand_path '..', __FILE__

$LOAD_PATH.unshift cwd.dup

s.files << discover_path

end

s.files << discover_path

end

Gem.searcher = nil

expected = [

File.join(foo2.full_gem_path, discover_path),

File.join(foo1.full_gem_path, discover_path),

]

ensure

assert_equal cwd, $LOAD_PATH.shift

end

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

end

def test_self_path

assert_equal [Gem.dir], Gem.path

end

def test_self_path_default

if defined? APPLE_GEM_HOME

orig_APPLE_GEM_HOME = APPLE_GEM_HOME

Object.send :remove_const, :APPLE_GEM_HOME

unless win_platform?

def test_self_path_APPLE_GEM_HOME

Gem.clear_paths

apple_gem_home = File.join @tempdir, 'apple_gem_home'

Gem.const_set :APPLE_GEM_HOME, apple_gem_home

end

end

def test_load_plugins

assert_equal :loaded, TEST_PLUGIN_LOAD

util_remove_interrupt_command

# Should attempt to cause a StandardError

assert_equal :loaded, TEST_PLUGIN_STANDARDERROR

util_remove_interrupt_command

# Should attempt to cause an Exception

assert_equal :loaded, TEST_PLUGIN_EXCEPTION

end

require 'rubygems/builder'

class TestGemBuilder < RubyGemTestCase

require 'rubygems/command'

class Gem::Command

require 'rubygems/command_manager'

class TestGemCommandManager < RubyGemTestCase

end

def test_run_interrupt

use_ui @ui do

assert_raises MockGemUi::TermError do

assert_equal '', ui.output

assert_equal "ERROR: Interrupted\n", ui.error

end

end

def test_run_crash_command

@command_manager.register_command :crash

use_ui @ui do

assert_raises MockGemUi::TermError do

err = ui.error.split("\n").first

assert_equal "ERROR: Loading command: crash (RuntimeError)", err

end

end

def test_process_args_bad_arg

#check defaults

@command_manager.process_args("install")

assert_equal true, check_options[:generate_rdoc]

assert_equal false, check_options[:force]

assert_equal :both, check_options[:domain]

#check settings

check_options = nil

@command_manager.process_args(

assert_equal true, check_options[:generate_rdoc]

assert_equal true, check_options[:force]

assert_equal :local, check_options[:domain]

#check settings

check_options = nil

assert_equal true, check_options[:generate_rdoc]

assert_equal true, check_options[:force]

assert_equal Dir.pwd, check_options[:install_dir]

require 'rubygems/commands/build_command'

require 'rubygems/format'

require 'rubygems/commands/cert_command'

unless defined? OpenSSL then

assert_equal '', @ui.error

assert_equal File.read(@cert_file_name),

end

def test_execute_list

assert_equal '', @ui.error

assert_equal File.read(@pkey_file_name),

end

def test_execute_remove

require 'rubygems/commands/check_command'

class TestGemCommandsCheckCommand < RubyGemTestCase

require 'rubygems/commands/contents_command'

class TestGemCommandsContentsCommand < RubyGemTestCase

require 'rubygems/commands/dependency_command'

class TestGemCommandsDependencyCommand < RubyGemTestCase

require 'rubygems/commands/environment_command'

class TestGemCommandsEnvironmentCommand < RubyGemTestCase

assert_equal '', @ui.error

end

require 'rubygems/package'

require 'rubygems/security'

require 'rubygems/commands/fetch_command'

require 'rubygems/indexer'

require 'rubygems/commands/generate_index_command'

@cmd.execute

end

end

def test_execute_rss_update

require 'rubygems/commands/install_command'

class TestGemCommandsInstallCommand < RubyGemTestCase

assert_match(/ould not find a valid gem 'nonexistent'/, @ui.error)

end

def test_execute_prerelease

util_setup_fake_fetcher(:prerelease)

util_setup_spec_fetcher @a2, @a2_pre

assert out.empty?, out.inspect

end

end

require 'rubygems/commands/list_command'

class TestGemCommandsListCommand < RubyGemTestCase

require 'rubygems/commands/lock_command'

class TestGemCommandsLockCommand < RubyGemTestCase

require 'rubygems/commands/outdated_command'

class TestGemCommandsOutdatedCommand < RubyGemTestCase

end

def test_execute

remote_10 = quick_gem 'foo', '1.0'

remote_20 = quick_gem 'foo', '2.0'

require 'rubygems/commands/owner_command'

class TestGemCommandsOwnerCommand < RubyGemTestCase

- email: [email protected]

EOF

use_ui @ui do

@cmd.show_owners("freewill")

def test_show_owners_denied

response = "You don't have permission to push to this gem"

assert_raises MockGemUi::TermError do

use_ui @ui do

def test_add_owners

response = "Owner added successfully."

use_ui @ui do

@cmd.add_owners("freewill", ["[email protected]"])

def test_add_owners_denied

response = "You don't have permission to push to this gem"

assert_raises MockGemUi::TermError do

use_ui @ui do

def test_remove_owners

response = "Owner removed successfully."

use_ui @ui do

@cmd.remove_owners("freewill", ["[email protected]"])

def test_remove_owners_denied

response = "You don't have permission to push to this gem"

assert_raises MockGemUi::TermError do

use_ui @ui do

require 'rubygems/commands/pristine_command'

class TestGemCommandsPristineCommand < RubyGemTestCase

require 'rubygems/commands/push_command'

class TestGemCommandsPushCommand < RubyGemTestCase

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

end

use_ui @ui do

@cmd.send_gem(@path)

end

assert_equal Net::HTTP::Post, @fetcher.last_request.class

assert_equal Gem.read_binary(@path), @fetcher.last_request.body

assert_equal "application/octet-stream", @fetcher.last_request["Content-Type"]

assert_equal Gem.configuration.rubygems_api_key, @fetcher.last_request["Authorization"]

end

def test_raises_error_with_no_arguments

def test_sending_gem_denied

response = "You don't have permission to push to this gem"

assert_raises MockGemUi::TermError do

use_ui @ui do

require 'rubygems/commands/query_command'

class TestGemCommandsQueryCommand < RubyGemTestCase

end

def test_execute_all

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

use_ui @ui do

end

def test_execute_all_prerelease

@cmd.handle_options %w[-r --all --prerelease]

use_ui @ui do

require 'rubygems/commands/server_command'

class TestGemCommandsServerCommand < RubyGemTestCase

require 'rubygems/commands/sources_command'

class TestGemCommandsSourcesCommand < RubyGemTestCase

require 'rubygems/commands/specification_command'

class TestGemCommandsSpecificationCommand < RubyGemTestCase

end

def test_execute_all

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

@cmd.options[:all] = true

end

def test_execute_exact_match

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

require 'rubygems/commands/stale_command'

class TestGemCommandsStaleCommand < RubyGemTestCase

require 'rubygems/commands/uninstall_command'

class TestGemCommandsUninstallCommand < GemInstallerTestCase

require 'rubygems/commands/unpack_command'

class TestGemCommandsUnpackCommand < RubyGemTestCase

require 'rubygems/commands/update_command'

class TestGemCommandsUpdateCommand < RubyGemTestCase

require 'rubygems/commands/which_command'

class TestGemCommandsWhichCommand < RubyGemTestCase

require 'rubygems/config_file'

class TestGemConfigFile < RubyGemTestCase

fp.puts ":benchmark: true"

fp.puts ":bulk_threshold: 10"

fp.puts ":verbose: false"

fp.puts ":sources:"

fp.puts " - http://more-gems.example.com"

fp.puts "install: --wrappers"

assert_equal 10, @cfg.bulk_threshold

assert_equal false, @cfg.verbose

assert_equal false, @cfg.update_sources

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

assert_equal '--wrappers', @cfg[:install]

assert_equal(['/usr/ruby/1.8/lib/ruby/gems/1.8', '/var/ruby/1.8/gem_home'],

require 'rubygems/dependency'

class TestGemDependency < RubyGemTestCase

def test_initialize

d = dep "pkg", "> 1.0"

assert d.prerelease?

end

end

require 'rubygems/dependency_installer'

class TestGemDependencyInstaller < RubyGemTestCase

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

end

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

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

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

end

@fetcher = Gem::FakeFetcher.new

Gem::RemoteFetcher.fetcher = @fetcher

util_clear_gems

end

end

def test_install_all_dependencies

s.add_dependency 'b'

end

end

def test_install_dependency_old

FileUtils.mv e1_gem, @tempdir

FileUtils.mv f1_gem, @tempdir

assert_equal [@a1_pre], prereleases

end

inst = Gem::DependencyInstaller.new

inst.gather_dependencies

end

inst = Gem::DependencyInstaller.new

inst.gather_dependencies

end

def test_gather_dependencies_platform_alternate

end

def test_gather_dependencies_old_required

util_clear_gems

inst = Gem::DependencyInstaller.new

inst.find_spec_by_name_and_version 'e'

require 'rubygems/dependency_list'

class TestGemDependencyList < RubyGemTestCase

require 'rubygems/doc_manager'

class TestGemDocManager < RubyGemTestCase

require 'rubygems/ext'

class TestGemExtConfigureBuilder < RubyGemTestCase

require 'rubygems/ext'

class TestGemExtExtConfBuilder < RubyGemTestCase

Gem::Ext::ExtConfBuilder.build 'extconf.rb', nil, @dest_path, output

end

assert_match(/^#{Gem.ruby} extconf.rb/, output[0])

assert_equal "creating Makefile\n", output[1]

assert_equal make_command, output[2]

end

def test_class_build_extconf_fail

require 'rubygems/ext'

class TestGemExtRakeBuilder < RubyGemTestCase

output = output.join "\n"

refute_match %r%^rake failed:%, output

assert_match %r%^#{Regexp.escape @@ruby} mkrf_conf\.rb%, output

assert_match %r%^#{Regexp.escape @@rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, output

end

end

assert_match %r%^rake failed:%, error.message

assert_match %r%^#{Regexp.escape @@ruby} mkrf_conf\.rb%, error.message

assert_match %r%^#{Regexp.escape @@rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, error.message

require 'rubygems/format'

class TestGemFormat < RubyGemTestCase

require 'rubygems/gem_path_searcher'

class Gem::GemPathSearcher

require 'rubygems/gem_runner'

class TestGemGemRunner < RubyGemTestCase

require 'rubygems'

require 'rubygems/gemcutter_utilities'

class TestGemGemcutterUtilities < RubyGemTestCase

if host

ENV['RUBYGEMS_HOST'] = host

else

end

@fetcher = Gem::FakeFetcher.new

require 'rubygems/indexer'

unless ''.respond_to? :to_xs then

@indexer.generate_index

end

assert_indexed @tempdir, "Marshal.#{@marshal_version}"

assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"

assert File.directory?(quickdir)

assert File.directory?(marshal_quickdir)

assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"

assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"

refute_indexed marshal_quickdir, @c1_2.spec_name

assert_indexed @tempdir, "specs.#{@marshal_version}"

@indexer.generate_index

end

assert_indexed @tempdir, "Marshal.#{@marshal_version}"

assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"

assert File.directory?(quickdir)

assert File.directory?(marshal_quickdir)

assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"

assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"

refute_indexed marshal_quickdir, "#{@c1_2.spec_name}"

refute_indexed @tempdir, "specs.#{@marshal_version}"

@indexer.generate_index

end

assert_indexed @tempdir, "Marshal.#{@marshal_version}"

assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"

quickdir = File.join @tempdir, 'quick'

marshal_quickdir = File.join quickdir, "Marshal.#{@marshal_version}"

assert File.directory?(marshal_quickdir)

assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"

assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"

@indexer.generate_index

end

assert_indexed @tempdir, "Marshal.#{@marshal_version}"

assert_indexed @tempdir, "Marshal.#{@marshal_version}.Z"

assert File.directory?(quickdir)

assert File.directory?(marshal_quickdir)

assert_indexed marshal_quickdir, "#{@a1.spec_name}.rz"

assert_indexed marshal_quickdir, "#{@a2.spec_name}.rz"

assert_match %r%^Loaded all gems$%, @ui.output

assert_match %r%^Generating Marshal quick index gemspecs for 10 gems$%,

@ui.output

assert_match %r%^Complete$%, @ui.output

assert_match %r%^Generating specs index$%, @ui.output

assert_match %r%^Generating latest specs index$%, @ui.output

assert_match %r%^Generating prerelease specs index$%, @ui.output

assert_match %r%^Generating Marshal master index$%, @ui.output

assert_match %r%^Complete$%, @ui.output

assert_match %r%^Compressing indicies$%, @ui.output

assert_equal '', @ui.error

end

def test_generate_index_specs

use_ui @ui do

@indexer.generate_index

require 'rubygems/install_update_options'

require 'rubygems/command'

end

def test_add_install_update_options

--ignore-dependencies --format-exec --include-dependencies]

assert @cmd.handles?(args)

class TestGemInstaller < GemInstallerTestCase

assert_equal '', @ui.error

gem_make_out = File.join @gemhome, 'gems', @spec.full_name, 'gem_make.out'

assert_match %r%#{Regexp.escape Gem.ruby} extconf\.rb%,

File.read(gem_make_out)

use_ui @ui do

Dir.chdir @tempdir do Gem::Builder.new(@spec).build end

@installer.install

end

require 'rubygems/local_remote_options'

require 'rubygems/command'

assert_equal true, @cmd.both?

end

def test_local_eh

assert_equal false, @cmd.local?

s3 = URI.parse 'http://other-gems.example.com/some_subdir'

s4 = URI.parse 'http://more-gems.example.com/' # Intentional duplicate

@cmd.handle_options %W[--source #{s1} --source #{s2} --source #{s3} --source #{s4}]

end

def test_update_sources_option

require 'rubygems/package'

class TestGemPackageTarHeader < TarTestCase

require 'rubygems/package/tar_input'

class TestGemPackageTarInput < TarTestCase

require 'rubygems/package/tar_output'

class TestGemPackageTarOutput < TarTestCase

require 'rubygems/package'

class TestGemPackageTarReader < TarTestCase

require 'rubygems/package'

class TestGemPackageTarReaderEntry < TarTestCase

require 'rubygems/package/tar_writer'

class TestTarWriter < TarTestCase

require 'rubygems'

require 'rubygems/package_task'

def test_gem_package

gem = Gem::Specification.new do |g|

require 'rubygems/platform'

require 'rbconfig'

def test_initialize_platform

platform = Gem::Platform.new 'cpu-my_platform1'

assert_equal 'cpu', platform.cpu

assert_equal 'my_platform', platform.os

require 'ostruct'

require 'webrick'

require 'rubygems/remote_fetcher'

uri.user, uri.password = 'domain%5Cuser', 'bar'

fetcher = Gem::RemoteFetcher.new uri.to_s

proxy = fetcher.instance_variable_get("@proxy_uri")

assert_equal 'bar', proxy.password

assert_data_from_proxy fetcher.fetch_path(@server_uri)

end

fetcher = Gem::RemoteFetcher.new uri.to_s

proxy = fetcher.instance_variable_get("@proxy_uri")

assert_equal 'user', proxy.user

assert_data_from_proxy fetcher.fetch_path(@server_uri)

end

end

ENV['http_proxy_pass'] = 'my bar'

fetcher = Gem::RemoteFetcher.new nil

proxy = fetcher.instance_variable_get("@proxy_uri")

assert_data_from_proxy fetcher.fetch_path(@server_uri)

end

end

end

end

fetcher.instance_variable_set :@connections, conn

data = fetcher.open_uri_or_path 'http://gems.example.com/redirect'

res

end

fetcher.instance_variable_set :@connections, conn

e = assert_raises Gem::RemoteFetcher::FetchError do

def assert_error(exception_class=Exception)

got_exception = false

begin

yield

got_exception = true

end

assert got_exception, "Expected exception conforming to #{exception_class}"

end

require "rubygems/requirement"

class TestGemRequirement < RubyGemTestCase

refute_satisfied_by "2.0", "~> 1.4.4"

refute_satisfied_by "1.1.pre", "~> 1.0.0"

refute_satisfied_by "2.0.a", "~> 1.0"

end

def test_satisfied_by_eh_multiple

require 'rubygems/server'

require 'stringio'

def test_listen

util_listen

@server.listen

end

def test_listen_addresses

util_listen

@server.listen %w[a b]

end

end

def test_quick_missing

end

def test_quick_marshal_a_1_mswin32_gemspec_rz

data = StringIO.new "GET /quick/Marshal.#{Gem.marshal_version}/a-1-#{Gem::Platform.local}.gemspec.rz HTTP/1.0\r\n\r\n"

@req.parse data

Marshal.load(Gem.gunzip(@res.body))

end

def util_listen

webrick = Object.new

webrick.instance_variable_set :@listeners, []

require 'rubygems/source_index'

require 'rubygems/config_file'

class TestGemSourceIndex < RubyGemTestCase

def setup

fp.write 'raise Exception, "epic fail"'

end

assert_equal nil, Gem::SourceIndex.load_specification(spec_file)

end

end

def test_self_load_specification_interrupt

fp.write '1 +'

end

assert_equal nil, Gem::SourceIndex.load_specification(spec_file)

end

end

def test_self_load_specification_system_exit

# TODO

end

def test_find_name

assert_equal [@a1, @a2, @a3a], @source_index.find_name('a')

assert_equal [@a2], @source_index.find_name('a', '= 2')

assert_equal 'source index not created from disk', e.message

end

def test_remove_spec

deleted = @source_index.remove_spec 'a-1'

assert_match(/^[a-f0-9]{64}$/, sig)

end

end

require 'rubygems/spec_fetcher'

class TestGemSpecFetcher < RubyGemTestCase

require 'stringio'

require 'rubygems/specification'

s.summary = %q{this is a summary}

if s.respond_to? :specification_version then

s.specification_version = #{Gem::Specification::CURRENT_SPECIFICATION_VERSION}

if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

s.test_files = [\"test/suite.rb\"]

if s.respond_to? :specification_version then

s.specification_version = 3

if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

end

end

def test_validate_rubygems_version

util_setup_validate

specfile.write "raise 'boom'"

specfile.close

begin

rescue => e

name_rexp = Regexp.new(Regexp.escape(specfile.path))

assert e.backtrace.grep(name_rexp).any?

require 'rubygems/user_interaction'

class TestGemStreamUI < RubyGemTestCase

@err = StringIO.new

@in.extend IsTty

@sui = Gem::StreamUI.new @in, @out, @err

end

assert_equal "which one?\n 1. foo\n 2. bar\n> ", @out.string

end

@cfg.verbose = nil

reporter = @sui.progress_reporter 10, 'hi'

assert_kind_of Gem::StreamUI::SilentProgressReporter, reporter

end

@cfg.verbose = false

reporter = @sui.progress_reporter 10, 'hi'

assert_kind_of Gem::StreamUI::SilentProgressReporter, reporter

assert_equal "", @out.string

end

@cfg.verbose = true

reporter = @sui.progress_reporter 10, 'hi'

assert_kind_of Gem::StreamUI::SimpleProgressReporter, reporter

assert_equal "hi\n", @out.string

end

@cfg.verbose = 0

reporter = @sui.progress_reporter 10, 'hi'

assert_kind_of Gem::StreamUI::VerboseProgressReporter, reporter

assert_equal "hi\n", @out.string

end

require 'rubygems/uninstaller'

class TestGemUninstaller < GemInstallerTestCase

require 'rubygems/validator'

class TestGemValidator < RubyGemTestCase

class TestGemVersion < RubyGemTestCase

assert_bumped_version_equal "5.3", "5.2.4.a"

end

def test_bump_trailing_zeros

assert_bumped_version_equal "5.1", "5.0.0"

end

end

def test_eql_eh

end

end

# REVISIT: consider removing as too impl-bound

end

def test_spaceship

end

def test_spermy_recommendation

require 'rubygems/command'

require 'rubygems/version_option'

class TestKernel < RubyGemTestCase

def test_gem

assert gem('a', '= 1'), "Should load"

assert $:.any? { |p| %r{a-1/lib} =~ p }

end

def test_gem_redundent

assert gem('a', '= 1'), "Should load"

refute gem('a', '= 1'), "Should not load"

assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size

end

def test_gem_overlapping

assert gem('a', '= 1'), "Should load"

refute gem('a', '>= 1'), "Should not load"

assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size

end

def test_gem_conflicting

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

assert_match(/activated a-1/, ex.message)

assert_equal 'a', ex.name

assert $:.any? { |p| %r{a-1/lib} =~ p }

refute $:.any? { |p| %r{a-2/lib} =~ p }

end

end