-module RbConfig

-

- ##

- # Return the path to the data directory associated with the given package

- # name. Normally this is just

- # "#{RbConfig::CONFIG['datadir']}/#{package_name}", but may be modified by

- # packages like RubyGems to handle versioned data directories.

-

- def self.datadir(package_name)

- File.join(CONFIG['datadir'], package_name)

- end unless RbConfig.respond_to?(:datadir)

-

-end

-require 'thread'

-require 'etc'

- RubyGemsVersion = VERSION = '1.3.7'

- attr_accessor :version_requirement

- end

- ##

- # Configuration settings from ::RbConfig

- ConfigMap = {} unless defined?(ConfigMap)

- require 'rbconfig'

- ConfigMap.merge!(

- :EXEEXT => RbConfig::CONFIG["EXEEXT"],

- :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"],

- :arch => RbConfig::CONFIG["arch"],

- :bindir => RbConfig::CONFIG["bindir"],

- :datadir => RbConfig::CONFIG["datadir"],

- :libdir => RbConfig::CONFIG["libdir"],

- :ruby_install_name => RbConfig::CONFIG["ruby_install_name"],

- :ruby_version => RbConfig::CONFIG["ruby_version"],

- :rubylibprefix => RbConfig::CONFIG["rubylibprefix"],

- :sitedir => RbConfig::CONFIG["sitedir"],

- :sitelibdir => RbConfig::CONFIG["sitelibdir"],

- :vendordir => RbConfig::CONFIG["vendordir"] ,

- :vendorlibdir => RbConfig::CONFIG["vendorlibdir"]

- )

- # :stopdoc:

- MUTEX = Mutex.new

-

- # +version_requirements+.

- def self.activate(gem, *version_requirements)

- if version_requirements.last.is_a?(Hash)

- options = version_requirements.pop

- if version_requirements.empty? then

- version_requirements = Gem::Requirement.default

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

- e.version_requirement = gem.requirement

- # bin directory must come before library directories

- spec.require_paths.unshift spec.bindir if spec.bindir

-

- # specified executable's path is returned. +version_requirements+ allows

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

- version_requirements = Gem::Requirement.default if

- version_requirements.empty?

- spec = Gem.source_index.find_name(name, version_requirements).last

- "can't find gem #{name} (#{version_requirements})" unless spec

- exec_name ||= spec.default_executable

- unless exec_name

- msg = "no default executable for #{spec.full_name}"

- raise Gem::Exception, msg

- unless spec.executables.include? exec_name

- msg = "can't find executable #{exec_name} for #{spec.full_name}"

- MUTEX.synchronize do

- @searcher = nil

- end

- set_home(ENV['GEM_HOME'] || Gem.configuration.home || default_dir) unless @gem_home

- # Returns a list of paths matching +file+ that can be used by a gem to pick

- # find_files search $LOAD_PATH for files as well as gems.

- def self.find_files(path)

- load_path_files = suffixes.map do |sfx|

- base = path + sfx

- $LOAD_PATH.map {|load_path|

- Dir[File.expand_path(base, load_path)]

- }

- end.flatten.select {|f| File.file?(f.untaint)}

- specs = searcher.find_all path

- specs_files = specs.map do |spec|

- searcher.matching_files spec, path

- end.flatten

- (load_path_files + specs_files).flatten.uniq

- "C:/"

- $LOAD_PATH.index { |p| p.instance_variable_defined? :@gem_prelude_index }

- def self.remove_prelude_paths

- # Gem::QuickLoader::GemLoadPaths.each do |path|

- # $LOAD_PATH.delete(path)

- # end

- paths = [ENV['GEM_PATH'] || Gem.configuration.path || default_path]

- MUTEX.synchronize do

- @searcher = nil

- end

- error.version_requirement = gem.requirement

- MUTEX.synchronize do

- @searcher ||= Gem::GemPathSearcher.new

- end

- ['', '.rb', ".#{RbConfig::CONFIG["DLEXT"]}"]

- end unless defined?(suffixes)

- # Find all 'rubygems_plugin' files and load them

-

- def self.load_plugins

- plugins = Gem.find_files 'rubygems_plugin'

- ##

- # Location of legacy YAML quick gemspecs on remote repositories

-

- YAML_SPEC_DIR = 'quick/'

-

- remove_method :gem if respond_to?(:gem, true) # defined in gem_prelude.rb on 1.9

- # +version_requirements+ is a list of version requirements that the

- def gem(gem_name, *version_requirements) # :doc:

- Gem.activate(gem_name, *version_requirements)

-require 'rubygems/version'

-require 'rubygems/requirement'

-require 'rubygems/dependency'

-require 'rubygems/gem_path_searcher' # Needed for Kernel#gem

-require 'rubygems/source_index' # Needed for Kernel#gem

-require 'rubygems/platform'

-require 'rubygems/builder' # HACK: Needed for rake's package task.

-begin

- ##

- # Defaults the operating system (or packager) wants to provide for RubyGems.

-

- require 'rubygems/defaults/operating_system'

-rescue LoadError

-end

-

-if defined?(RUBY_ENGINE) then

- # Defaults the ruby implementation wants to provide for RubyGems

- require "rubygems/defaults/#{RUBY_ENGINE}"

-end

-

-require 'rubygems/config_file'

-class << Gem

- remove_method :try_activate if Gem.respond_to?(:try_activate, true)

- def try_activate(path)

- spec = Gem.searcher.find(path)

- return false unless spec

-

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

- return true

-require 'rubygems/custom_require'

-Gem.clear_paths

-Gem.load_plugins

- require "yaml"

- require "rubygems/package"

- require "rubygems/security"

-

- pkg.metadata = @spec.to_yaml

- #

- def show_lookup_failure(gem_name, version, errors=nil)

-require 'timeout'

- register_command :mirror

- Gem::Security::OPT[:issuer_cert] = cert

- Gem::Security::OPT[:issuer_key] = key

- my_cert = Gem::Security::OPT[:issuer_cert]

- my_key = Gem::Security::OPT[:issuer_key]

- add_option('-v', '--verbose', "Spew more words") do |value, options|

- options[:verbose] = true

- end

-

- add_option('-t', '--test', "Run unit tests for gem") do |value, options|

- options[:test] = true

- end

-

- add_version_option 'run tests for'

- if options[:test]

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

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

- gem_spec = Gem::SourceIndex.from_installed_gems.search(dep).first

