- VERSION = '2.0.4'

- REPOSITORY_SUBDIRECTORIES.each do |name|

- # Register a Gem::Specification for default gem

-require 'openssl'

- key = OpenSSL::PKey::RSA.new File.read key_file

- key = options[:key] || Gem::Security.create_key

- cert = Gem::Security.create_cert_email name, key

- key_path = Gem::Security.write key, "gem-private_key.pem"

- say "Private Key: #{key_path}"

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

- options[:key] = OpenSSL::PKey::RSA.new key

-end

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

-

- path = Gem.path.dup

- path.delete Gem.dir

- path.each do |p|

- out << " - #{p}\n"

- end

- * The CPU must match exactly, unless one of the platforms has

- "universal" as the CPU.

- "[No command found for #{cmd_name}, bug?]"

-require 'rubygems/install_message' # must come before rdoc for messaging

-require 'rubygems/rdoc'

-

- # TODO use installer options

- install_defaults = Gem::ConfigFile::PLATFORM_DEFAULTS['install']

- installer_env_shebang = install_defaults.to_s['--env-shebang']

- :env_shebang => installer_env_shebang,

- path = File.join Gem.user_home, '.gem', 'specs'

- rescue ArgumentError

- warn "Failed to load #{filename}"

- spec = Gem::Specification.find { |s|

- matches = Gem::Specification.find_all { |spec|

- }

-require 'rubygems/source_local'

-require 'rubygems/source_specific_file'

- attr_reader :gems_to_install

- attr_reader :installed_gems

-

- ##

- # Documentation types. For use by the Gem.done_installing hook

-

- attr_reader :document

-

- DEFAULT_OPTIONS = {

- def initialize(options = {})

- # Set with any errors that SpecFetcher finds while search through

- # gemspecs for a dep

- attr_reader :errors

- def find_gems_with_sources(dep)

- def gather_dependencies

- def add_found_dependencies to_do, dependency_list

- seen = {}

- dependencies = Hash.new { |h, name| h[name] = Gem::Dependency.new name }

-

- until to_do.empty? do

- spec = to_do.shift

-

- # HACK why is spec nil?

- next if spec.nil? or seen[spec.name]

- seen[spec.name] = true

-

- deps = spec.runtime_dependencies

-

- if @development

- if @dev_shallow

- if @toplevel_specs.include? spec.full_name

- deps |= spec.development_dependencies

- end

- else

- deps |= spec.development_dependencies

- end

- end

-

- deps.each do |dep|

- dependencies[dep.name] = dependencies[dep.name].merge dep

-

- if @minimal_deps

- next if Gem::Specification.any? do |installed_spec|

- dep.name == installed_spec.name and

- dep.requirement.satisfied_by? installed_spec.version

- end

- end

-

- results = find_gems_with_sources(dep)

-

- results.sorted.each do |t|

- to_do.push t.spec

- end

-

- results.remove_installed! dep

-

- @available << results

- results.inject_into_list dependency_list

- end

- end

-

- dependency_list.remove_specs_unsatisfied_by dependencies

- end

-

- ##

- # Finds a spec and the source_uri it came from for gem +gem_name+ and

- # +version+. Returns an Array of specs and sources required for

- # installation of the gem.

-

- def find_spec_by_name_and_version(gem_name,

- version = Gem::Requirement.default,

- prerelease = false)

-

- set = Gem::AvailableSet.new

-

- if consider_local?

- if gem_name =~ /\.gem$/ and File.file? gem_name then

- src = Gem::Source::SpecificFile.new(gem_name)

- set.add src.spec, src

- else

- local = Gem::Source::Local.new

-

- if s = local.find_gem(gem_name, version)

- set.add s, local

-

- if set.empty?

- dep = Gem::Dependency.new gem_name, version

- # HACK Dependency objects should be immutable

- dep.prerelease = true if prerelease

-

- set = find_gems_with_sources(dep)

- set.match_platform!

- end

-

- if set.empty?

- raise Gem::SpecificGemNotFoundException.new(gem_name, version, @errors)

- end

-

- @available = set

- available_set_for dep_or_name, version

- gather_dependencies

-

- # REFACTOR is the last gem always the one that the user requested?

- # This code assumes that but is that actually validated by the code?

-

- last = @gems_to_install.size - 1

- @gems_to_install.each_with_index do |spec, index|

- # REFACTOR more current spec set hardcoding, should be abstracted?

- next if Gem::Specification.include?(spec) and index != last

-

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

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

-

- source = @available.source_for spec

-

- begin

- # REFACTOR make the fetcher to use configurable

- local_gem_path = source.download spec, @cache_dir

- rescue Gem::RemoteFetcher::FetchError

- # TODO I doubt all fetch errors are recoverable, we should at least

- # report the errors probably.

- next if @force

- raise

- end

-

- if @development

- if @dev_shallow

- is_dev = @toplevel_specs.include? spec.full_name

- else

- is_dev = true

- end

- end

- inst = Gem::Installer.new local_gem_path,

- :bin_dir => @bin_dir,

- :development => is_dev,

- :env_shebang => @env_shebang,

- :force => @force,

- :format_executable => @format_executable,

- :ignore_dependencies => @ignore_dependencies,

- :install_dir => @install_dir,

- :security_policy => @security_policy,

- :user_install => @user_install,

- :wrappers => @wrappers,

- :build_args => @build_args

-

- spec = inst.install

-

- @installed_gems << spec

- def in_background what

- fork_happened = false

- if @build_docs_in_background and Process.respond_to?(:fork)

- begin

- Process.fork do

- yield

- end

- fork_happened = true

- say "#{what} in a background process."

- rescue NotImplementedError

- end

- yield unless fork_happened

-module Gem

- # Raised when a DependencyConflict reaches the toplevel.

- # Indicates which dependencies were incompatible.

- #

- class DependencyResolutionError < Gem::Exception

- def initialize(conflict)

- @conflict = conflict

- a, b = conflicting_dependencies

- super "unable to resolve conflicting dependencies '#{a}' and '#{b}'"

- end

- attr_reader :conflict

- def conflicting_dependencies

- @conflict.conflicting_dependencies

- end

- end

- # Raised when a dependency requests a gem for which there is

- # no spec.

- #

- class UnsatisfiableDepedencyError < Gem::Exception

- def initialize(dep)

- super "unable to find any gem matching dependency '#{dep}'"

- @dependency = dep

- end

- attr_reader :dependency

- end

- # Raised when dependencies conflict and create the inability to

- # find a valid possible spec for a request.

- #

- class ImpossibleDependenciesError < Gem::Exception

- def initialize(request, conflicts)

- s = conflicts.size == 1 ? "" : "s"

- super "detected #{conflicts.size} conflict#{s} with dependency '#{request.dependency}'"

- @request = request

- @conflicts = conflicts

- end

- def dependency

- @request.dependency

- end

- attr_reader :conflicts

- # Given a set of Gem::Dependency objects as +needed+ and a way

- # to query the set of available specs via +set+, calculates

- # a set of ActivationRequest objects which indicate all the specs

- # that should be activated to meet the all the requirements.

- class DependencyResolver

-

- # Represents a specification retrieved via the rubygems.org

- # API. This is used to avoid having to load the full

- # Specification object when all we need is the name, version,

- # and dependencies.

- #

- class APISpecification

- attr_reader :set # :nodoc:

-

- def initialize(set, api_data)

- @set = set

- @name = api_data[:name]

- @version = Gem::Version.new api_data[:number]

- @dependencies = api_data[:dependencies].map do |name, ver|

- Gem::Dependency.new name, ver.split(/\s*,\s*/)

- end

- end

-

- attr_reader :name, :version, :dependencies

-

- def == other # :nodoc:

- self.class === other and

- @set == other.set and

- @name == other.name and

- @version == other.version and

- @dependencies == other.dependencies

- end

-

- def full_name

- "#{@name}-#{@version}"

- end

- end

-

- # The global rubygems pool, available via the rubygems.org API.

- # Returns instances of APISpecification.

- #

- class APISet

- def initialize

- @data = Hash.new { |h,k| h[k] = [] }

- @dep_uri = URI 'https://rubygems.org/api/v1/dependencies'

- end

-

- # Return data for all versions of the gem +name+.

- #

- def versions(name)

- if @data.key?(name)

- return @data[name]

- end

-

- uri = @dep_uri + "?gems=#{name}"

- str = Gem::RemoteFetcher.fetcher.fetch_path uri

-

- Marshal.load(str).each do |ver|

- @data[ver[:name]] << ver

- end

-

- @data[name]

- end

-

- # Return an array of APISpecification objects matching

- # DependencyRequest +req+.

- #

- def find_all(req)

- res = []

-

- versions(req.name).each do |ver|

- if req.dependency.match? req.name, ver[:number]

- res << APISpecification.new(self, ver)

- end

- end

-

- res

- end

-

- # A hint run by the resolver to allow the Set to fetch

- # data for DependencyRequests +reqs+.

- #

- def prefetch(reqs)

- names = reqs.map { |r| r.dependency.name }

- needed = names.find_all { |d| [email protected]?(d) }

-

- return if needed.empty?

-

- uri = @dep_uri + "?gems=#{needed.sort.join ','}"

- str = Gem::RemoteFetcher.fetcher.fetch_path uri

-

- Marshal.load(str).each do |ver|

- @data[ver[:name]] << ver

- end

- end

- end

-

- # Represents a possible Specification object returned

- # from IndexSet. Used to delay needed to download full

- # Specification objects when only the +name+ and +version+

- # are needed.

- #

- class IndexSpecification

- def initialize(set, name, version, source, plat)

- @set = set

- @name = name

- @version = version

- @source = source

- @platform = plat

-

- @spec = nil

- end

-

- attr_reader :name, :version, :source

-

- def full_name

- "#{@name}-#{@version}"

- end

-

- def spec

- @spec ||= @set.load_spec(@name, @version, @source)

- end

-

- def dependencies

- spec.dependencies

- end

- end

-

- # The global rubygems pool represented via the traditional

- # source index.

- #

- class IndexSet

- def initialize

- @f = Gem::SpecFetcher.fetcher

-

- @all = Hash.new { |h,k| h[k] = [] }

-

- list, _ = @f.available_specs(:released)

- list.each do |uri, specs|

- specs.each do |n|

- @all[n.name] << [uri, n]

- end

- end

-

- @specs = {}

- end

-

- # Return an array of IndexSpecification objects matching

- # DependencyRequest +req+.

- #

- def find_all(req)

- res = []

-

- name = req.dependency.name

-

- @all[name].each do |uri, n|

- if req.dependency.match? n

- res << IndexSpecification.new(self, n.name, n.version,

- uri, n.platform)

- end

- end

-

- res

- end

-

- # No prefetching needed since we load the whole index in

- # initially.

- #

- def prefetch(gems)

- end

-

- # Called from IndexSpecification to get a true Specification

- # object.

- #

- def load_spec(name, ver, source)

- key = "#{name}-#{ver}"

- @specs[key] ||= source.fetch_spec(Gem::NameTuple.new(name, ver))

- end

- end

-

- # A set which represents the installed gems. Respects

- # all the normal settings that control where to look

- # for installed gems.

- #

- class CurrentSet

- def find_all(req)

- req.dependency.matching_specs

- end

-

- def prefetch(gems)

- end

- end

-

- # Create DependencyResolver object which will resolve

- # the tree starting with +needed+ Depedency objects.

- #

- # +set+ is an object that provides where to look for

- # specifications to satisify the Dependencies. This

- # defaults to IndexSet, which will query rubygems.org.

- #

- def initialize(needed, set=IndexSet.new)

- @set = set || IndexSet.new # Allow nil to mean IndexSet

- @needed = needed

-

- @conflicts = nil

- end

-

- # Provide a DependencyResolver that queries only against

- # the already installed gems.

- #

- def self.for_current_gems(needed)

- new needed, CurrentSet.new

- end

-

- # Contains all the conflicts encountered while doing resolution

- #

- attr_reader :conflicts

-

- # Proceed with resolution! Returns an array of ActivationRequest

- # objects.

- #

- def resolve

- @conflicts = []

-

- needed = @needed.map { |n| DependencyRequest.new(n, nil) }

-

- res = resolve_for needed, []

-

- if res.kind_of? DependencyConflict

- raise DependencyResolutionError.new(res)

- end

-

- res

- end

-

- # Used internally to indicate that a dependency conflicted

- # with a spec that would be activated.

- #

- class DependencyConflict

- def initialize(dependency, activated, failed_dep=dependency)

- @dependency = dependency

- @activated = activated

- @failed_dep = failed_dep

- end

-

- attr_reader :dependency, :activated

-

- # Return the Specification that listed the dependency

- #

- def requester

- @failed_dep.requester

- end

-

- def for_spec?(spec)

- @dependency.name == spec.name

- end

- # Return the 2 dependency objects that conflicted

- #

- def conflicting_dependencies

- [@failed_dep.dependency, @activated.request.dependency]

- end

- # Used Internally. Wraps a Depedency object to also track

- # which spec contained the Dependency.

- #

- class DependencyRequest

- def initialize(dep, act)

- @dependency = dep

- @requester = act

- end

- attr_reader :dependency, :requester

- def name

- @dependency.name

- end

- def matches_spec?(spec)

- @dependency.matches_spec? spec

- end

- def to_s

- @dependency.to_s

- end

- def ==(other)

- case other

- when Dependency

- @dependency == other

- when DependencyRequest

- @dependency == other.dependency && @requester == other.requester

- else

- false

- end

- end

- # Specifies a Specification object that should be activated.

- # Also contains a dependency that was used to introduce this

- # activation.

- #

- class ActivationRequest

- def initialize(spec, req, others_possible=true)

- @spec = spec

- @request = req

- @others_possible = others_possible

- end

-

- attr_reader :spec, :request

- # Indicate if this activation is one of a set of possible

- # requests for the same Dependency request.

- #

- def others_possible?

- @others_possible

- end

- # Return the ActivationRequest that contained the dependency

- # that we were activated for.

- #

- def parent

- @request.requester

- end

-

- def name

- @spec.name

- end

-

- def full_name

- @spec.full_name

- end

-

- def version

- @spec.version

- end

-

- def full_spec

- Gem::Specification === @spec ? @spec : @spec.spec

- end

- def download(path)

- if @spec.respond_to? :source

- source = @spec.source

- source = Gem.sources.first

- Gem.ensure_gem_subdirectories path

-

- source.download full_spec, path

- end

-

- def ==(other)

- case other

- when Gem::Specification

- @spec == other

- when ActivationRequest

- @spec == other.spec && @request == other.request

- else

- false

- end

- ##

- # Indicates if the requested gem has already been installed.

- def installed?

- this_spec = full_spec

- Gem::Specification.any? do |s|

- s == this_spec

- end

- end

-

- def requests(s, act)

- reqs = []

- s.dependencies.each do |d|

- next unless d.type == :runtime

- reqs << DependencyRequest.new(d, act)

- end

-

- @set.prefetch(reqs)

-

- reqs

- end

-

- # The meat of the algorithm. Given +needed+ DependencyRequest objects

- # and +specs+ being a list to ActivationRequest, calculate a new list

- # of ActivationRequest objects.

- #

- def resolve_for(needed, specs)

- until needed.empty?

- dep = needed.shift

-

- # If there is already a spec activated for the requested name...

- if existing = specs.find { |s| dep.name == s.name }

-

- # then we're done since this new dep matches the

- # existing spec.

- next if dep.matches_spec? existing

-

- # There is a conflict! We return the conflict

- # object which will be seen by the caller and be

- # handled at the right level.

-

- # If the existing activation indicates that there

- # are other possibles for it, then issue the conflict

- # on the dep for the activation itself. Otherwise, issue

- # it on the requester's request itself.

- #

- if existing.others_possible?

- conflict = DependencyConflict.new(dep, existing)

- depreq = existing.request.requester.request

- conflict = DependencyConflict.new(depreq, existing, dep)

- @conflicts << conflict

-

- return conflict

- # Get a list of all specs that satisfy dep

- possible = @set.find_all(dep)

-

- case possible.size

- when 0

- # If there are none, then our work here is done.

- raise UnsatisfiableDepedencyError.new(dep)

- when 1

- # If there is one, then we just add it to specs

- # and process the specs dependencies by adding

- # them to needed.

-

- spec = possible.first

- act = ActivationRequest.new(spec, dep, false)

-

- specs << act

-

- # Put the deps for at the beginning of needed

- # rather than the end to match the depth first

- # searching done by the multiple case code below.

- #

- # This keeps the error messages consistent.

- needed = requests(spec, act) + needed

- else

- # There are multiple specs for this dep. This is

- # the case that this class is built to handle.

-

- # Sort them so that we try the highest versions

- # first.

- possible = possible.sort_by { |s| s.version }

-

- # We track the conflicts seen so that we can report them

- # to help the user figure out how to fix the situation.

- conflicts = []

-

- # To figure out which to pick, we keep resolving

- # given each one being activated and if there isn't

- # a conflict, we know we've found a full set.

- #

- # We use an until loop rather than #reverse_each

- # to keep the stack short since we're using a recursive

- # algorithm.

- #

- until possible.empty?

- s = possible.pop

-

- # Recursively call #resolve_for with this spec

- # and add it's dependencies into the picture...

-

- act = ActivationRequest.new(s, dep)

-

- try = requests(s, act) + needed

-

- res = resolve_for(try, specs + [act])

-

- # While trying to resolve these dependencies, there may

- # be a conflict!

-

- if res.kind_of? DependencyConflict

- # The conflict might be created not by this invocation

- # but rather one up the stack, so if we can't attempt

- # to resolve this conflict (conflict isn't with the spec +s+)

- # then just return it so the caller can try to sort it out.

- return res unless res.for_spec? s

-

- # Otherwise, this is a conflict that we can attempt to fix

- conflicts << [s, res]

-

- # Optimization:

- #

- # Because the conflict indicates the dependency that trigger

- # it, we can prune possible based on this new information.

- #

- # This cuts down on the number of iterations needed.

- possible.delete_if { |x| !res.dependency.matches_spec? x }

- else

- # No conflict, return the specs

- return res

- end

- end

-

- # We tried all possibles and nothing worked, so we let the user

- # know and include as much information about the problem since

- # the user is going to have to take action to fix this.

- raise ImpossibleDependenciesError.new(dep, conflicts)

- end

-

- specs

- make_program = $1 || ENV['MAKE'] || ENV['make']

- def run(args)

- if args.include?('--')

- # We need to preserve the original ARGV to use for passing gem options

- # to source gems. If there is a -- in the line, strip all options after

- # it...its for the source building process.

- # TODO use slice!

- build_args = args[args.index("--") + 1...args.length]

- args = args[0...args.index("--")]

- end

- attr_writer :host

- def host

- configured_host = Gem.host unless

- Gem.configuration.disable_default_gem_server

-

- @host ||=

- begin

- env_rubygems_host = ENV['RUBYGEMS_HOST']

- env_rubygems_host = nil if

- env_rubygems_host and env_rubygems_host.empty?

-

- env_rubygems_host|| configured_host

- end

- end

-

- def rubygems_api_request(method, path, host = nil, &block)

- require 'net/http'

- self.host = host if host

- unless self.host

- alert_error "You must specify a gem server"

-

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

-

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

-

- Gem::RemoteFetcher.fetcher.request(uri, request_method, &block)

- def with_response resp, error_prefix = nil

- case resp

- yield resp

- say resp.body

- message = resp.body

- def verify_api_key(key)

- if Gem.configuration.api_keys.key? key then

- Gem.configuration.api_keys[key]

- else

- alert_error "No such API key. Please add it to your configuration (done automatically on initial `gem push`)."

- terminate_interaction 1 # TODO: question this

- end

- end

-

-

- extract_files

-

- build_extensions

- write_build_info_file

- run_post_build_hooks

-

- generate_bin

- write_spec

- write_cache_file

- :install_dir => Gem.dir,

- @gem_home = options[:install_dir]

- Gem.ensure_gem_subdirectories gem_home

- case @platform

- when nil, 'ruby', ''

- "#{@name}-#{@version}.gemspec"

- else

- "#{@name}-#{@version}-#{@platform}.gemspec"

- end

- def to_s

- [Gem::Security::DIGEST_NAME]

- digester = OpenSSL::Digest.new algorithm

- def extract_files destination_dir

- extract_tar_gz entry, destination_dir

- def extract_tar_gz io, destination_dir # :nodoc:

- @signer = Gem::Security::Signer.new @spec.signing_key, @spec.cert_chain

- @signer = Gem::Security::Signer.new nil, nil

- file_name = entry.full_name

- @files << file_name

-

- case file_name

- when /\.sig$/ then

- @signatures[$`] = entry.read if @security_policy

- next

- else

- digest entry

- end

-

- case file_name

- when /^metadata(.gz)?$/ then

- load_spec entry

- when 'data.tar.gz' then

- verify_gz entry

- end

- def header(type, fname, dname, length, mode, checksum = nil)

- Z(to_oct(0, 11)), # char mtime[12]; 0 padded, octal, null

- def tar_dir_header(name, prefix, mode)

- h = header("5", name, prefix, 0, mode)

- header("5", name, prefix, 0, mode, checksum)

- def tar_file_header(fname, dname, mode, length)

- h = header("0", fname, dname, length, mode)

- header("0", fname, dname, length, mode, checksum)

- util_entry tar_dir_header("foo", "bar", 0)

- :size => size, :prefix => prefix

- [digest.name, digest]

- OpenSSL::Digest::SHA512,

- ].uniq

- signature_digest = digests.values.find do |digest|

- digest.name == signer.digest_name

- signature = signer.sign signature_digest.digest

- add_file_simple "#{name}.sig", 0444, signature.length do |io|

- io.write signature

- end if signature

- :size => size, :prefix => prefix).to_s

- :prefix => prefix

- (@cpu == 'universal' or other.cpu == 'universal' or @cpu == other.cpu) and

-require 'uri'

- @connections = {}

- @requests = Hash.new 0

- @proxy_uri =

- case proxy

- when :no_proxy then nil

- when nil then get_proxy_from_env

- when URI::HTTP then proxy

- else URI.parse(proxy)

- end

- @user_agent = user_agent

- @env_no_proxy = get_no_proxy_from_env

- source_path = unescape source_path

- def escape(str)

- return unless str

- @uri_parser ||= uri_escaper

- @uri_parser.escape str

- end

-

- def unescape(str)

- return unless str

- @uri_parser ||= uri_escaper

- @uri_parser.unescape str

- end

-

- def uri_escaper

- URI::Parser.new

- rescue NameError

- URI

- end

-

- ##

- # Returns list of no_proxy entries (if any) from the environment

-

- def get_no_proxy_from_env

- env_no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']

-

- return [] if env_no_proxy.nil? or env_no_proxy.empty?

-

- env_no_proxy.split(/\s*,\s*/)

- end

-

- ##

- # Returns an HTTP proxy URI if one is set in the environment variables.

-

- def get_proxy_from_env

- env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']

-

- return nil if env_proxy.nil? or env_proxy.empty?

-

- uri = URI.parse(normalize_uri(env_proxy))

-

- if uri and uri.user.nil? and uri.password.nil? then

- # Probably we have http_proxy_* variables?

- uri.user = escape(ENV['http_proxy_user'] || ENV['HTTP_PROXY_USER'])

- uri.password = escape(ENV['http_proxy_pass'] || ENV['HTTP_PROXY_PASS'])

- end

-

- uri

- end

-

- ##

- # Normalize the URI by adding "http://" if it is missing.

-

- def normalize_uri(uri)

- (uri =~ /^(https?|ftp|file):/i) ? uri : "http://#{uri}"

- end

-

- ##

- # Creates or an HTTP connection based on +uri+, or retrieves an existing

- # connection, using a proxy if needed.

-

- def connection_for(uri)

- net_http_args = [uri.host, uri.port]

-

- if @proxy_uri and not no_proxy?(uri.host) then

- net_http_args += [

- @proxy_uri.host,

- @proxy_uri.port,

- @proxy_uri.user,

- @proxy_uri.password

- ]

- end

-

- connection_id = [Thread.current.object_id, *net_http_args].join ':'

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

- connection = @connections[connection_id]

-

- if https?(uri) and not connection.started? then

- configure_connection_for_https(connection)

- end

-

- connection.start unless connection.started?

-

- connection

- rescue defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : Errno::EHOSTDOWN,

- Errno::EHOSTDOWN => e

- raise FetchError.new(e.message, uri)

- end

-

- def configure_connection_for_https(connection)

- require 'net/https'

- connection.use_ssl = true

- connection.verify_mode =

- Gem.configuration.ssl_verify_mode || OpenSSL::SSL::VERIFY_PEER

- store = OpenSSL::X509::Store.new

- if Gem.configuration.ssl_ca_cert

- if File.directory? Gem.configuration.ssl_ca_cert

- store.add_path Gem.configuration.ssl_ca_cert

- else

- store.add_file Gem.configuration.ssl_ca_cert

- end

- else

- store.set_default_paths

- add_rubygems_trusted_certs(store)

- end

- connection.cert_store = store

- rescue LoadError => e

- raise unless (e.respond_to?(:path) && e.path == 'openssl') ||

- e.message =~ / -- openssl$/

-

- raise Gem::Exception.new(

- 'Unable to require openssl, install OpenSSL and rebuild ruby (preferred) or use non-HTTPS sources')

- end

-

- def add_rubygems_trusted_certs(store)

- pattern = File.expand_path("./ssl_certs/*.pem", File.dirname(__FILE__))

- Dir.glob(pattern).each do |ssl_cert_file|

- store.add_file ssl_cert_file

- end

- end

-

- def no_proxy? host

- host = host.downcase

- @env_no_proxy.each do |pattern|

- pattern = pattern.downcase

- return true if host[-pattern.length, pattern.length ] == pattern

- end

- return false

- end

-

- request = request_class.new uri.request_uri

-

- unless uri.nil? || uri.user.nil? || uri.user.empty? then

- request.basic_auth uri.user, uri.password

- end

-

- request.add_field 'User-Agent', @user_agent

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

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

-

- if last_modified then

- last_modified = last_modified.utc

- request.add_field 'If-Modified-Since', last_modified.rfc2822

- end

-

- yield request if block_given?

-

- connection = connection_for uri

-

- retried = false

- bad_response = false

-

- begin

- @requests[connection.object_id] += 1

-

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

- Gem.configuration.really_verbose

-

- file_name = File.basename(uri.path)

- # perform download progress reporter only for gems

- if request.response_body_permitted? && file_name =~ /\.gem$/

- reporter = ui.download_reporter

- response = connection.request(request) do |incomplete_response|

- if Net::HTTPOK === incomplete_response

- reporter.fetch(file_name, incomplete_response.content_length)

- downloaded = 0

- data = ''

-

- incomplete_response.read_body do |segment|

- data << segment

- downloaded += segment.length

- reporter.update(downloaded)

- end

- reporter.done

- if incomplete_response.respond_to? :body=

- incomplete_response.body = data

- else

- incomplete_response.instance_variable_set(:@body, data)

- end

- end

- end

- else

- response = connection.request request

- end

-

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

- Gem.configuration.really_verbose

-

- rescue Net::HTTPBadResponse

- say "bad response" if Gem.configuration.really_verbose

-

- reset connection

-

- raise FetchError.new('too many bad responses', uri) if bad_response

-

- bad_response = true

- retry

- # HACK work around EOFError bug in Net::HTTP

- # NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible

- # to install gems.

- rescue EOFError, Timeout::Error,

- Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE

-

- requests = @requests[connection.object_id]

- say "connection reset after #{requests} requests, retrying" if

- Gem.configuration.really_verbose

-

- raise FetchError.new('too many connection resets', uri) if retried

-

- reset connection

-

- retried = true

- retry

- end

-

- response

- end

-

- ##

- # Resets HTTP connection +connection+.

-

- def reset(connection)

- @requests.delete connection.object_id

-

- connection.finish

- connection.start

- end

-

- def user_agent

- ua = "RubyGems/#{Gem::VERSION} #{Gem::Platform.local}"

-

- ruby_version = RUBY_VERSION

- ruby_version += 'dev' if RUBY_LEVEL == -1

-

- ua << " Ruby/#{ruby_version} (#{RUBY_RELEASE_DATE}"

- if RUBY_LEVEL >= 0 then

- ua << " level #{RUBY_LEVEL}"

- elsif defined?(RUBY_REVISION) then

- ua << " revision #{RUBY_REVISION}"

- end

- ua << ")"

-

- ua << " #{RUBY_ENGINE}" if defined?(RUBY_ENGINE) and RUBY_ENGINE != 'ruby'

-

- ua

-module Gem

- class RequestSet

- include TSort

- def initialize(*deps)

- @dependencies = deps

- yield self if block_given?

- end

- attr_reader :dependencies

- # Declare that a gem of name +name+ with +reqs+ requirements

- # is needed.

- #

- def gem(name, *reqs)

- @dependencies << Gem::Dependency.new(name, reqs)

- end

- # Add +deps+ Gem::Depedency objects to the set.

- #

- def import(deps)

- @dependencies += deps

- end

- # Resolve the requested dependencies and return an Array of

- # Specification objects to be activated.

- #

- def resolve(set=nil)

- r = Gem::DependencyResolver.new(@dependencies, set)

- @requests = r.resolve

- end

- # Resolve the requested dependencies against the gems

- # available via Gem.path and return an Array of Specification

- # objects to be activated.

- #

- def resolve_current

- resolve DependencyResolver::CurrentSet.new

- end

- # Load a dependency management file.

- #

- def load_gemdeps(path)

- gf = GemDepedencyAPI.new(self, path)

- gf.load

- end

- def specs

- @specs ||= @requests.map { |r| r.full_spec }

- end

- def tsort_each_node(&block)

- @requests.each(&block)

- end

- def tsort_each_child(node)

- node.spec.dependencies.each do |dep|

- next if dep.type == :development

-

- match = @requests.find { |r| dep.match? r.spec.name, r.spec.version }

- if match

- begin

- yield match

- rescue TSort::Cyclic

- end

- else

- raise Gem::DependencyError, "Unresolved depedency found during sorting - #{dep}"

- end

- end

- end

- def sorted_requests

- @sorted ||= strongly_connected_components.flatten

- def specs_in(dir)

- Dir["#{dir}/specifications/*.gemspec"].map do |g|

- Gem::Specification.load g

- end

- def install_into(dir, force=true, &b)

- existing = force ? [] : specs_in(dir)

- dir = File.expand_path dir

- installed = []

- sorted_requests.each do |req|

- if existing.find { |s| s.full_name == req.spec.full_name }

- b.call req, nil if b

- next

- end

- path = req.download(dir)

- inst = Gem::Installer.new path, :install_dir => dir,

- :only_install_dir => true

- b.call req, inst if b

- inst.install

- installed << req

- installed

- end

- def install(options, &b)

- if dir = options[:install_dir]

- return install_into(dir, false, &b)

- cache_dir = options[:cache_dir] || Gem.dir

- specs = []

- sorted_requests.each do |req|

- if req.installed?

- b.call req, nil if b

- next

- end

- path = req.download cache_dir

- inst = Gem::Installer.new path, options

- b.call req, inst if b

- specs << inst.install

- end

- specs

- end

- # A semi-compatible DSL for Bundler's Gemfile format

- #

- class GemDepedencyAPI

- def initialize(set, path)

- @set = set

- @path = path

- end

- def load

- instance_eval File.read(@path).untaint, @path, 1

- end

- # DSL

- def source(url)

- end

- def gem(name, *reqs)

- # Ignore the opts for now.

- reqs.pop if reqs.last.kind_of?(Hash)

- @set.gem name, *reqs

- end

- def platform(what)

- if what == :ruby

- yield

- end

- end

- alias_method :platforms, :platform

- def group(*what)

-

- module OpenSSL # :nodoc:

- class Digest # :nodoc:

- class SHA1 # :nodoc:

- def name

- 'SHA1'

- end

- end

- end

- module PKey # :nodoc:

- class RSA # :nodoc:

- end

- end

- end

- DIGEST_ALGORITHM = OpenSSL::Digest::SHA1

- DIGEST_NAME = DIGEST_ALGORITHM.new.name # :nodoc:

- KEY_ALGORITHM = OpenSSL::PKey::RSA

- # +permissions+.

- def self.write pemmable, path, permissions = 0600

- io.write pemmable.to_pem

-require 'rubygems/security/policy'

-require 'rubygems/security/policies'

-require 'rubygems/security/trust_dir'

- # Verifies the certificate +chain+ is valid, the +digests+ match the

- # signatures +signatures+ created by the signer depending on the +policy+

- # settings.

- def verify chain, key = nil, digests = {}, signatures = {}

- if @only_signed and signatures.empty? then

- raise Gem::Security::Exception,

- "unsigned gems are not allowed by the #{name} policy"

- check_trust chain, digester, trust_dir if @only_trusted

- verify chain, nil, digests, signatures

- def initialize key, cert_chain

- @key = OpenSSL::PKey::RSA.new File.read @key if

- if !@uri

- return 0 unless other.uri

- return -1

- end

- return 1 if !other.uri

- @uri.to_s <=> other.uri.to_s

- root = File.join Gem.user_home, '.gem', 'specs'

- File.join root, "#{uri.host}%#{uri.port}", File.dirname(escaped_path)

-class Gem::Source::Local < Gem::Source

- def initialize

- @uri = nil

- end

- def load_specs(type)

- names = []

-

- @specs = {}

-

- Dir["*.gem"].each do |file|

- begin

- pkg = Gem::Package.new(file)

- rescue SystemCallError, Gem::Package::FormatError

- # ignore

- else

- tup = pkg.spec.name_tuple

- @specs[tup] = [File.expand_path(file), pkg]

-

- case type

- when :released

- unless pkg.spec.version.prerelease?

- names << pkg.spec.name_tuple

- end

- when :prerelease

- if pkg.spec.version.prerelease?

- names << pkg.spec.name_tuple

- end

- when :latest

- tup = pkg.spec.name_tuple

-

- cur = names.find { |x| x.name == tup.name }

- if !cur

- names << tup

- elsif cur.version < tup.version

- names.delete cur

- names << tup

- end

- else

- names << pkg.spec.name_tuple

- end

- end

- end

-

- names

- end

-

- def find_gem(gem_name, version=Gem::Requirement.default,

- prerelease=false)

- load_specs :complete

-

- found = []

-

- @specs.each do |n, data|

- if n.name == gem_name

- s = data[1].spec

-

- if version.satisfied_by?(s.version)

- if prerelease

- found << s

- elsif !s.version.prerelease?

- found << s

- end

- end

- end

- end

-

- found.sort_by { |s| s.version }.last

- end

-

- def fetch_spec(name)

- load_specs :complete

-

- if data = @specs[name]

- data.last.spec

- else

- raise Gem::Exception, "Unable to find spec for '#{name}'"

- end

- end

-

- def download(spec, cache_dir=nil)

- load_specs :complete

-

- @specs.each do |name, data|

- return data[0] if data[1].spec == spec

- end

-

- raise Gem::Exception, "Unable to find file for '#{spec.full_name}'"

- end

-end

-class Gem::Source::SpecificFile < Gem::Source

- def initialize(file)

- @uri = nil

- @path = ::File.expand_path(file)

- @package = Gem::Package.new @path

- @spec = @package.spec

- @name = @spec.name_tuple

- end

- attr_reader :spec

-

- def load_specs(*a)

- [@name]

- end

-

- def fetch_spec(name)

- return @spec if name == @name

- raise Gem::Exception, "Unable to find '#{name}'"

- @spec

- end

-

- def download(spec, dir=nil)

- return @path if spec == @spec

- raise Gem::Exception, "Unable to download '#{spec.full_name}'"

- end

-

-end

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

-class Gem::Specification

- # Path this gemspec was loaded from. This attribute is not persisted.

-

- attr_reader :loaded_from

-

- ##

- class << self

- def default_specifications_dir

- File.join(Gem.default_dir, "specifications", "default")

- def each_spec(search_dirs) # :nodoc:

- search_dirs.each { |dir|

- Dir[File.join(dir, "*.gemspec")].each { |path|

- spec = Gem::Specification.load path.untaint

- # #load returns nil if the spec is bad, so we just ignore

- # it at this stage

- yield(spec) if spec

- }

- }

- def each_default(&block) # :nodoc:

- each_spec([default_specifications_dir],

- &block)

- def each_normal(&block) # :nodoc:

- each_spec(dirs, &block)

- def self._all # :nodoc:

- unless defined?(@@all) && @@all then

- specs = {}

- each_default do |spec|

- specs[spec.full_name] ||= spec

- each_normal do |spec|

- specs[spec.full_name] ||= spec

- end

-

- @@all = specs.values

-

- # After a reset, make sure already loaded specs

- # are still marked as activated.

- specs = {}

- Gem.loaded_specs.each_value{|s| specs[s] = true}

- @@all.each{|s| s.activated = true if specs[s]}

- _resort!

- @@all

- def self._resort! # :nodoc:

- @@all.sort! { |a, b|

- each_default do |spec|

- _resort!

- self.find { |spec|

- spec.contains_requirable_file? path unless spec.activated?

- # Returns the full path to the base gem directory.

- #

- # eg: /usr/local/lib/ruby/gems/1.8

-

- def base_dir

- return Gem.dir unless loaded_from

- @base_dir ||= if default_gem? then

- File.dirname File.dirname File.dirname loaded_from

- else

- File.dirname File.dirname loaded_from

- end

- end

-

- ##

- # Return true if this spec can require +file+.

-

- def contains_requirable_file? file

- root = full_gem_path

- suffixes = Gem.suffixes

-

- require_paths.any? do |lib|

- base = "#{root}/#{lib}/#{file}"

- suffixes.any? { |suf| File.file? "#{base}#{suf}" }

- end

- end

-

- ##

- ##

- # The full path to the gem (install path + full name).

-

- def full_gem_path

- # TODO: This is a heavily used method by gems, so we'll need

- # to aleast just alias it to #gem_dir rather than remove it.

-

- # TODO: also, shouldn't it default to full_name if it hasn't been written?

- return @full_gem_path if defined?(@full_gem_path) && @full_gem_path

-

- @full_gem_path = File.expand_path File.join(gems_dir, full_name)

- @full_gem_path.untaint

-

- return @full_gem_path if File.directory? @full_gem_path

-

- @full_gem_path = File.expand_path File.join(gems_dir, original_name)

-

- ##

- # Returns the full name (name-version) of this Gem. Platform information

- # is included (name-version-platform) if it is specified and not the

- # default Ruby platform.

- @full_name ||= if platform == Gem::Platform::RUBY or platform.nil? then

- "#{@name}-#{@version}".untaint

- else

- "#{@name}-#{@version}-#{platform}".untaint

- end

- # Returns the full path to the gems directory containing this spec's

- # gem directory. eg: /usr/local/lib/ruby/1.8/gems

-

- def gems_dir

- # TODO: this logic seems terribly broken, but tests fail if just base_dir

- @gems_dir ||= File.join(loaded_from && base_dir || Gem.dir, "gems")

- end

-

- ##

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

- hash_code ^ self.send(name).hash

- }

- @loaded_from = nil

- value = case default

- when Time, Numeric, Symbol, true, false, nil then default

- else default.dup

- end

-

- ##

- # Set the location a Specification was loaded from. +obj+ is converted

- # to a String.

- def loaded_from= path

- @loaded_from = path.to_s

-

- # reset everything @loaded_from depends upon

- @base_dir = nil

- @full_gem_path = nil

- @gems_dir = nil

- def default_gem?

- loaded_from &&

- File.dirname(loaded_from) == self.class.default_specifications_dir

- end

-

-

- # TODO: move to installer test cases

- Gem.post_build_hooks.clear

- Gem.post_install_hooks.clear

- Gem.done_installing_hooks.clear

- Gem.post_reset_hooks.clear

- Gem.post_uninstall_hooks.clear

- Gem.pre_install_hooks.clear

- Gem.pre_reset_hooks.clear

- Gem.pre_uninstall_hooks.clear

-

- # TODO: move to installer test cases

- Gem.post_build do |installer|

- @post_build_hook_arg = installer

- true

- end

-

- Gem.post_install do |installer|

- @post_install_hook_arg = installer

- end

-

- Gem.post_uninstall do |uninstaller|

- @post_uninstall_hook_arg = uninstaller

- end

-

- Gem.pre_install do |installer|

- @pre_install_hook_arg = installer

- true

- end

-

- Gem.pre_uninstall do |uninstaller|

- @pre_uninstall_hook_arg = uninstaller

- end

- # Loads an RSA private key named +key_name+ in <tt>test/rubygems/</tt>

- def self.load_key key_name

- OpenSSL::PKey::RSA.new key

- # Returns the path tot he key named +key_name+ from <tt>test/rubygems</tt>

- PRIVATE_KEY = load_key 'private'

- PRIVATE_KEY_PATH = key_path 'private'

- PUBLIC_KEY = PRIVATE_KEY.public_key

- PUBLIC_CERT = load_cert 'public'

- PUBLIC_CERT_PATH = cert_path 'public'

- end

- @gem = gem

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

- @gem_home = File.expand_path(options[:install_dir] || Gem.dir)

- @force_executables = options[:executables]

- @force_all = options[:all]

- @force_ignore = options[:ignore]

- @bin_dir = options[:bin_dir]

- @format_executable = options[:format_executable]

- unless ask_if_ok(spec)

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

- attr_reader :version

- @version = version.to_s.dup.strip

- Gem::Requirement.new value

- options[:prerelease] = true if value.prerelease?

- def assert_activate expected, *specs

- specs.each do |spec|

- case spec

- when String then

- Gem::Specification.find_by_name(spec).activate

- when Gem::Specification then

- spec.activate

- else

- flunk spec.inspect

- end

- end

-

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

-

- assert_equal expected.sort, loaded.sort if expected

- end

-

- def test_self_activate

- foo = util_spec 'foo', '1'

-

- assert_activate %w[foo-1], foo

- end

-

- def loaded_spec_names

- Gem.loaded_specs.values.map(&:full_name).sort

- end

-

- def unresolved_names

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

- end

-

- # TODO: move these to specification

- def test_self_activate_via_require

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

- b1 = new_spec "b", "1", nil, "lib/b/c.rb"

- b2 = new_spec "b", "2", nil, "lib/b/c.rb"

-

- install_specs a1, b1, b2

-

- a1.activate

- save_loaded_features do

- require "b/c"

- end

-

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

- end

-

- # TODO: move these to specification

- def test_self_activate_deep_unambiguous

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

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

- b2 = new_spec "b", "2", "c" => "= 2"

- c1 = new_spec "c", "1"

- c2 = new_spec "c", "2"

-

- install_specs a1, b1, b2, c1, c2

-

- a1.activate

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

- end

-

- def save_loaded_features

- old_loaded_features = $LOADED_FEATURES.dup

- yield

- ensure

- $LOADED_FEATURES.replace old_loaded_features

- end

-

- # TODO: move these to specification

- def test_self_activate_ambiguous_direct

- save_loaded_features do

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

- b1 = new_spec("b", "1", { "c" => ">= 1" }, "lib/d.rb")

- b2 = new_spec("b", "2", { "c" => ">= 2" }, "lib/d.rb")

- c1 = new_spec "c", "1"

- c2 = new_spec "c", "2"

-

- Gem::Specification.reset

- install_specs a1, b1, b2, c1, c2

-

- a1.activate

- assert_equal %w(a-1), loaded_spec_names

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

-

- require "d"

-

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

- assert_equal [], unresolved_names

- end

- end

-

- # TODO: move these to specification

- def test_self_activate_ambiguous_indirect

- save_loaded_features do

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

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

- b2 = new_spec "b", "2", "c" => ">= 2"

- c1 = new_spec "c", "1", nil, "lib/d.rb"

- c2 = new_spec "c", "2", nil, "lib/d.rb"

-

- install_specs a1, b1, b2, c1, c2

-

- a1.activate

- assert_equal %w(a-1), loaded_spec_names

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

-

- require "d"

-

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

- assert_equal [], unresolved_names

- end

- end

-

- def test_self_activate_via_require_wtf

- save_loaded_features do

- a1 = new_spec "a", "1", "b" => "> 0", "d" => "> 0" # this

- b1 = new_spec "b", "1", { "c" => ">= 1" }, "lib/b.rb"

- b2 = new_spec "b", "2", { "c" => ">= 2" }, "lib/b.rb" # this

- c1 = new_spec "c", "1"

- c2 = new_spec "c", "2" # this

- d1 = new_spec "d", "1", { "c" => "< 2" }, "lib/d.rb"

- d2 = new_spec "d", "2", { "c" => "< 2" }, "lib/d.rb" # this

-

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

-

- a1.activate

-

- assert_equal %w(a-1), loaded_spec_names

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

-

- require "b"

-

- e = assert_raises Gem::LoadError do

- require "d"

- end

-

- assert_equal "unable to find a version of 'd' to activate", e.message

-

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

- assert_equal ["d (> 0)"], unresolved_names

- end

- end

-

- # TODO: move these to specification

- def test_self_activate_ambiguous_unrelated

- save_loaded_features do

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

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

- b2 = new_spec "b", "2", "c" => ">= 2"

- c1 = new_spec "c", "1"

- c2 = new_spec "c", "2"

- d1 = new_spec "d", "1", nil, "lib/d.rb"

-

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

-

- a1.activate

- assert_equal %w(a-1), loaded_spec_names

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

-

- require "d"

-

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

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

- end

- end

-

- # TODO: move these to specification

- def test_self_activate_ambiguous_indirect_conflict

- save_loaded_features do

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

- a2 = new_spec "a", "2", "b" => "> 0"

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

- b2 = new_spec "b", "2", "c" => ">= 2"

- c1 = new_spec "c", "1", nil, "lib/d.rb"

- c2 = new_spec("c", "2", { "a" => "1" }, "lib/d.rb") # conflicts with a-2

-

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

-

- a2.activate

- assert_equal %w(a-2), loaded_spec_names

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

-

- require "d"

-

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

- assert_equal [], unresolved_names

- end

- end

-

- # TODO: move these to specification

- 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

-

- a1.activate

- assert_equal %w(a-1), loaded_spec_names

- assert_equal [], unresolved_names

-

- assert require "d"

-

- assert_equal %w(a-1), loaded_spec_names

- assert_equal [], unresolved_names

- end

- end

-

- # TODO: move these to specification

- def test_require_already_activated_indirect_conflict

- save_loaded_features do

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

- a2 = new_spec "a", "2", "b" => "> 0"

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

- b2 = new_spec "b", "2", "c" => ">= 2"

- c1 = new_spec "c", "1", nil, "lib/d.rb"

- c2 = new_spec("c", "2", { "a" => "1" }, "lib/d.rb") # conflicts with a-2

-

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

-

- a1.activate

- c1.activate

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

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

-

- assert require "d"

-

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

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

- end

- end

-

- # TODO: move these to specification

- def test_self_activate_loaded

- foo = util_spec 'foo', '1'

-

- assert foo.activate

- refute foo.activate

- end

-

- ##

- # [A] depends on

- # [B] >= 1.0 (satisfied by 2.0)

- # [C] depends on nothing

-

- def test_self_activate_unrelated

- a = util_spec 'a', '1.0', 'b' => '>= 1.0'

- util_spec 'b', '1.0'

- c = util_spec 'c', '1.0'

-

- assert_activate %w[b-1.0 c-1.0 a-1.0], a, c, "b"

- end

-

- ##

- # [A] depends on

- # [B] >= 1.0 (satisfied by 2.0)

- # [C] = 1.0 depends on

- # [B] ~> 1.0

- #

- # and should resolve using b-1.0

- # TODO: move these to specification

-

- def test_self_activate_over

- a = util_spec 'a', '1.0', 'b' => '>= 1.0', 'c' => '= 1.0'

- util_spec 'b', '1.0'

- util_spec 'b', '1.1'

- util_spec 'b', '2.0'

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

-

- a.activate

-

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

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

- end

-

- ##

- # [A] depends on

- # [B] ~> 1.0 (satisfied by 1.1)

- # [C] = 1.0 depends on

- # [B] = 1.0

- #

- # and should resolve using b-1.0

- #

- # TODO: this is not under, but over... under would require depth

- # first resolve through a dependency that is later pruned.

-

- def test_self_activate_under

- a, _ = util_spec 'a', '1.0', 'b' => '~> 1.0', 'c' => '= 1.0'

- util_spec 'b', '1.0'

- util_spec 'b', '1.1'

- c, _ = util_spec 'c', '1.0', 'b' => '= 1.0'

-

- assert_activate %w[b-1.0 c-1.0 a-1.0], a, c, "b"

- end

-

- ##

- # [A1] depends on

- # [B] > 0 (satisfied by 2.0)

- # [B1] depends on

- # [C] > 0 (satisfied by 1.0)

- # [B2] depends on nothing!

- # [C1] depends on nothing

-

- def test_self_activate_dropped

- a1, = util_spec 'a', '1', 'b' => nil

- util_spec 'b', '1', 'c' => nil

- util_spec 'b', '2'

- util_spec 'c', '1'

-

- assert_activate %w[b-2 a-1], a1, "b"

- end

-

- ##

- # [A] depends on

- # [B] >= 1.0 (satisfied by 1.1) depends on

- # [Z]

- # [C] >= 1.0 depends on

- # [B] = 1.0

- #

- # and should backtrack to resolve using b-1.0, pruning Z from the

- # resolve.

-

- def test_self_activate_raggi_the_edgecase_generator

- a, _ = util_spec 'a', '1.0', 'b' => '>= 1.0', 'c' => '>= 1.0'

- util_spec 'b', '1.0'

- util_spec 'b', '1.1', 'z' => '>= 1.0'

- c, _ = util_spec 'c', '1.0', 'b' => '= 1.0'

-

- assert_activate %w[b-1.0 c-1.0 a-1.0], a, c, "b"

- end

-

- def test_self_activate_conflict

- util_spec 'b', '1.0'

- util_spec 'b', '2.0'

-

- gem "b", "= 1.0"

-

- assert_raises Gem::LoadError do

- gem "b", "= 2.0"

- end

- end

-

- ##

- # [A] depends on

- # [C] = 1.0 depends on

- # [B] = 2.0

- # [B] ~> 1.0 (satisfied by 1.0)

-

- def test_self_activate_checks_dependencies

- a, _ = util_spec 'a', '1.0'

- a.add_dependency 'c', '= 1.0'

- a.add_dependency 'b', '~> 1.0'

-

- util_spec 'b', '1.0'

- util_spec 'b', '2.0'

- c, _ = util_spec 'c', '1.0', 'b' => '= 2.0'

-

- e = assert_raises Gem::LoadError do

- assert_activate nil, a, c, "b"

- end

-

- expected = "can't satisfy 'b (~> 1.0)', already activated 'b-2.0'"

- assert_equal expected, e.message

- end

-

- ##

- # [A] depends on

- # [B] ~> 1.0 (satisfied by 1.0)

- # [C] = 1.0 depends on

- # [B] = 2.0

-

- def test_self_activate_divergent

- a, _ = util_spec 'a', '1.0', 'b' => '~> 1.0', 'c' => '= 1.0'

- util_spec 'b', '1.0'

- util_spec 'b', '2.0'

- c, _ = util_spec 'c', '1.0', 'b' => '= 2.0'

-

- e = assert_raises Gem::LoadError do

- assert_activate nil, a, c, "b"

- end

-

- assert_match(/Unable to activate c-1.0,/, e.message)

- assert_match(/because b-1.0 conflicts with b .= 2.0/, e.message)

- end

-

- ##

- # DOC

-

- def test_self_activate_platform_alternate

- @x1_m = util_spec 'x', '1' do |s|

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

- end

-

- @x1_o = util_spec 'x', '1' do |s|

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

- end

-

- @w1 = util_spec 'w', '1', 'x' => nil

-

- util_set_arch 'cpu-my_platform1'

-

- assert_activate %w[x-1-cpu-my_platform-1 w-1], @w1, @x1_m

- end

-

- ##

- # DOC

-

- def test_self_activate_platform_bump

- @y1 = util_spec 'y', '1'

-

- @y1_1_p = util_spec 'y', '1.1' do |s|

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

- end

-

- @z1 = util_spec 'z', '1', 'y' => nil

-

- assert_activate %w[y-1 z-1], @z1, @y1

- end

-

- ##

- # [C] depends on

- # [A] = 1.a

- # [B] = 1.0 depends on

- # [A] >= 0 (satisfied by 1.a)

-

- def test_self_activate_prerelease

- @c1_pre = util_spec 'c', '1.a', "a" => "1.a", "b" => "1"

- @a1_pre = util_spec 'a', '1.a'

- @b1 = util_spec 'b', '1' do |s|

- s.add_dependency 'a'

- s.add_development_dependency 'aa'

- end

-

- assert_activate %w[a-1.a b-1 c-1.a], @c1_pre, @a1_pre, @b1

- end

-

- ##

- # DOC

-

- def test_self_activate_old_required

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

- @d1 = util_spec 'd', '1'

- @d2 = util_spec 'd', '2'

-

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

- end

-

-

-unless defined? OpenSSL then

- warn "`gem cert` tests are being skipped, module OpenSSL not found"

- use_ui @ui do

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

- assert_empty @ui.error

- assert_equal "Private Key: #{File.join @tempdir, 'gem-private_key.pem'}",

- output.shift

-

- assert_equal "Don't forget to move the key file to somewhere private!",

- output.shift

- private_key_file = File.join @tempdir, 'gem-private_key.pem'

- assert_path_exists private_key_file

- assert_equal PRIVATE_KEY.to_pem, File.read(private_key_file)

-end if defined? OpenSSL

- expected = %W[

- #{Gem::ConfigMap[:bindir]}/default_command

- #{Gem::ConfigMap[:rubylibdir]}/default/gem.rb

- #{Gem::ConfigMap[:archdir]}/default_gem.so

- assert_equal '', @ui.error

- assert_equal '', err

- refute_match 'No command found for ', out

- path = File.join Gem.user_home, '.gem', 'specs', "not-there.nothing%80",

- "latest_specs.4.8"

- def test_execute_installs_dependencies

- r, r_gem = util_gem 'r', '1', 'q' => '= 1'

- q, q_gem = util_gem 'q', '1'

-

- util_setup_fake_fetcher

- util_setup_spec_fetcher r, q

-

- Gem::Specification.reset

-

- @fetcher.data["#{@gem_repo}gems/#{q.file_name}"] = read_binary(q_gem)

- @fetcher.data["#{@gem_repo}gems/#{r.file_name}"] = read_binary(r_gem)

-

- @cmd.options[:args] = ["r"]

-

- e = nil

- use_ui @ui do

- e = assert_raises Gem::SystemExitException do

- capture_io do

- @cmd.execute

- end

- end

- end

-

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

- assert_equal "2 gems installed", out.shift

- assert out.empty?, out.inspect

-

- assert_equal %w[q-1 r-1], @cmd.installed_specs.map { |spec| spec.full_name }

-

- assert_equal 0, e.exit_code

- end

-

- def test_execute_satisfy_deps_of_local_from_sources

- r, r_gem = util_gem 'r', '1', 'q' => '= 1'

- q, q_gem = util_gem 'q', '1'

-

- util_setup_fake_fetcher

- util_setup_spec_fetcher r, q

-

- Gem::Specification.reset

-

- @fetcher.data["#{@gem_repo}gems/#{q.file_name}"] = read_binary(q_gem)

-

- @cmd.options[:args] = [r_gem]

-

- use_ui @ui do

- e = assert_raises Gem::SystemExitException do

- capture_io do

- @cmd.execute

- end

- end

- assert_equal 0, e.exit_code

- end

-

- assert_equal %w[q-1 r-1], @cmd.installed_specs.map { |spec| spec.full_name }

-

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

- assert_equal "2 gems installed", out.shift

- assert out.empty?, out.inspect

- end

-

-

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

- assert_equal "Gems updated: #{@c2.name} #{@b2.name} #{@a2.name}",

- FileUtils.mv e1_gem, @tempdir

- Dir.chdir @tempdir do

- inst = Gem::DependencyInstaller.new

- inst.install 'e'

- end

-

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

- end

-

- def test_install_ignore_satified_deps

- util_setup_gems

-

- _, e1_gem = util_gem 'e', '1' do |s|

- s.add_dependency 'b'

- end

-

- util_clear_gems

-

- FileUtils.mv @a1_gem, @tempdir

- FileUtils.mv @b1_gem, @tempdir

- FileUtils.mv e1_gem, @tempdir

-

- Dir.chdir @tempdir do

- i = Gem::DependencyInstaller.new :ignore_dependencies => true

- i.install 'b'

- end

-

- inst = nil

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

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

- FileUtils.mv a2_gem, @tempdir # not in index

- inst.install 'a', Gem::Requirement.create("= 2")

- FileUtils.mv a2_gem, @tempdir # not in index

- FileUtils.mv a3_gem, @tempdir

-

- inst = nil

- inst = Gem::DependencyInstaller.new

- inst.install 'a', Gem::Requirement.create("= 2")

- e = assert_raises Gem::DependencyError do

- expected = "Unable to resolve dependencies: b requires a (>= 0)"

- local = gems.first

- remote = gems.last

- assert_equal exp, act

- assert_equal "unable to find any gem matching dependency 'a (>= 0)'", e.message

- assert_equal "detected 1 conflict with dependency 'c (>= 2)'", e.message

- def test_build_args_are_handled

- Gem.clear_paths

-

- cls = Class.new(Gem::Command) do

- def execute

- end

- end

- test_obj = cls.new :ba_test

- cmds = Gem::CommandManager.new

- cmds.register_command :ba_test, test_obj

- runner = Gem::GemRunner.new :command_manager => cmds

- runner.run(%W[ba_test -- --build_arg1 --build_arg2])

- assert_equal %w[--build_arg1 --build_arg2], test_obj.options[:build_args]

- -P HighSecurity

- def test_write_build_args

- def test_write_build_args_empty

- 'SHA1' => {

- 'metadata.gz' => metadata_sha1,

- 'data.tar.gz' => data_digests['SHA1'].hexdigest,

- },

- digest = OpenSSL::Digest::SHA1.new

- io.write tar_file_header('metadata.gz', "\000x", 0644, data.length)

- tar = tar_dir_header "foo", "bar", 0

- tar << tar_file_header("bar", "baz", 0, 0)

- str = tar_file_header("lib/foo", "", 010644, content.size) + content +

- "\0" * (512 - content.size)

- tar = tar_dir_header "foo", "bar", 0

- tar << tar_file_header("bar", "baz", 0, 0)

- tar = tar_dir_header "foo", "bar", 0

- tar << tar_file_header("bar", "baz", 0, 0)

- @tar << tar_file_header("lib/foo", "", 0, @contents.size)

- @tar_writer.add_file 'x', 0644 do |f| f.write 'a' * 10 end

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- digest_algorithms = OpenSSL::Digest::SHA1, OpenSSL::Digest::SHA512

- digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|

- io.write 'a' * 10

- end

- assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',

- digests['SHA1'].hexdigest

- assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \

- '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \

- '4993d6b40a4e4d8424196afc347e97640d68de61' \

- 'e1cf14b0',

- digests['SHA512'].hexdigest

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- digest_algorithms = [OpenSSL::Digest::SHA1, OpenSSL::Digest::SHA512]

- digests = @tar_writer.add_file_digest 'x', 0644, digest_algorithms do |io|

- io.write 'a' * 10

- end

- assert_equal '3495ff69d34671d1e15b33a63c1379fdedd3a32a',

- digests['SHA1'].hexdigest

- assert_equal '4714870aff6c97ca09d135834fdb58a6389a50c1' \

- '1fef8ec4afef466fb60a23ac6b7a9c92658f14df' \

- '4993d6b40a4e4d8424196afc347e97640d68de61' \

- 'e1cf14b0',

- digests['SHA512'].hexdigest

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- @io.string[0, 512])

- @tar_writer.add_file_signed 'x', 0644, signer do |io|

- io.write 'a' * 10

- end

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- @io.string[0, 512])

- assert_equal "aaaaaaaaaa#{"\0" * 502}", @io.string[512, 512]

- digest = signer.digest_algorithm.new

- digest.update 'a' * 10

- signature = signer.sign digest.digest

- assert_headers_equal(tar_file_header('x.sig', '', 0444, signature.length),

- @io.string[1024, 512])

- assert_equal "#{signature}#{"\0" * (512 - signature.length)}",

- @io.string[1536, 512]

- assert_equal 2048, @io.pos

- @tar_writer.add_file_signed 'x', 0644, signer do |io|

- io.write 'a' * 10

- end

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- digest = signer.digest_algorithm.new

- digest.update 'a' * 10

-

- @tar_writer.add_file_simple 'x', 0644, 10 do |io| io.write "a" * 10 end

- assert_headers_equal(tar_file_header('x', '', 0644, 10),

- @tar_writer.add_file_simple 'x', 0, 100

- assert_headers_equal tar_file_header('x', '', 0, 100),

- @tar_writer.mkdir 'foo', 0644

- assert_headers_equal tar_dir_header('foo', '', 0644),

- @io.string[0, 512]

- assert_equal 512, @io.pos

-require 'ostruct'

-require 'webrick/https'

- assert_equal proxy_uri, fetcher.instance_variable_get(:@proxy_uri).to_s

- end

-

- def test_self_fetcher_with_proxy_URI

- proxy_uri = URI.parse 'http://proxy.example.com'

- Gem.configuration[:http_proxy] = proxy_uri

- Gem::RemoteFetcher.fetcher = nil

-

- fetcher = Gem::RemoteFetcher.fetcher

- refute_nil fetcher

-

- assert_kind_of Gem::RemoteFetcher, fetcher

- assert_equal proxy_uri, fetcher.instance_variable_get(:@proxy_uri)

- def fetcher.connection_for(uri)

- def test_explicit_proxy

- use_ui @ui do

- fetcher = Gem::RemoteFetcher.new @proxy_uri

- assert_equal PROXY_DATA.size, fetcher.fetch_size(@server_uri)

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

- end

-

- def test_explicit_proxy_with_user_auth

- use_ui @ui do

- uri = URI.parse @proxy_uri

- uri.user, uri.password = 'foo', 'bar'

- fetcher = Gem::RemoteFetcher.new uri.to_s

- proxy = fetcher.instance_variable_get("@proxy_uri")

- assert_equal 'foo', proxy.user

- assert_equal 'bar', proxy.password

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

-

- use_ui @ui do

- uri = URI.parse @proxy_uri

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

- fetcher = Gem::RemoteFetcher.new uri.to_s

- proxy = fetcher.instance_variable_get("@proxy_uri")

- assert_equal 'domain\user', fetcher.unescape(proxy.user)

- assert_equal 'bar', proxy.password

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

-

- use_ui @ui do

- uri = URI.parse @proxy_uri

- uri.user, uri.password = 'user', 'my%20pass'

- fetcher = Gem::RemoteFetcher.new uri.to_s

- proxy = fetcher.instance_variable_get("@proxy_uri")

- assert_equal 'user', proxy.user

- assert_equal 'my pass', fetcher.unescape(proxy.password)

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

- end

-

- def test_explicit_proxy_with_user_auth_in_env

- use_ui @ui do

- ENV['http_proxy'] = @proxy_uri

- ENV['http_proxy_user'] = 'foo'

- ENV['http_proxy_pass'] = 'bar'

- fetcher = Gem::RemoteFetcher.new nil

- proxy = fetcher.instance_variable_get("@proxy_uri")

- assert_equal 'foo', proxy.user

- assert_equal 'bar', proxy.password

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

-

- use_ui @ui do

- ENV['http_proxy'] = @proxy_uri

- ENV['http_proxy_user'] = 'foo\user'

- ENV['http_proxy_pass'] = 'my bar'

- fetcher = Gem::RemoteFetcher.new nil

- proxy = fetcher.instance_variable_get("@proxy_uri")

- assert_equal 'foo\user', fetcher.unescape(proxy.user)

- assert_equal 'my bar', fetcher.unescape(proxy.password)

- assert_data_from_proxy fetcher.fetch_path(@server_uri)

- end

- end

-

- def test_get_proxy_from_env_auto_normalizes

- fetcher = Gem::RemoteFetcher.new(nil)

- ENV['HTTP_PROXY'] = 'fakeurl:12345'

-

- assert_equal('http://fakeurl:12345', fetcher.get_proxy_from_env.to_s)

- end

-

- def test_get_proxy_from_env_empty

- ENV['HTTP_PROXY'] = ''

- ENV.delete 'http_proxy'

-

- fetcher = Gem::RemoteFetcher.new nil

-

- assert_equal nil, fetcher.send(:get_proxy_from_env)

- end

-

- conn = Object.new

- def conn.started?() true end

- def conn.request(req)

- conn = { "#{Thread.current.object_id}:gems.example.com:80" => conn }

- fetcher.instance_variable_set :@connections, conn

-

- conn = Object.new

- def conn.started?() true end

- def conn.request(req)

- conn = { "#{Thread.current.object_id}:gems.example.com:80" => conn }

- fetcher.instance_variable_set :@connections, conn

-

- def test_normalize_uri

- assert_equal 'FILE://example/', @fetcher.normalize_uri('FILE://example/')

- assert_equal 'FTP://example/', @fetcher.normalize_uri('FTP://example/')

- assert_equal 'HTTP://example/', @fetcher.normalize_uri('HTTP://example/')

- assert_equal 'HTTPS://example/', @fetcher.normalize_uri('HTTPS://example/')

- assert_equal 'http://example/', @fetcher.normalize_uri('example/')

- end

-

- def test_request

- uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"

- util_stub_connection_for :body => :junk, :code => 200

-

- response = @fetcher.request uri, Net::HTTP::Get

-

- assert_equal 200, response.code

- assert_equal :junk, response.body

- end

-

- def test_request_head

- uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"

- util_stub_connection_for :body => '', :code => 200

- response = @fetcher.request uri, Net::HTTP::Head

-

- assert_equal 200, response.code

- assert_equal '', response.body

- end

-

- def test_request_unmodified

- uri = URI.parse "#{@gem_repo}/specs.#{Gem.marshal_version}"

- conn = util_stub_connection_for :body => '', :code => 304

-

- t = Time.now

- response = @fetcher.request uri, Net::HTTP::Head, t

-

- assert_equal 304, response.code

- assert_equal '', response.body

-

- assert_equal t.rfc2822, conn.payload['if-modified-since']

- end

-

- def test_user_agent

- ua = @fetcher.user_agent

-

- assert_match %r%^RubyGems/\S+ \S+ Ruby/\S+ \(.*?\)%, ua

- assert_match %r%RubyGems/#{Regexp.escape Gem::VERSION}%, ua

- assert_match %r% #{Regexp.escape Gem::Platform.local.to_s} %, ua

- assert_match %r%Ruby/#{Regexp.escape RUBY_VERSION}%, ua

- assert_match %r%\(#{Regexp.escape RUBY_RELEASE_DATE} %, ua

- end

-

- def test_user_agent_engine

- util_save_version

-

- Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)

- Object.send :const_set, :RUBY_ENGINE, 'vroom'

-

- ua = @fetcher.user_agent

-

- assert_match %r%\) vroom%, ua

- ensure

- util_restore_version

- end

-

- def test_user_agent_engine_ruby

- util_save_version

-

- Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)

- Object.send :const_set, :RUBY_ENGINE, 'ruby'

-

- ua = @fetcher.user_agent

-

- assert_match %r%\)%, ua

- ensure

- util_restore_version

- end

-

- def test_user_agent_level

- util_save_version

-

- Object.send :remove_const, :RUBY_LEVEL

- Object.send :const_set, :RUBY_LEVEL, 5

-

- ua = @fetcher.user_agent

-

- assert_match %r% level 5\)%, ua

- ensure

- util_restore_version

- end

-

- def test_user_agent_revision

- util_save_version

-

- Object.send :remove_const, :RUBY_LEVEL

- Object.send :const_set, :RUBY_LEVEL, -1

- Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)

- Object.send :const_set, :RUBY_REVISION, 6

-

- ua = @fetcher.user_agent

-

- assert_match %r% revision 6\)%, ua

- assert_match %r%Ruby/#{Regexp.escape RUBY_VERSION}dev%, ua

- ensure

- util_restore_version

- end

-

- def test_user_agent_revision_missing

- util_save_version

-

- Object.send :remove_const, :RUBY_LEVEL

- Object.send :const_set, :RUBY_LEVEL, -1

- Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)

-

- ua = @fetcher.user_agent

-

- assert_match %r%\(#{Regexp.escape RUBY_RELEASE_DATE}\)%, ua

- ensure

- util_restore_version

- end

-

- def util_stub_connection_for hash

- def @fetcher.connection= conn

- @conn = conn

- end

-

- def @fetcher.connection_for uri

- @conn

- end

-

- @fetcher.connection = Conn.new OpenStruct.new(hash)

- end

-

- class Conn

- attr_accessor :payload

-

- def initialize(response)

- @response = response

- self.payload = nil

- end

-

- def request(req)

- self.payload = req

- @response

- end

- end

-

- DH_PARAM = OpenSSL::PKey::DH.new(128)

- server.ssl_context.tmp_dh_callback = proc { DH_PARAM }

-

-

- def util_save_version

- @orig_RUBY_ENGINE = RUBY_ENGINE if defined? RUBY_ENGINE

- @orig_RUBY_LEVEL = RUBY_LEVEL

- @orig_RUBY_REVISION = RUBY_REVISION if defined? RUBY_REVISION

- end

-

- def util_restore_version

- Object.send :remove_const, :RUBY_ENGINE if defined?(RUBY_ENGINE)

- Object.send :const_set, :RUBY_ENGINE, @orig_RUBY_ENGINE if

- defined?(@orig_RUBY_ENGINE)

-

- Object.send :remove_const, :RUBY_LEVEL

- Object.send :const_set, :RUBY_LEVEL, @orig_RUBY_LEVEL

-

- Object.send :remove_const, :RUBY_REVISION if defined?(RUBY_REVISION)

- Object.send :const_set, :RUBY_REVISION, @orig_RUBY_REVISION if

- defined?(@orig_RUBY_REVISION)

- end

-

-end

-end

-end

-end

- root = File.join Gem.user_home, '.gem', 'specs'

- cache_dir = File.join Gem.user_home, '.gem', 'specs', 'gems.example.com%80'

- cache_dir = File.join Gem.user_home, '.gem', 'specs', 'gems.example.com%80'

- cache_dir = File.join Gem.user_home, '.gem', 'specs', 'gems.example.com%80'

-require 'rubygems/source_local'

- assert_equal(-1, (@sl <=> s))

- assert_equal 1, (s <=> @sl)

- assert_equal 0, (@sl <=> @sl)

-require 'rubygems/source_specific_file'

- def setup

- super

-

- @a1 = quick_spec 'a', '1' do |s|

- @a1.instance_variable_set :@loaded_from, nil

- @a1.instance_variable_set :@loaded_from, default_dir

- @a1.runtime_dependencies.each do |dep|

- assert_equal expected, @a1.runtime_dependencies.map { |d| d.name }

- s.require_paths = ["lib"]

- @a1.platform = Gem::Platform.local

- ruby_code = @a1.to_ruby

- assert_equal @a1, same_spec

- expected = { :version => Gem::Requirement.new('> 1'), :args => [] }