- Gem::Validator.new.unit_test(gem_spec)

- end

-

- say "#{key} is error-free" if options[:verbose]

- :force => false, :test => false, :install_dir => Gem.dir

- begin

- specs_and_sources = fetcher.find_matching(dependency, false, true,

- dependency.prerelease?)

-

- specs_and_sources.each do |spec_tuple, source_uri|

- spec = fetcher.fetch_spec spec_tuple, URI.parse(source_uri)

-

- source_indexes[source_uri].add_spec spec

- end

- rescue Gem::RemoteFetcher::FetchError => e

- raise unless fetcher.warn_legacy e do

- require 'rubygems/source_info_cache'

- specs = Gem::SourceInfoCache.search_with_source dependency, false

- specs.each do |spec, source_uri|

- source_indexes[source_uri].add_spec spec

- end

- end

- :bulk_threshold: Switch to a bulk update when this many sources are out of

- date (legacy setting)

- show_lookup_failure gem_name, version, errors

- 'Generate indexes for RubyGems older than',

- '1.2.0' do |value, options|

- quick/index

- quick/index.rz # quick index manifest

- quick/<gemname>.gemspec.rz # legacy YAML quick index

- # file

- yaml

- yaml.Z # legacy YAML full index

-The yaml indexes exist for legacy RubyGems clients and fallback in case of

-Marshal version changes.

-* Install 'rake' from remote server, and run unit tests,

- and generate RDocs:

-

- gem install --remote rake --test --rdoc --ri

-

- :test => false,

- "--no-test --install-dir #{Gem.dir}"

- show_lookup_failure e.name, e.version, e.errors

-

- if options[:test] then

- installed_gems.each do |spec|

- gem_spec = Gem::SourceIndex.from_installed_gems.find_name(spec.name, spec.version.version).first

- result = Gem::Validator.new.unit_test(gem_spec)

- if result and not result.passed?

- unless ask_yes_no("...keep Gem?", true)

- require 'rubygems/uninstaller'

- Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall

- end

- end

- end

- end

- spec = Gem::SourceIndex.load_specification spec_path(full_name)

-require 'yaml'

-require 'zlib'

-

-require 'rubygems/command'

-require 'open-uri'

-

-class Gem::Commands::MirrorCommand < Gem::Command

-

- def initialize

- super 'mirror', 'Mirror a gem repository'

- end

-

- def description # :nodoc:

- <<-EOF

-The mirror command uses the ~/.gemmirrorrc config file to mirror remote gem

-repositories to a local path. The config file is a YAML document that looks

-like this:

-

- ---

- - from: http://gems.example.com # source repository URI

- to: /path/to/mirror # destination directory

-

-Multiple sources and destinations may be specified.

- EOF

- end

-

- def execute

- config_file = File.join Gem.user_home, '.gemmirrorrc'

-

- raise "Config file #{config_file} not found" unless File.exist? config_file

-

- mirrors = YAML.load_file config_file

-

- raise "Invalid config file #{config_file}" unless mirrors.respond_to? :each

-

- mirrors.each do |mir|

- raise "mirror missing 'from' field" unless mir.has_key? 'from'

- raise "mirror missing 'to' field" unless mir.has_key? 'to'

-

- get_from = mir['from']

- save_to = File.expand_path mir['to']

-

- raise "Directory not found: #{save_to}" unless File.exist? save_to

- raise "Not a directory: #{save_to}" unless File.directory? save_to

-

- gems_dir = File.join save_to, "gems"

-

- if File.exist? gems_dir then

- raise "Not a directory: #{gems_dir}" unless File.directory? gems_dir

- else

- Dir.mkdir gems_dir

- end

-

- source_index_data = ''

-

- say "fetching: #{get_from}/Marshal.#{Gem.marshal_version}.Z"

-

- get_from = URI.parse get_from

-

- if get_from.scheme.nil? then

- get_from = get_from.to_s

- elsif get_from.scheme == 'file' then

- # check if specified URI contains a drive letter (file:/D:/Temp)

- get_from = get_from.to_s

- get_from = if get_from =~ /^file:.*[a-z]:/i then

- get_from[6..-1]

- else

- get_from[5..-1]

- end

- end

-

- open File.join(get_from.to_s, "Marshal.#{Gem.marshal_version}.Z"), "rb" do |y|

- source_index_data = Zlib::Inflate.inflate y.read

- open File.join(save_to, "Marshal.#{Gem.marshal_version}"), "wb" do |out|

- out.write source_index_data

- end

- end

-

- source_index = Marshal.load source_index_data

-

- progress = ui.progress_reporter source_index.size,

- "Fetching #{source_index.size} gems"

- source_index.each do |fullname, gem|

- gem_file = gem.file_name

- gem_dest = File.join gems_dir, gem_file

-

- unless File.exist? gem_dest then

- begin

- open "#{get_from}/gems/#{gem_file}", "rb" do |g|

- contents = g.read

- open gem_dest, "wb" do |out|

- out.write contents

- end

- end

- rescue

- old_gf = gem_file

- gem_file = gem_file.downcase

- retry if old_gf != gem_file

- alert_error $!

- end

- end

-

- progress.updated gem_file

- end

-

- progress.done

- end

- end

-

-end

-

-require 'fileutils'

- say "Pushing gem to RubyGems.org..."

- response = rubygems_api_request :post, "api/v1/gems" do |request|

- begin

- fetcher = Gem::SpecFetcher.fetcher

- spec_tuples = fetcher.find_matching dep, all, false, prerelease

-

- spec_tuples += fetcher.find_matching dep, false, false, true if

- prerelease and all

- rescue Gem::RemoteFetcher::FetchError => e

- if prerelease then

- raise Gem::OperationNotSupportedError,

- "Prereleases not supported on legacy repositories"

- end

-

- raise unless fetcher.warn_legacy e do

- require 'rubygems/source_info_cache'

-

- dep.name = '' if dep.name == //

- specs = Gem::SourceInfoCache.search_with_source dep, false, all

-

- spec_tuples = specs.map do |spec, source_uri|

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

- source_uri]

- end

- end

- end

-require 'fileutils'

-require 'rbconfig'

-require 'tmpdir'

-require 'fileutils'

- yaml_uri = uri + 'yaml'

- gem_repo = Gem::RemoteFetcher.fetcher.fetch_size yaml_uri rescue false

-

- if e.uri =~ /specs\.#{Regexp.escape Gem.marshal_version}\.gz$/ and

- gem_repo then

-

- alert_warning <<-EOF

-RubyGems 1.2+ index not found for:

-\t#{source_uri}

-

-Will cause RubyGems to revert to legacy indexes, degrading performance.

- EOF

-

- say "#{source_uri} added to sources"

- else

- say "Error fetching #{source_uri}:\n\t#{e.message}"

- end

- if fetcher.legacy_repos.empty? then

- Gem.sources.each do |update_uri|

- update_uri = URI.parse update_uri

- fetcher.load_specs update_uri, 'specs'

- fetcher.load_specs update_uri, 'latest_specs'

- end

- else

- Gem::SourceInfoCache.cache true

- Gem::SourceInfoCache.cache.flush

-require 'yaml'

-require 'fileutils'

- :force => false,

- :test => false

- "--rdoc --ri --no-force --no-test --install-dir #{Gem.dir}"

- if gems_to_update.include? "rubygems-update" then

- Gem.source_index.refresh!

-

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

-

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

-

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

- installed = do_rubygems_update latest_update_gem.version

-

- say "RubyGems system software updated" if installed

- if updated.empty? then

- say "Nothing to update"

- else

- say "Gems updated: #{updated.map { |spec| spec.name }.join ', '}"

-

- if options[:generate_ri] then

- updated.each do |gem|

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

- end

- Gem::DocManager.update_ri_cache

- if options[:generate_rdoc] then

- updated.each do |gem|

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

- end

- begin

- fetcher = Gem::SpecFetcher.fetcher

- spec_tuples = fetcher.find_matching dependency

- rescue Gem::RemoteFetcher::FetchError => e

- raise unless fetcher.warn_legacy e do

- require 'rubygems/source_info_cache'

-

- dependency.name = '' if dependency.name == //

-

- specs = Gem::SourceInfoCache.search_with_source dependency

-

- spec_tuples = specs.map do |spec, source_uri|

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

- end

- end

- end

- require 'etc.so'

- rescue LoadError

- '/etc'

- require 'yaml'

- require 'yaml'

- require 'yaml'

- if load_error.message.end_with?(path)

- if Gem.try_activate(path)

- return gem_original_require(path)

- end

-end unless Kernel.private_method_defined?(:gem_original_require)

- # :stopdoc:

- @warned_version_requirement = false

-

- def self.warned_version_requirement

- @warned_version_requirement

- end

-

- def self.warned_version_requirement= value

- @warned_version_requirement = value

- end

- # :startdoc:

-

- + "not #{@type.inspect}"

- def pretty_print(q) # :nodoc:

- ##

- # Rails subclasses Gem::Dependency and uses this method, so we'll hack

- # around it.

-

- alias __requirement requirement # :nodoc:

-

- def version_requirements # :nodoc:

- unless Gem::Dependency.warned_version_requirement then

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

- "Gem::Dependency#version_requirements is deprecated " \

- "and will be removed on or after August 2010. " \

- "Use #requirement"

-

- Gem::Dependency.warned_version_requirement = true

- end

-

- __requirement

- end

-

- alias version_requirement version_requirements # :nodoc:

-

- def version_requirements= requirements # :nodoc:

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

- "Gem::Dependency#version_requirements= is deprecated " \

- "and will be removed on or after August 2010. " \

- "Use Gem::Dependency.new."

-

- @requirement = Gem::Requirement.create requirements

- end

-

- [@name] <=> [other.name]

- other = Gem::Dependency.new other.name, other.version rescue return false

- pattern = name

-

- if Regexp === pattern then

- return false unless pattern =~ other.name

- else

- return false unless pattern == other.name

- end

- def match?(spec_name, spec_version)

- pattern = name

- if Regexp === pattern

- return false unless pattern =~ spec_name

- else

- return false unless pattern == spec_name

- end

- return true if requirement.none?

- requirement.satisfied_by? Gem::Version.new(spec_version)

- unless @ignore_dependencies then

- to_do = specs.dup

- seen = {}

- until to_do.empty? do

- spec = to_do.shift

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

- seen[spec.name] = true

- deps = spec.runtime_dependencies

- deps |= spec.development_dependencies if @development

- deps.each do |dep|

- results = find_gems_with_sources(dep).reverse

- results.reject! do |dep_spec,|

- to_do.push dep_spec

- @source_index.any? do |_, installed_spec|

- dep.name == installed_spec.name and

- dep.requirement.satisfied_by? installed_spec.version

- end

- end

- results.each do |dep_spec, source_uri|

- next if seen[dep_spec.name]

- @specs_and_sources << [dep_spec, source_uri]

- dependency_list.add dep_spec

-

- @gems_to_install = dependency_list.dependency_order.reverse

- result = 0

-

- specs.each do |spec|

- result += 1 unless ignored[spec.full_name]

- end

-

- result

-require 'fileutils'

- make_program = ENV['make']

- cmd = ENV['rake'] || "#{Gem.ruby} -rubygems #{Gem.bin_path('rake')}" rescue Gem.default_exec_format % 'rake'

-require 'fileutils'

-

- OpenSSL::Digest::SHA1

-

- Gem.ssl_available = true

- # Look in all the installed gems until a matching _path_ is found.

- def find(path)

- @gemspecs.find do |spec| matching_file? spec, path end

- # Works like #find, but finds all gemspecs matching +path+.

- def find_all(path)

- matching_file? spec, path

-require 'net/http'

- def rubygems_api_request(method, path, &block)

- host = ENV['RUBYGEMS_HOST'] || 'https://rubygems.org'

-require 'fileutils'

-require 'tmpdir'

-require 'zlib'

- progress = ui.progress_reporter index.size,

- "Generating YAML quick index gemspecs for #{index.size} gems",

- "Complete"

-

- Gem.time 'Generated YAML quick index gemspecs' do

- index.released_gems.each do |original_name, spec|

- spec_file_name = "#{original_name}.gemspec.rz"

- yaml_name = File.join @quick_dir, spec_file_name

-

- yaml_zipped = Gem.deflate spec.to_yaml

- open yaml_name, 'wb' do |io| io.write yaml_zipped end

-

- progress.updated original_name

- end

-

- progress.done

- end

-

- say "Generating quick index"

-

- Gem.time 'Generated quick index' do

- open @quick_index, 'wb' do |io|

- io.puts index.sort.map { |_, spec| spec.original_name }

- end

- end

-

- say "Generating latest index"

-

- Gem.time 'Generated latest index' do

- open @latest_index, 'wb' do |io|

- io.puts index.latest_specs.sort.map { |spec| spec.original_name }

- end

- end

-

- # Don't need prerelease legacy index

-

- progress = ui.progress_reporter index.size,

- "Generating YAML master index for #{index.size} gems (this may take a while)",

- "Complete"

-

- Gem.time 'Generated YAML master index' do

- open @master_index, 'wb' do |io|

- io.puts "--- !ruby/object:#{index.class}"

- io.puts "gems:"

-

- gems = index.sort_by { |name, gemspec| gemspec.sort_obj }

- gems.each do |original_name, gemspec|

- yaml = gemspec.to_yaml.gsub(/^/, ' ')

- yaml = yaml.sub(/\A ---/, '') # there's a needed extra ' ' here

- io.print " #{original_name}:"

- io.puts yaml

-

- progress.updated original_name

- end

- end

-

- progress.done

- end

-

- @files << @quick_dir

- @files << @master_index

- @files << "#{@master_index}.Z"

- compress @quick_index, 'rz'

- paranoid @quick_index, 'rz'

-

- compress @latest_index, 'rz'

- paranoid @latest_index, 'rz'

-

-

- compress @master_index, 'Z'

- paranoid @master_index, 'Z'

- add_option(:"Install/Update", '-t', '--[no-]test',

- 'Ignored; just for compatiblity') do |value, options|

- end

-

-require 'fileutils'

-require 'rbconfig'

-

- include Gem::RequirePathsBuilder

- write_require_paths_file_if_needed

- File.join @gem_dir, @spec.bindir, filename

- # HACK some gems don't have #! in their executables, restore 2008/06

- #if File.read(exec_path, 2) == '#!' then

- FileUtils.rm_f bin_script_path # prior install may have been --no-wrappers

-

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

- file.print app_script_text(filename)

- end

- say bin_script_path if Gem.configuration.really_verbose

- generate_windows_script filename, bindir

- #else

- # FileUtils.rm_f bin_script_path

- # FileUtils.cp exec_path, bin_script_path,

- # :verbose => Gem.configuration.really_verbose

- #end

- FileUtils.mkdir_p File.dirname(path)

- 'Use URL as the remote source for gems') do |source, options|

- if options[:added_source] then

- Gem.sources << source unless Gem.sources.include?(source)

- options[:added_source] = true

- Gem.sources.replace [source]

-require 'fileutils'

-require 'yaml'

-require 'zlib'

-require 'fileutils'

-require 'find'

-require 'stringio'

-require 'yaml'

-require 'zlib'

-

- when_writing "Creating #{gem_spec.file_name}" do

- Gem::Builder.new(gem_spec).build

- verbose trace do

- mv gem_file, gem_path

-

-

- when /^dotnet$/ then [ 'dotnet', nil ]

-require 'net/http'

-require 'stringio'

-require 'time'

-require 'uri'

- source_path = URI.unescape source_path

- URI.escape(str)

- URI.unescape(str)

- connection_id = net_http_args.join ':'

- response = connection.request request

- require_paths = spec.require_paths

- return if require_paths.size == 1 and require_paths.first == "lib"

- file_name = "#{gem_home}/gems/#{@spec.full_name}/.require_paths".untaint

- File.open(file_name, "wb") do |file|

- file.puts require_paths

-end

- "~>" => lambda { |v, r| v = v.release; v >= r && v < r.bump }

-require 'rubygems'

- #

- # default options for most of the methods below

- #

- },

-

- # save the key and cert to a file in build_self_signed_cert()?

- :save_key => true,

- :save_cert => true,

-

- # if you define either of these, then they'll be used instead of

- # the output_fmt macro below

- :save_key_path => nil,

- :save_cert_path => nil,

-

- # output name format for self-signed certs

- :output_fmt => 'gem-%s.pem',

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

-

- # output directory for trusted certificate checksums

- :trust_dir => File::join(Gem.user_home, '.gem', 'trust'),

-

- # default permissions for trust directory and certs

- :perms => {

- :trust_dir => 0700,

- :trusted_cert => 0600,

- :signing_cert => 0600,

- :signing_key => 0600,

- },

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- #

- # set up issuer information

- cert.sign(signing_key, opt[:dgst_algo].new)

- #

- #

- #

- #

- opt = OPT.merge(opt)

- # create new cert

- ret = OpenSSL::X509::Certificate.new

- # populate cert attributes

- ret.version = 2

- ret.serial = 0

- ret.public_key = key.public_key

- ret.not_before = Time.now

- ret.not_after = Time.now + opt[:cert_age]

- ret.subject = name

- # add certificate extensions

- ef = OpenSSL::X509::ExtensionFactory.new(nil, ret)

- ret.extensions = opt[:cert_exts].map { |k, v| ef.create_extension(k, v) }

- # sign cert

- i_key, i_cert = opt[:issuer_key] || key, opt[:issuer_cert] || ret

- ret = sign_cert(ret, i_key, i_cert, opt)

- # return cert

- ret

- #

- #

- # split email address up

- cn, dcs = email_addr.split('@')

- dcs = dcs.split('.')

-

- # munge email CN and DCs

- cn = cn.gsub(opt[:munge_re], '_')

- dcs = dcs.map { |dc| dc.gsub(opt[:munge_re], '_') }

-

- # create DN

- name = "CN=#{cn}/" << dcs.map { |dc| "DC=#{dc}" }.join('/')

- name = OpenSSL::X509::Name::parse(name)

- # build private key

- key = opt[:key_algo].new(opt[:key_size])

- # method name pretty much says it all :)

- verify_trust_dir(opt[:trust_dir], opt[:perms][:trust_dir])

- # if we're saving the key, then write it out

- if opt[:save_key]

- File.open(path[:key], 'wb') do |file|

- file.chmod(opt[:perms][:signing_key])

- file.write(key.to_pem)

- # build self-signed public cert from key

- cert = build_cert(name, key, opt)

- # if we're saving the cert, then write it out

- if opt[:save_cert]

- File.open(path[:cert], 'wb') do |file|

- file.chmod(opt[:perms][:signing_cert])

- file.write(cert.to_pem)

- # return key, cert, and paths (if applicable)

- #

- #

- #

- #

- attr_accessor :key, :cert_chain

- #

- #

-require 'yaml'

-# * "/yaml" - YAML dump of metadata for installed gems - deprecated

- options[:addresses]).run

- def initialize(gem_dirs, port, daemon, addresses = nil)

- when '/quick/index' then

- res.body << @source_index.map { |name,| name }.sort.join("\n")

- when '/quick/index.rz' then

- index = @source_index.map { |name,| name }.sort.join("\n")

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

- res.body << Gem.deflate(index)

- when '/quick/latest_index' then

- index = @source_index.latest_specs.map { |spec| spec.full_name }

- res.body << index.sort.join("\n")

- when '/quick/latest_index.rz' then

- index = @source_index.latest_specs.map { |spec| spec.full_name }

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

- res.body << Gem.deflate(index.sort.join("\n"))

- else # deprecated YAML format

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

- res.body << Gem.deflate(specs.first.to_yaml)

- @server.mount_proc "/yaml", method(:yaml)

- @server.mount_proc "/yaml.Z", method(:yaml)

-

- def yaml(req, res)

- @source_index.refresh!

- add_date res

- index = @source_index.to_yaml

- if req.path =~ /Z$/ then

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

- index = Gem.deflate index

- else

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

- end

-

- if req.request_method == 'HEAD' then

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

- return

- end

-

- res.body << index

-require 'rubygems/user_interaction'

-# :stopdoc:

-module Gem

- autoload :SpecFetcher, 'rubygems/spec_fetcher'

-end

-# :startdoc:

-

- include Gem::UserInteraction

-

- include Gem::UserInteraction

-

- return nil unless file_name and File.exist? file_name

-

- spec_code = if defined? Encoding then

- File.read file_name, :encoding => 'UTF-8'

- else

- File.read file_name

- end.untaint

-

- begin

- gemspec = eval spec_code, binding, file_name

-

- if gemspec.is_a?(Gem::Specification)

- gemspec.loaded_from = file_name

- return gemspec

- end

- alert_warning "File '#{file_name}' does not evaluate to a gem specification"

- rescue SignalException, SystemExit

- raise

- rescue SyntaxError => e

- alert_warning e

- alert_warning spec_code

- rescue Exception => e

- alert_warning "#{e.inspect}\n#{spec_code}"

- alert_warning "Invalid .gemspec format in '#{file_name}'"

- end

-

- return nil

- gemspec = self.class.load_specification spec_file.untaint

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

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

- version_requirement = nil

- version_requirement = platform_only || Gem::Requirement.default

- version_requirement = gem_pattern.requirement

- version_requirement = platform_only || Gem::Requirement.default

- unless Gem::Requirement === version_requirement then

- version_requirement = Gem::Requirement.create version_requirement

- version_requirement.satisfied_by? spec.version

- begin

- fetcher = Gem::SpecFetcher.fetcher

- remotes = fetcher.find_matching dependency

- remotes = remotes.map { |(_,version,_),_| version }

- rescue Gem::RemoteFetcher::FetchError => e

- raise unless fetcher.warn_legacy e do

- require 'rubygems/source_info_cache'

-

- specs = Gem::SourceInfoCache.search_with_source dependency, true

-

- remotes = specs.map { |spec,| spec.version }

- end

- end

- ##

- # Updates this SourceIndex from +source_uri+. If +all+ is false, only the

- # latest gems are fetched.

-

- def update(source_uri, all)

- source_uri = URI.parse source_uri unless URI::Generic === source_uri

- source_uri.path += '/' unless source_uri.path =~ /\/$/

-

- use_incremental = false

-

- begin

- gem_names = fetch_quick_index source_uri, all

- remove_extra gem_names

- missing_gems = find_missing gem_names

-

- return false if missing_gems.size.zero?

-

- say "Missing metadata for #{missing_gems.size} gems" if

- missing_gems.size > 0 and Gem.configuration.really_verbose

-

- use_incremental = missing_gems.size <= Gem.configuration.bulk_threshold

- rescue Gem::OperationNotSupportedError => ex

- alert_error "Falling back to bulk fetch: #{ex.message}" if

- Gem.configuration.really_verbose

- use_incremental = false

- end

-

- if use_incremental then

- update_with_missing(source_uri, missing_gems)

- else

- new_index = fetch_bulk_index(source_uri)

- @gems.replace(new_index.gems)

- end

-

- true

- end

-

- private

-

- def fetcher

- require 'rubygems/remote_fetcher'

-

- Gem::RemoteFetcher.fetcher

- end

-

- def fetch_index_from(source_uri)

- @fetch_error = nil

-

- indexes = %W[

- Marshal.#{Gem.marshal_version}.Z

- Marshal.#{Gem.marshal_version}

- yaml.Z

- yaml

- ]

-

- indexes.each do |name|

- spec_data = nil

- index = source_uri + name

- begin

- spec_data = fetcher.fetch_path index

- spec_data = unzip(spec_data) if name =~ /\.Z$/

-

- if name =~ /Marshal/ then

- return Marshal.load(spec_data)

- else

- return YAML.load(spec_data)

- end

- rescue => e

- if Gem.configuration.really_verbose then

- alert_error "Unable to fetch #{name}: #{e.message}"

- end

-

- @fetch_error = e

- end

- end

-

- nil

- end

-

- def fetch_bulk_index(source_uri)

- say "Bulk updating Gem source index for: #{source_uri}" if

- Gem.configuration.verbose

-

- index = fetch_index_from(source_uri)

- if index.nil? then

- raise Gem::RemoteSourceException,

- "Error fetching remote gem cache: #{@fetch_error}"

- end

- @fetch_error = nil

- index

- end

-

- ##

- # Get the quick index needed for incremental updates.

-

- def fetch_quick_index(source_uri, all)

- index = all ? 'index' : 'latest_index'

-

- zipped_index = fetcher.fetch_path source_uri + "quick/#{index}.rz"

-

- unzip(zipped_index).split("\n")

- rescue ::Exception => e

- unless all then

- say "Latest index not found, using quick index" if

- Gem.configuration.really_verbose

-

- fetch_quick_index source_uri, true

- else

- raise Gem::OperationNotSupportedError,

- "No quick index found: #{e.message}"

- end

- end

-

- ##

- # Make a list of full names for all the missing gemspecs.

-

- def find_missing(spec_names)

- unless defined? @originals then

- @originals = {}

- each do |full_name, spec|

- @originals[spec.original_name] = spec

- end

- end

-

- spec_names.find_all { |full_name|

- @originals[full_name].nil?

- }

- end

-

- def remove_extra(spec_names)

- dictionary = spec_names.inject({}) { |h, k| h[k] = true; h }

- each do |name, spec|

- remove_spec name unless dictionary.include? spec.original_name

- end

- end

-

- ##

- # Unzip the given string.

-

- def unzip(string)

- require 'zlib'

- Gem.inflate string

- end

-

- ##

- # Tries to fetch Marshal representation first, then YAML

-

- def fetch_single_spec(source_uri, spec_name)

- @fetch_error = nil

-

- begin

- marshal_uri = source_uri + "quick/Marshal.#{Gem.marshal_version}/#{spec_name}.gemspec.rz"

- zipped = fetcher.fetch_path marshal_uri

- return Marshal.load(unzip(zipped))

- rescue => ex

- @fetch_error = ex

-

- if Gem.configuration.really_verbose then

- say "unable to fetch marshal gemspec #{marshal_uri}: #{ex.class} - #{ex}"

- end

- end

-

- begin

- yaml_uri = source_uri + "quick/#{spec_name}.gemspec.rz"

- zipped = fetcher.fetch_path yaml_uri

- return YAML.load(unzip(zipped))

- rescue => ex

- @fetch_error = ex

- if Gem.configuration.really_verbose then

- say "unable to fetch YAML gemspec #{yaml_uri}: #{ex.class} - #{ex}"

- end

- end

-

- nil

- end

-

- ##

- # Update the cached source index with the missing names.

-

- def update_with_missing(source_uri, missing_names)

- progress = ui.progress_reporter(missing_names.size,

- "Updating metadata for #{missing_names.size} gems from #{source_uri}")

- missing_names.each do |spec_name|

- gemspec = fetch_single_spec(source_uri, spec_name)

- if gemspec.nil? then

- ui.say "Failed to download spec #{spec_name} from #{source_uri}:\n" \

- "\t#{@fetch_error.message}"

- else

- add_spec gemspec

- progress.updated spec_name

- end

- @fetch_error = nil

- end

- progress.done

- progress.count

- end

-

-require 'fileutils'

-

-require 'rubygems'

-require 'rubygems/source_info_cache_entry'

-require 'rubygems/user_interaction'

-

-##

-# SourceInfoCache stores a copy of the gem index for each gem source.

-#

-# There are two possible cache locations, the system cache and the user cache:

-# * The system cache is preferred if it is writable or can be created.

-# * The user cache is used otherwise

-#

-# Once a cache is selected, it will be used for all operations.

-# SourceInfoCache will not switch between cache files dynamically.

-#

-# Cache data is a Hash mapping a source URI to a SourceInfoCacheEntry.

-#

-#--

-# To keep things straight, this is how the cache objects all fit together:

-#

-# Gem::SourceInfoCache

-# @cache_data = {

-# source_uri => Gem::SourceInfoCacheEntry

-# @size = source index size

-# @source_index = Gem::SourceIndex

-# ...

-# }

-

-class Gem::SourceInfoCache

-

- include Gem::UserInteraction

-

- ##

- # The singleton Gem::SourceInfoCache. If +all+ is true, a full refresh will

- # be performed if the singleton instance is being initialized.

-

- def self.cache(all = false)

- return @cache if @cache

- @cache = new

- @cache.refresh all if Gem.configuration.update_sources

- @cache

- end

-

- def self.cache_data

- cache.cache_data

- end

-

- ##

- # The name of the system cache file.

-

- def self.latest_system_cache_file

- File.join File.dirname(system_cache_file),

- "latest_#{File.basename system_cache_file}"

- end

-

- ##

- # The name of the latest user cache file.

-

- def self.latest_user_cache_file

- File.join File.dirname(user_cache_file),

- "latest_#{File.basename user_cache_file}"

- end

-

- ##

- # Reset all singletons, discarding any changes.

-

- def self.reset

- @cache = nil

- @system_cache_file = nil

- @user_cache_file = nil

- end

-

- ##

- # Search all source indexes. See Gem::SourceInfoCache#search.

-

- def self.search(*args)

- cache.search(*args)

- end

-

- ##

- # Search all source indexes returning the source_uri. See

- # Gem::SourceInfoCache#search_with_source.

-

- def self.search_with_source(*args)

- cache.search_with_source(*args)

- end

-

- ##

- # The name of the system cache file. (class method)

-

- def self.system_cache_file

- @system_cache_file ||= Gem.default_system_source_cache_dir

- end

-

- ##

- # The name of the user cache file.

-

- def self.user_cache_file

- @user_cache_file ||=

- ENV['GEMCACHE'] || Gem.default_user_source_cache_dir

- end

-

- def initialize # :nodoc:

- @cache_data = nil

- @cache_file = nil

- @dirty = false

- @only_latest = true

- end

-

- ##

- # The most recent cache data.

-

- def cache_data

- return @cache_data if @cache_data

- cache_file # HACK writable check

-

- @only_latest = true

-

- @cache_data = read_cache_data latest_cache_file

-

- @cache_data

- end

-

- ##

- # The name of the cache file.

-

- def cache_file

- return @cache_file if @cache_file

- @cache_file = (try_file(system_cache_file) or

- try_file(user_cache_file) or

- raise "unable to locate a writable cache file")

- end

-

- ##

- # Write the cache to a local file (if it is dirty).

-

- def flush

- write_cache if @dirty

- @dirty = false

- end

-

- def latest_cache_data

- latest_cache_data = {}

-

- cache_data.each do |repo, sice|

- latest = sice.source_index.latest_specs

-

- new_si = Gem::SourceIndex.new

- new_si.add_specs(*latest)

-

- latest_sice = Gem::SourceInfoCacheEntry.new new_si, sice.size

- latest_cache_data[repo] = latest_sice

- end

-

- latest_cache_data

- end

-

- ##

- # The name of the latest cache file.

-

- def latest_cache_file

- File.join File.dirname(cache_file), "latest_#{File.basename cache_file}"

- end

-

- ##

- # The name of the latest system cache file.

-

- def latest_system_cache_file

- self.class.latest_system_cache_file

- end

-

- ##

- # The name of the latest user cache file.

-

- def latest_user_cache_file

- self.class.latest_user_cache_file

- end

-

- ##

- # Merges the complete cache file into this Gem::SourceInfoCache.

-

- def read_all_cache_data

- if @only_latest then

- @only_latest = false

- all_data = read_cache_data cache_file

-

- cache_data.update all_data do |source_uri, latest_sice, all_sice|

- all_sice.source_index.gems.update latest_sice.source_index.gems

-

- Gem::SourceInfoCacheEntry.new all_sice.source_index, latest_sice.size

- end

-

- begin

- refresh true

- rescue Gem::RemoteFetcher::FetchError

- end

- end

- end

-

- ##

- # Reads cached data from +file+.

-

- def read_cache_data(file)

- # Marshal loads 30-40% faster from a String, and 2MB on 20061116 is small

- data = open file, 'rb' do |fp| fp.read end

- cache_data = Marshal.load data

-

- cache_data.each do |url, sice|

- next unless sice.is_a?(Hash)

- update

-

- cache = sice['cache']

- size = sice['size']

-

- if cache.is_a?(Gem::SourceIndex) and size.is_a?(Numeric) then

- new_sice = Gem::SourceInfoCacheEntry.new cache, size

- cache_data[url] = new_sice

- else # irreperable, force refetch.

- reset_cache_for url, cache_data

- end

- end

-

- cache_data

- rescue Errno::ENOENT

- {}

- rescue => e

- if Gem.configuration.really_verbose then

- say "Exception during cache_data handling: #{e.class} - #{e}"

- say "Cache file was: #{file}"

- say "\t#{e.backtrace.join "\n\t"}"

- end

-

- {}

- end

-

- ##

- # Refreshes each source in the cache from its repository. If +all+ is

- # false, only latest gems are updated.

-

- def refresh(all)

- Gem.sources.each do |source_uri|

- cache_entry = cache_data[source_uri]

- if cache_entry.nil? then

- cache_entry = Gem::SourceInfoCacheEntry.new nil, 0

- cache_data[source_uri] = cache_entry

- end

-

- update if cache_entry.refresh source_uri, all

- end

-

- flush

- end

-

- def reset_cache_for(url, cache_data)

- say "Reseting cache for #{url}" if Gem.configuration.really_verbose

-

- sice = Gem::SourceInfoCacheEntry.new Gem::SourceIndex.new, 0

- sice.refresh url, false # HACK may be unnecessary, see ::cache and #refresh

-

- cache_data[url] = sice

- cache_data

- end

-

- def reset_cache_data

- @cache_data = nil

- @only_latest = true

- end

-

- ##

- # Force cache file to be reset, useful for integration testing of rubygems

-

- def reset_cache_file

- @cache_file = nil

- end

-

- ##

- # Searches all source indexes. See Gem::SourceIndex#search for details on

- # +pattern+ and +platform_only+. If +all+ is set to true, the full index

- # will be loaded before searching.

-

- def search(pattern, platform_only = false, all = false)

- read_all_cache_data if all

-

- cache_data.map do |source_uri, sic_entry|

- next unless Gem.sources.include? source_uri

- # TODO - Remove this gunk after 2008/11

- unless pattern.kind_of? Gem::Dependency then

- pattern = Gem::Dependency.new pattern, Gem::Requirement.default

- end

- sic_entry.source_index.search pattern, platform_only

- end.flatten.compact

- end

-

- ##

- # Searches all source indexes for +pattern+. If +only_platform+ is true,

- # only gems matching Gem.platforms will be selected. Returns an Array of

- # pairs containing the Gem::Specification found and the source_uri it was

- # found at.

-

- def search_with_source(pattern, only_platform = false, all = false)

- read_all_cache_data if all

-

- results = []

-

- cache_data.map do |source_uri, sic_entry|

- next unless Gem.sources.include? source_uri

-

- # TODO - Remove this gunk after 2008/11

- unless pattern.kind_of?(Gem::Dependency)

- pattern = Gem::Dependency.new(pattern, Gem::Requirement.default)

- end

-

- sic_entry.source_index.search(pattern, only_platform).each do |spec|

- results << [spec, source_uri]

- end

- end

-

- results

- end

-

- ##

- # Set the source info cache data directly. This is mainly used for unit

- # testing when we don't want to read a file system to grab the cached source

- # index information. The +hash+ should map a source URL into a

- # SourceInfoCacheEntry.

-

- def set_cache_data(hash)

- @cache_data = hash

- update

- end

-

- ##

- # The name of the system cache file.

-

- def system_cache_file

- self.class.system_cache_file

- end

-

- ##

- # Determine if +path+ is a candidate for a cache file. Returns +path+ if

- # it is, nil if not.

-

- def try_file(path)

- return path if File.writable? path

- return nil if File.exist? path

-

- dir = File.dirname path

-

- unless File.exist? dir then

- begin

- FileUtils.mkdir_p dir

- rescue RuntimeError, SystemCallError

- return nil

- end

- end

-

- return path if File.writable? dir

-

- nil

- end

-

- ##

- # Mark the cache as updated (i.e. dirty).

-

- def update

- @dirty = true

- end

-

- ##

- # The name of the user cache file.

-

- def user_cache_file

- self.class.user_cache_file

- end

-

- ##

- # Write data to the proper cache files.

-

- def write_cache

- if not File.exist?(cache_file) or not @only_latest then

- open cache_file, 'wb' do |io|

- io.write Marshal.dump(cache_data)

- end

- end

-

- open latest_cache_file, 'wb' do |io|

- io.write Marshal.dump(latest_cache_data)

- end

- end

-

- reset

-

-end

-

-require 'rubygems'

-require 'rubygems/source_index'

-require 'rubygems/remote_fetcher'

-

-##

-# Entries held by a SourceInfoCache.

-

-class Gem::SourceInfoCacheEntry

-

- ##

- # The source index for this cache entry.

-

- attr_reader :source_index

-

- ##

- # The size of the source entry. Used to determine if the source index has

- # changed.

-

- attr_reader :size

-

- ##

- # Create a cache entry.

-

- def initialize(si, size)

- @source_index = si || Gem::SourceIndex.new({})

- @size = size

- @all = false

- end

-

- def refresh(source_uri, all)

- begin

- marshal_uri = URI.join source_uri.to_s, "Marshal.#{Gem.marshal_version}"

- remote_size = Gem::RemoteFetcher.fetcher.fetch_size marshal_uri

- rescue Gem::RemoteSourceException

- yaml_uri = URI.join source_uri.to_s, 'yaml'

- remote_size = Gem::RemoteFetcher.fetcher.fetch_size yaml_uri

- end

-

- # TODO Use index_signature instead of size?

- return false if @size == remote_size and @all

-

- updated = @source_index.update source_uri, all

- @size = remote_size

- @all = all

-

- updated

- end

-

- def ==(other) # :nodoc:

- self.class === other and

- @size == other.size and

- @source_index == other.source_index

- end

-

-end

-

-require 'zlib'

-require 'fileutils'

-

- rescue Gem::RemoteFetcher::FetchError => e

- raise unless warn_legacy e do

- require 'rubygems/source_info_cache'

-

- return [Gem::SourceInfoCache.search_with_source(dependency,

- matching_platform, all), nil]

- end

- # Returns Array of gem repositories that were generated with RubyGems less

- # than 1.2.

- def legacy_repos

- Gem.sources.reject do |source_uri|

- source_uri = URI.parse source_uri

- spec_path = source_uri + "specs.#{Gem.marshal_version}.gz"

- begin

- @fetcher.fetch_size spec_path

- rescue Gem::RemoteFetcher::FetchError

- begin

- @fetcher.fetch_size(source_uri + 'yaml') # re-raise if non-repo

- rescue Gem::RemoteFetcher::FetchError

- alert_error "#{source_uri} does not appear to be a repository"

- raise

- end

- false

- end

- end

- list = {}

-

- file = { :latest => 'latest_specs',

- :prerelease => 'prerelease_specs',

- :all => 'specs' }[type]

-

- cache = { :latest => @latest_specs,

- :prerelease => @prerelease_specs,

- :all => @specs }[type]

- ##

- # Warn about legacy repositories if +exception+ indicates only legacy

- # repositories are available, and yield to the block. Returns false if the

- # exception indicates some other FetchError.

-

- def warn_legacy(exception)

- uri = exception.uri.to_s

- if uri =~ /specs\.#{Regexp.escape Gem.marshal_version}\.gz$/ then

- alert_warning <<-EOF

-RubyGems 1.2+ index not found for:

-\t#{legacy_repos.join "\n\t"}

-

-RubyGems will revert to legacy indexes degrading performance.

- EOF

-

- yield

-

- return true

- end

-

- false

- end

-

- # Loads ruby format gemspec from +filename+

- def self.load(filename)

- gemspec = nil

- raise "NESTED Specification.load calls not allowed!" if @@gather

- @@gather = proc { |gs| gemspec = gs }

- data = File.read filename

- eval data, nil, filename

- gemspec

- ensure

- @@gather = nil

- n = self.send(name).hash

- hash_code + n

- result << " current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION"

- %w[author description email homepage rubyforge_project summary].each do |attribute|

- ##

- # Ask for a password. Does not echo response to terminal.

- def ask_for_password(question)

- return nil if not @ins.tty?

- require 'io/console'

- @outs.print(question + " ")

- @outs.flush

- password = @ins.noecho {@ins.gets}

- password.chomp! if password

- password

-require 'find'

-

-require 'digest'

-begin

- gem 'test-unit'

-rescue Gem::LoadError

- # Ignore - use the test-unit library that's part of the standard library

-end

-

-=begin

- if RUBY_VERSION < '1.9' then

- class TestRunner

- def initialize(suite, ui)

- @suite = suite

- @ui = ui

- end

-

- def self.run(suite, ui)

- require 'test/unit/ui/testrunnermediator'

- return new(suite, ui).start

- end

-

- def start

- @mediator = Test::Unit::UI::TestRunnerMediator.new(@suite)

- @mediator.add_listener(Test::Unit::TestResult::FAULT, &method(:add_fault))

- return @mediator.run_suite

- end

-

- def add_fault(fault)

- if Gem.configuration.verbose then

- @ui.say fault.long_display

- end

- end

- end

-

- autoload :TestRunner, 'test/unit/ui/testrunnerutilities'

- end

-=end

-

- ##

- # Runs unit tests for a given gem specification

-

- def unit_test(gem_spec)

- start_dir = Dir.pwd

- Dir.chdir(gem_spec.full_gem_path)

- $: << gem_spec.full_gem_path

- # XXX: why do we need this gem_spec when we've already got 'spec'?

- test_files = gem_spec.test_files

-

- if test_files.empty? then

- say "There are no unit tests to run for #{gem_spec.full_name}"

- return nil

- end

-

- gem gem_spec.name, "= #{gem_spec.version.version}"

-

- test_files.each do |f| require f end

-

-=begin

- if RUBY_VERSION < '1.9' then

- suite = Test::Unit::TestSuite.new("#{gem_spec.name}-#{gem_spec.version}")

-

- ObjectSpace.each_object(Class) do |klass|

- suite << klass.suite if (klass < Test::Unit::TestCase)

- end

-

- result = TestRunner.run suite, ui

-

- alert_error result.to_s unless result.passed?

- else

- result = MiniTest::Unit.new

- result.run

- end

-=end

- result = MiniTest::Unit.new

- result.run

-

- result

- ensure

- Dir.chdir(start_dir)

- end

-

-# part in the Nth part sort less than versions with N-1 parts. Prerelease

-# parts are sorted alphabetically using the normal Ruby string sorting

-# rules.

-# 2. 1.0.b

-# 3. 1.0.a

-

- segments # prime @segments

- # (alpha) parts, e.g, 5.3.1.b2 => 5.4, are ignored.

- self.class === other and segments == other.segments

- @prerelease ||= segments.any? { |s| String === s }

- # @segments is lazy so it can pick up @version values that come

- # from old marshaled versions, which don't go through

- # marshal_load. +segments+ is called in +initialize+ to "prime

- # the pump" in normal cases.

- @segments ||= @version.scan(/[0-9a-z]+/i).map do |s|

- # Compares this version with +other+ returning -1, 0, or 1 if the other

- # version is larger, the same, or smaller than this one.

- return 1 unless other # HACK: comparable with nil? why?

- return nil unless self.class === other

- lhsize = segments.size

- rhsize = other.segments.size

- 0.upto(limit) do |i|

- lhs, rhs = segments[i] || 0, other.segments[i] || 0

- return -1 if String === lhs && Numeric === rhs

- return 1 if Numeric === lhs && String === rhs

- return lhs <=> rhs if lhs != rhs