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

- "can't activate #{gem}, already activated #{existing_spec.full_name}]"

- spec.dependencies.each do |dep_gem|

- paths = [ENV['GEM_PATH']] || [default_path]

-

-

-

-end

-# Modify the non-gem version of datadir to handle gem package names.

-require 'rbconfig/datadir'

-module Config # :nodoc:

- alias gem_original_datadir datadir

-

- Gem.datadir(package_name) || Config.gem_original_datadir(package_name)

- source_indexes = []

- if local? then

- source_indexes << Gem::SourceIndex.from_installed_gems

- if remote? then

- Gem::SourceInfoCache.cache_data.map do |_, sice|

- source_indexes << sice.source_index

- options[:args].each do |name|

- new_specs = nil

- source_indexes.each do |source_index|

- new_specs = find_gems(name, source_index)

- say "No match found for #{name} (#{options[:version]})" if

- new_specs.empty?

- specs = specs.merge new_specs

- terminate_interaction 1 if specs.empty?

- specs.values.each do |source_index, spec|

- reverse[spec.full_name] = find_reverse_dependencies spec, source_index

- def find_reverse_dependencies(spec, source_index)

- source_index.each do |name, sp|

- specs_and_sources = Gem::SourceInfoCache.search_with_source dep, true

- :install_dir => Gem.dir,

- :bin_dir => options[:bin_dir]

-module Gem

- module Commands

- class ListCommand < QueryCommand

-

- def initialize

- super 'list', 'Display gems whose name starts with STRING'

-

- remove_option('--name-matches')

- end

-

- def arguments # :nodoc:

- "STRING start of gem name to look for"

- end

-

- def defaults_str # :nodoc:

- "--local --no-details"

- end

-

- def usage # :nodoc:

- "#{program_name} [STRING]"

- end

-

- def execute

- string = get_one_optional_argument || ''

- options[:name] = /^#{string}/i

- super

- end

- end

- spec.dependencies.each do |dep|

-require 'rubygems/source_info_cache'

- remotes = Gem::SourceInfoCache.search_with_source(/^#{name}$/, true)

- installer = Gem::Installer.new gem, :wrappers => true

- gem_file = File.join install_dir, "cache", "#{spec.full_name}.gem"

-

- security_policy = nil # TODO use installer option

-

- format = Gem::Format.from_file_by_path gem_file, security_policy

-

- target_directory = File.join(install_dir, "gems", format.spec.full_name)

- target_directory.untaint

-

- pristine_files = format.file_entries.collect { |data| data[0]["path"] }

- file_map = {}

-

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

- file_map[entry["path"]] = file_data

- end

-

- Dir.chdir target_directory do

- deployed_files = Dir.glob(File.join("**", "*")) +

- Dir.glob(File.join("**", ".*"))

-

- pristine_files = pristine_files.map { |f| File.expand_path f }

- deployed_files = deployed_files.map { |f| File.expand_path f }

-

- to_redeploy = (pristine_files - deployed_files)

- to_redeploy = to_redeploy.map { |path| path.untaint}

-

- if to_redeploy.length > 0 then

- say "Restoring #{to_redeploy.length} file#{to_redeploy.length == 1 ? "" : "s"} to #{spec.full_name}..."

-

- to_redeploy.each do |path|

- say " #{path}"

- FileUtils.mkdir_p File.dirname(path)

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

- out.write file_map[path]

- end

- end

- else

- say "#{spec.full_name} is in pristine condition"

- end

- end

-

- installer.generate_bin

- installer.build_extensions

-require 'rubygems/source_info_cache'

- output_query_results Gem.source_index.search(name)

- Gem::SourceInfoCache.cache all

- rescue Gem::RemoteFetcher::FetchError

- # no network

- output_query_results Gem::SourceInfoCache.search(name, false, all)

- def output_query_results(gemspecs)

- gem_list_with_version = {}

- gemspecs.flatten.each do |gemspec|

- gem_list_with_version[gemspec.name] ||= []

- gem_list_with_version[gemspec.name] << gemspec

- gem_list_with_version = gem_list_with_version.sort_by do |name, spec|

- gem_list_with_version.each do |gem_name, list_of_matching|

- list_of_matching = list_of_matching.sort_by { |x| x.version.to_ints }.reverse

- seen_versions = {}

- list_of_matching.delete_if do |item|

- if seen_versions[item.version] then

- seen_versions[item.version] = true

- versions = list_of_matching.map { |s| s.version }.uniq

- entry << "\n" << format_text(list_of_matching[0].summary, 68, 4) if

- options[:details]

-require 'rubygems/source_info_cache_entry'

- add_option '-u', '--update', 'Update source cache' do |value, options|

- options[:update] = value

- end

-

- options[:list] = !(options[:add] || options[:remove] || options[:clear_all] || options[:update])

- sice = Gem::SourceInfoCacheEntry.new nil, nil

- sice.refresh source_uri, true

-

- Gem::SourceInfoCache.cache_data[source_uri] = sice

- Gem::SourceInfoCache.cache.update

- Gem::SourceInfoCache.cache.flush

-

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

- end

- end

- if options[:update] then

- Gem::SourceInfoCache.cache true

- Gem::SourceInfoCache.cache.flush

- say "source cache successfully updated"

- begin # HACK figure out how to get the cache w/o update

- Gem::SourceInfoCache.cache

- rescue Gem::RemoteFetcher::FetchError

- end

-

- Gem::SourceInfoCache.cache_data.delete source_uri

- Gem::SourceInfoCache.cache.update

- Gem::SourceInfoCache.cache.flush

- Gem::SourceInfoCache.cache_data.each do |_,sice|

- specs.push(*sice.source_index.search(gem, options[:version]))

- end

-require 'rubygems/source_info_cache'

- :generate_rdoc => true,

- :generate_ri => true,

- :force => false,

- :test => false,

- :install_dir => Gem.dir

- Gem::SourceIndex.from_installed_gems.each do |name, spec|

- pattern = if options[:args].empty? then

- //

- else

- Regexp.union(*options[:args])

- end

-

- remote_gemspecs = Gem::SourceInfoCache.search pattern

-

- gems_to_update = which_to_update hig, remote_gemspecs

- def which_to_update(highest_installed_gems, remote_gemspecs)

- matching_gems = remote_gemspecs.select do |spec|

- spec.name == l_name and Gem.platforms.any? do |platform|

- platform == spec.platform

- highest_remote_gem = matching_gems.sort_by { |spec| spec.version }.last

- l_spec.version < highest_remote_gem.version then

- begin

- # HACK $SAFE ok?

- @hash = open(config_file_name.dup.untaint) {|f| YAML.load(f) }

- rescue ArgumentError

- warn "Failed to load #{config_file_name}"

- rescue Errno::ENOENT

- # Ignore missing config file error.

- rescue Errno::EACCES

- warn "Failed to load #{config_file_name} due to permissions problem."

- end

-

- @hash ||= {}

- if load_error.message =~ /\A[Nn]o such file to load -- #{Regexp.escape path}\z/ and

- %w[http://gems.rubyforge.org]

- # Constructs the dependency

- #

- # name:: [String] name of the Gem

- # version_requirements:: [String Array] version requirement (e.g. ["> 1.2"])

- #

- def initialize(name, version_requirements)

- "#{name} (#{version_requirements})"

- def hash

- name.hash + version_requirements.hash

-require 'rubygems/source_info_cache'

- # :env_shebang:: See Gem::Installer::new.

- # :ignore_dependencies: Don't install any dependencies.

- # :install_dir: See Gem::Installer#install.

- # :security_policy: See Gem::Installer::new and Gem::Security.

- # :wrappers: See Gem::Installer::new

- @env_shebang = options[:env_shebang]

- @install_dir = options[:install_dir] || Gem.dir

- @bin_dir = options[:bin_dir]

- # sources. Gems are sorted with newer gems preferred over older gems, and

- found = Gem::SourceInfoCache.search_with_source dep, true, all

-

- spec.dependencies.each do |dep|

- results = find_gems_with_sources(dep).reverse # local gems first

- "could not find #{gem_name} locally or in a repository"

- # Installs the gem and all its dependencies.

- gather_dependencies

- spec_dir = File.join @install_dir, 'specifications'

- source_index = Gem::SourceIndex.from_gems_in spec_dir

- next if source_index.any? { |n,_| n == spec.full_name } and not last

- @install_dir

- :bin_dir => @bin_dir

- spec.dependencies.all? do |dep|

-

-

-

-

- args.flatten!

- @master_index = Gem::Indexer::MasterIndexBuilder.new "yaml", @directory

- @marshal_index = Gem::Indexer::MarshalIndexBuilder.new marshal_name, @directory

- @quick_index = Gem::Indexer::QuickIndexBuilder.new 'index', @directory

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

- @latest_index = Gem::Indexer::LatestIndexBuilder.new 'latest_index', quick_dir

- # Build the index.

-

- def build_index

- @master_index.build do

- @quick_index.build do

- @marshal_index.build do

- @latest_index.build do

- progress = ui.progress_reporter gem_file_list.size,

- "Generating index for #{gem_file_list.size} gems in #{@dest_directory}",

- "Loaded all gems"

-

- gem_file_list.each do |gemfile|

- if File.size(gemfile.to_s) == 0 then

- alert_warning "Skipping zero-length gem: #{gemfile}"

- next

- end

-

- begin

- spec = Gem::Format.from_file_by_path(gemfile).spec

-

- unless gemfile =~ /\/#{Regexp.escape spec.original_name}.*\.gem\z/i then

- alert_warning "Skipping misnamed gem: #{gemfile} => #{spec.full_name} (#{spec.original_name})"

- next

- end

-

- abbreviate spec

- sanitize spec

-

- @master_index.add spec

- @quick_index.add spec

- @marshal_index.add spec

- @latest_index.add spec

-

- progress.updated spec.original_name

-

- rescue SignalException => e

- alert_error "Received signal, exiting"

- raise

- rescue Exception => e

- alert_error "Unable to process #{gemfile}\n#{e.message} (#{e.class})\n\t#{e.backtrace.join "\n\t"}"

- end

- end

-

- progress.done

-

- say "Generating master indexes (this may take a while)"

- end

- def install_index

- verbose = Gem.configuration.really_verbose

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

- files = @master_index.files + @quick_index.files + @marshal_index.files +

- @latest_index.files

- files.each do |file|

- src_name = File.join @directory, file

- dst_name = File.join @dest_directory, file

- FileUtils.rm_rf dst_name, :verbose => verbose

- FileUtils.mv src_name, @dest_directory, :verbose => verbose

- build_index

- install_index

- # List of gem file names to index.

- def gem_file_list

- Dir.glob(File.join(@dest_directory, "gems", "*.gem"))

- # Abbreviate the spec for downloading. Abbreviated specs are only

- # used for searching, downloading and related activities and do not

- # need deployment specific information (e.g. list of files). So we

- # abbreviate the spec, making it much smaller for quicker downloads.

- def abbreviate(spec)

- spec.files = []

- spec.test_files = []

- spec.rdoc_options = []

- spec.extra_rdoc_files = []

- spec.cert_chain = []

- spec

-require 'rubygems/indexer/abstract_index_builder'

-require 'rubygems/indexer/master_index_builder'

-require 'rubygems/indexer/quick_index_builder'

-require 'rubygems/indexer/marshal_index_builder'

-require 'rubygems/indexer/latest_index_builder'

-

- @spec.dependencies.each do |dep_gem|

- # True if the current installed gems satisfy the given dependency.

- #

- # dependency :: Gem::Dependency

- current_index = Gem::SourceIndex.from_installed_gems

- current_index.find_name(dependency.name, dependency.version_requirements).size > 0

- #

- #

- #

- bindir = @bin_dir ? @bin_dir : (Gem.bindir @gem_home)

- #

- #

- value = URI.parse value

- raise OptionParser::InvalidArgument, value unless value.scheme == 'http'

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

- Gem.sources << value

- Gem.sources.replace [value]

-#

- class FetchError < Gem::Exception; end

- local_gem_path = File.join install_dir, 'cache', gem_file_name

- Gem.ensure_gem_subdirectories install_dir

- # Downloads +uri+.

- raise FetchError, "timed out fetching #{uri}"

- raise FetchError, "#{e.class}: #{e} reading #{uri}"

- message = "#{e.class}: #{e} reading #{uri}"

- raise FetchError, message

- http = connect_to uri.host, uri.port

-

- request = Net::HTTP::Head.new uri.request_uri

-

- request.basic_auth unescape(uri.user), unescape(uri.password) unless

- uri.user.nil? or uri.user.empty?

- resp = http.request request

-

- if resp.code !~ /^2/ then

- raise Gem::RemoteSourceException,

- "HTTP Response #{resp.code} fetching #{uri}"

- if resp['content-length'] then

- return resp['content-length'].to_i

- resp = http.get uri.request_uri

- return resp.body.size

- raise Gem::RemoteFetcher::FetchError,

- "#{e.message} (#{e.class})\n\tgetting size of #{uri}"

- # Connect to the source host/port, using a proxy if needed.

- def connect_to(host, port)

- if @proxy_uri

- Net::HTTP::Proxy(@proxy_uri.host, @proxy_uri.port, unescape(@proxy_uri.user), unescape(@proxy_uri.password)).new(host, port)

- else

- Net::HTTP.new(host, port)

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

-

- if @proxy_uri then

- net_http_args += [ @proxy_uri.host,

- @proxy_uri.port,

- @proxy_uri.user,

- @proxy_uri.password

- ]

- end

-

- connection_id = net_http_args.join ':'

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

- connection = @connections[connection_id]

- if uri.scheme == 'https' && ! connection.started?

- http_obj.use_ssl = true

- http_obj.verify_mode = OpenSSL::SSL::VERIFY_NONE

- end

-

- connection.start unless connection.started?

-

- request = Net::HTTP::Get.new(uri.request_uri)

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

- request.basic_auth(uri.user, uri.password)

- end

-

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

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

- ua << " level #{RUBY_LEVEL}" if defined? RUBY_LEVEL

- ua << ")"

-

- request.add_field 'User-Agent', ua

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

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

-

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

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

- # to install gems.

- retried = false

- begin

- @requests[connection_id] += 1

- response = connection.request(request)

- rescue EOFError, Errno::ECONNABORTED

- requests = @requests[connection_id]

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

- Gem.configuration.really_verbose

-

- raise Gem::RemoteFetcher::FetchError, 'too many connection resets' if

- retried

-

- @requests[connection_id] = 0

-

- connection.finish

- connection.start

- retried = true

- retry

- end

- raise Gem::RemoteFetcher::FetchError, "too many redirects" if depth > 10

- raise Gem::RemoteFetcher::FetchError,

- "bad response #{response.message} #{response.code}"

- #

- def marshal_dump

- def marshal_load(array)

- # Is the requirement satisfied by +version+.

- #

- # version:: [Gem::Version] the version to compare against

- # return:: [Boolean] true if this requirement is satisfied by

- # the version, otherwise false

- #

- # Is "version op required_version" satisfied?

- #

- def <=>(other)

- RubyGemsVersion = '1.1.1'

-# * "/Marshal" - Full SourceIndex dump of metadata for installed gems

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

-# gem server [-p portnum] [-d gem_path]

-# port_num:: The TCP port the HTTP server will bind to

-# gem_path::

-# Root gem directory containing both "cache" and "specifications"

-# subdirectories.

- <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />

- def initialize(gemdir, port, daemon)

- @gemdir = gemdir

- @spec_dir = File.join @gemdir, "specifications"

- case req.request_uri.request_uri

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

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

- res.body << Zlib::Deflate.deflate(index)

- elsif $1 then # marshal quickindex instead of YAML

- res.body << Zlib::Deflate.deflate(Marshal.dump(specs.first))

- res.body << Zlib::Deflate.deflate(specs.first.to_yaml)

- res.status = 404

- res.body = "#{req.request_uri} not found"

- @server.mount_proc("/yaml") do |req, res|

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

- res['date'] = File.stat(@spec_dir).mtime

- if req.request_method == 'HEAD' then

- res['content-length'] = @source_index.to_yaml.length

- else

- res.body << @source_index.to_yaml

- end

- end

- @server.mount_proc("/Marshal") do |req, res|

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

- res['date'] = File.stat(@spec_dir).mtime

- if req.request_method == 'HEAD' then

- res['content-length'] = Marshal.dump(@source_index).length

- else

- res.body << Marshal.dump(@source_index)

- end

- end

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

- @server.mount_proc("/") do |req, res|

- specs = []

- total_file_count = 0

-

- @source_index.each do |path, spec|

- total_file_count += spec.files.size

- deps = spec.dependencies.collect { |dep|

- { "name" => dep.name,

- "version" => dep.version_requirements.to_s, }

- }

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

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

-

- # executables

- executables = spec.executables.sort.collect { |exec| {"executable" => exec} }

- executables = nil if executables.empty?

- executables.last["is_last"] = true if executables

-

- specs << {

- "authors" => spec.authors.sort.join(", "),

- "date" => spec.date.to_s,

- "dependencies" => deps,

- "doc_path" => ('/doc_root/' + spec.full_name + '/rdoc/index.html'),

- "executables" => executables,

- "only_one_executable" => (executables && executables.size==1),

- "full_name" => spec.full_name,

- "has_deps" => !deps.empty?,

- "homepage" => spec.homepage,

- "name" => spec.name,

- "rdoc_installed" => Gem::DocManager.new(spec).rdoc_installed?,

- "summary" => spec.summary,

- "version" => spec.version.to_s,

- }

- end

-

- specs << {

- "authors" => "Chad Fowler, Rich Kilmer, Jim Weirich, Eric Hodel and others",

- "dependencies" => [],

- "doc_path" => "/doc_root/rubygems-#{Gem::RubyGemsVersion}/rdoc/index.html",

- "executables" => [{"executable" => 'gem', "is_last" => true}],

- "only_one_executable" => true,

- "full_name" => "rubygems-#{Gem::RubyGemsVersion}",

- "has_deps" => false,

- "homepage" => "http://rubygems.org/",

- "name" => 'rubygems',

- "rdoc_installed" => true,

- "summary" => "RubyGems itself",

- "version" => Gem::RubyGemsVersion,

- }

-

- specs = specs.sort_by { |spec| [spec["name"].downcase, spec["version"]] }

- specs.last["is_last"] = true

-

- # tag all specs with first_name_entry

- last_spec = nil

- specs.each do |spec|

- is_first = last_spec.nil? || (last_spec["name"].downcase != spec["name"].downcase)

- spec["first_name_entry"] = is_first

- last_spec = spec

- end

-

- # create page from template

- template = ERB.new(DOC_TEMPLATE)

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

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

- "total_file_count" => total_file_count.to_s }

- result = template.result binding

- res.body = result

- end

- File.join(@gemdir, mount_dir), true)

- #

- self.new.load_gems_in(*spec_dirs)

- # Returns a Hash of name => Specification of the latest versions of each

- # gem in this index.

- gem_pattern = if gem_pattern.name.empty? then

- # installed_spec_directories,

- load_gems_in(*self.class.installed_spec_directories)

- dep = Gem::Dependency.new '', Gem::Requirement.default

-

- remotes = Gem::SourceInfoCache.search dep, true

-

- remote = remotes.select { |spec| spec.name == name }.

- sort_by { |spec| spec.version.to_ints }.

- last

- outdateds << name if remote and local.version < remote.version

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

- Zlib::Inflate.inflate(string)

- CURRENT_SPECIFICATION_VERSION = 2

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

- # Adds a dependency to this Gem. For example,

- # spec.add_dependency('jabber4r', '> 0.1', '<= 0.5')

- def add_dependency(gem, *requirements)

- requirements = if requirements.empty? then

- Gem::Requirement.default

- else

- requirements.flatten

- end

- unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements)

- gem = Dependency.new(gem, requirements)

- end

- dependencies << gem

- end

-

- #

- # return:: [String] the full gem path

- #

-

-

- # The root directory that the gem was installed into.

- #

- # return:: [String] the installation path

- #

- (File.dirname(@loaded_from).split(File::SEPARATOR)[0..-2]).

- join(File::SEPARATOR)

-

- result << " s.specification_version = #{specification_version} if s.respond_to? :specification_version="

- result << ""

- result << "" unless dependencies.empty?

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- result << ""

- match_path = File.join @gem_home, 'gems', spec.full_name

- match_path == spec.full_gem_path

- ####################################################################

- # Module that defines the default UserInteraction. Any class

- # including this module will have access to the +ui+ method that

- # returns the default UI.

- # Set the default UI. If the default UI is never explicitly set, a

- # simple console based UserInteraction will be used automatically.

- # The default UI is a class variable of the singleton class for

- # this module.

-

- @ui = nil

-

- class << self

- def ui

- @ui ||= Gem::ConsoleUI.new

- end

- def ui=(new_ui)

- @ui = new_ui

- end

- def use_ui(new_ui)

- old_ui = @ui

- @ui = new_ui

- yield

- ensure

- @ui = old_ui

- end

- end

- ####################################################################

- # including this module may use the interaction methods on the

- # default UI directly. Classes may also reference the +ui+ and

- # <tt>ui=</tt> methods.

- [

- :choose_from_list, :ask, :ask_yes_no, :say, :alert, :alert_warning,

- :alert_error, :terminate_interaction

- ].each do |methname|

- }

- ####################################################################

-

- # Choose from a list of options. +question+ is a prompt displayed

- # above the list. +list+ is a list of option strings. Returns

- # the pair [option_name, option_index].

- # Ask a question. Returns a true for yes, false for no. If not

- # connected to a tty, raises an exception if default is nil,

- # otherwise returns default.

- if not @ins.tty? then

- raise(

- Gem::OperationNotSupportedError,

- "Not connected to a tty and no default specified")

- when nil

- 'yn'

- when true

- 'Yn'

- else

- 'yN'

- end

-

- # Ask a question. Returns an answer if connected to a tty, nil

- # otherwise.

-

-

- # Display an informational alert.

- return ask(question) if question

-

- # Display a warning in a location expected to get error messages.

- ask(question) if question

-

- # Display an error message in a location expected to get error

- # messages.

- # Terminate the application normally, running any exit handlers

- # that might have been defined.

- # Return a progress reporter object

- ####################################################################

- # Subclass of StreamUI that instantiates the user interaction using

- # standard in, out and error.

- ####################################################################

- # Checks if version string is valid format

- #

- # str:: [String] the version string

- # return:: [Boolean] true if the string format is correct, otherwise false

- #

- #

- # Constructs a version from the supplied string

- #

- # version:: [String] The version string. Format is digit.digit...

- #

- # Convert version to integer array

- #

- # return:: [Array] list of integers

- #

- # Compares two versions

- #

- # other:: [Version or .ints] other version to compare to

- # return:: [Fixnum] -1, 0, 1

- #

- alias eql? == # :nodoc:

- to_ints.inject { |hash_code, n| hash_code + n }

-require 'tempfile'

-require 'rubygems/source_info_cache'

-class FakeFetcher

-

- attr_reader :data

- attr_accessor :uri

- attr_accessor :paths

-

- def initialize

- @data = {}

- @paths = []

- @uri = nil

- end

-

- def fetch_path(path)

- path = path.to_s

- @paths << path

- raise ArgumentError, 'need full URI' unless path =~ %r'^http://'

- data = @data[path]

- raise Gem::RemoteFetcher::FetchError, "no data for #{path}" if data.nil?

- data.respond_to?(:call) ? data.call : data

- end

-

- def fetch_size(path)

- path = path.to_s

- @paths << path

- raise ArgumentError, 'need full URI' unless path =~ %r'^http://'

- data = @data[path]

- raise Gem::RemoteFetcher::FetchError, "no data for #{path}" if data.nil?

- data.respond_to?(:call) ? data.call : data.length

- end

-

- def download spec, source_uri, install_dir = Gem.dir

- name = "#{spec.full_name}.gem"

- path = File.join(install_dir, 'cache', name)

-

- Gem.ensure_gem_subdirectories install_dir

-

- if source_uri =~ /^http/ then

- File.open(path, "wb") do |f|

- f.write fetch_path(File.join(source_uri, "gems", name))

- end

- else

- FileUtils.cp source_uri, path

- end

-

- path

- end

-end

-

- @gem_repo = "http://gems.example.com"

- Gem::RemoteFetcher.instance_variable_set :@fetcher, nil

- Gem::SourceInfoCache.instance_variable_set :@cache, nil

- Gem::Installer.new(gem).install

- # Set the platform to +cpu+ and +os+

- @uri = URI.parse @gem_repo

- @fetcher = FakeFetcher.new

- @fetcher.uri = @uri

- Gem::RemoteFetcher.instance_variable_set :@fetcher, @fetcher

-class TempIO

-

- @@count = 0

-

- def initialize(string = '')

- @tempfile = Tempfile.new "TempIO-#{@@count ++ 1}"

- @tempfile.binmode

- @tempfile.write string

- @tempfile.rewind

- end

-

- def method_missing(meth, *args, &block)

- @tempfile.send(meth, *args, &block)

- end

-

- def respond_to?(meth)

- @tempfile.respond_to? meth

- end

-

- def string

- @tempfile.flush

-

- Gem.read_binary @tempfile.path

- end

-

-end

-

- def test_gem_original_datadir

- datadir = Config::CONFIG['datadir']

- assert_equal "#{datadir}/xyz", Config.gem_original_datadir('xyz')

- end

-

- assert_equal %w[http://gems.rubyforge.org], Gem.default_sources

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

- assert_equal Gem.dir, check_options[:install_dir]

- assert_equal "Gem foo-2\n bar (> 1)\n\n", @ui.output

- assert_equal "No match found for foo (>= 0)\n", @ui.output

- bar (> 1)

- baz-2 (foo (>= 0))

- util_setup_source_info_cache foo

- assert_equal "Gem foo-2\n bar (> 1)\n\n", @ui.output

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @source_index.dump

- @fetcher.data["#{@gem_repo}/gems/#{@a2.full_name}.gem"] =

- assert File.exist?(File.join(@tempdir, "#{@a2.full_name}.gem"))

- assert_equal "ERROR: could not find no_such_gem locally or in a repository\n",

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @source_index.dump

- assert_equal "ERROR: could not find nonexistent locally or in a repository\n",

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @source_index.dump

- @fetcher.data["#{@gem_repo}/gems/#{@a2.full_name}.gem"] =

- assert_match %r|Bulk updating|, out.shift

- assert_equal "#{a.full_name} is in pristine condition", out.shift

- gem_bin = File.join @gemhome, 'gems', "#{a.full_name}", 'bin', 'foo'

- assert_equal "Restoring 1 file to #{a.full_name}...", out.shift

- assert_equal " #{gem_bin}", out.shift

- util_make_gems

-

- @a2.summary = 'This is a lot of text. ' * 4

-

- @si = util_setup_source_info_cache @a1, @a2, @pl1

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

- cache = Gem::SourceInfoCache.cache

- cache.update

- cache.write_cache

- cache.reset_cache_data

- Gem::SourceInfoCache.reset

-

- a2_name = @a2.full_name

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = util_zip a2_name

- @fetcher.data["#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{a2_name}.gemspec.rz"] = util_zip Marshal.dump(@a2)

- @fetcher.data["#{@gem_repo}/Marshal.#{Gem.marshal_version}"] =

- Marshal.dump @si

-

-Updating metadata for 1 gems from http://gems.example.com/

-.

-complete

- cache = Gem::SourceInfoCache.cache

- cache.update

- cache.write_cache

- cache.reset_cache_data

- Gem::SourceInfoCache.reset

-

- @fetcher.data["#{@gem_repo}/quick/index.rz"] =

- util_zip [a1_name, a2_name].join("\n")

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = util_zip a2_name

- @fetcher.data["#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{a1_name}.gemspec.rz"] = util_zip Marshal.dump(@a1)

- @fetcher.data["#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{a2_name}.gemspec.rz"] = util_zip Marshal.dump(@a2)

- @fetcher.data["#{@gem_repo}/Marshal.#{Gem.marshal_version}"] =

- Marshal.dump @si

-Updating metadata for 2 gems from http://gems.example.com/

-..

-complete

- util_setup_source_info_cache

- @fetcher.data["http://beta-gems.example.com/Marshal.#{@marshal_version}"] =

- si.dump

- @cmd.handle_options %w[--add http://beta-gems.example.com]

- util_setup_source_info_cache

-Bulk updating Gem source index for: http://beta-gems.example.com/

-http://beta-gems.example.com added to sources

-

- Gem::SourceInfoCache.cache.flush

- assert_equal %W[http://beta-gems.example.com #{@gem_repo}],

- Gem::SourceInfoCache.cache_data.keys.sort

- @fetcher.data["http://beta-gems.example.com/Marshal.#{@marshal_version}"] =

- proc do

- raise Gem::RemoteFetcher::FetchError, 'it died'

- end

- Gem::RemoteFetcher.instance_variable_set :@fetcher, @fetcher

- util_setup_source_info_cache

-\tit died

- util_setup_source_info_cache

- util_setup_source_info_cache

-

- Gem::SourceInfoCache.cache.flush

- assert_equal [], Gem::SourceInfoCache.cache_data.keys

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

-

- Gem::SourceInfoCache.cache.flush

- assert_equal [], Gem::SourceInfoCache.cache_data.keys

- util_setup_fake_fetcher

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = si.dump

-Bulk updating Gem source index for: #{@gem_repo}/

-

- util_setup_source_info_cache foo

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @source_index.dump

- @fetcher.data["#{@gem_repo}/gems/#{@a1.full_name}.gem"] = read_binary @a1_path

- @fetcher.data["#{@gem_repo}/gems/#{@a2.full_name}.gem"] = read_binary @a2_path

- util_remove_gems

- assert_match %r|Bulk updating|, out.shift

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @source_index.dump

- @fetcher.data["#{@gem_repo}/gems/#{@a1.full_name}.gem"] = read_binary @a1_path

- @fetcher.data["#{@gem_repo}/gems/#{@a2.full_name}.gem"] = read_binary @a2_path

- @fetcher.data["#{@gem_repo}/gems/#{@b2.full_name}.gem"] = read_binary @b2_path

- @fetcher.data["#{@gem_repo}/gems/#{@c1_2.full_name}.gem"] =

- @fetcher.data["#{@gem_repo}/gems/#{@c2.full_name}.gem"] = read_binary @c2_path

- util_remove_gems

- assert_match %r|Bulk updating|, out.shift

- assert_match %r|Bulk updating|, out.shift

- util_remove_gems

- assert_match %r|Bulk updating|, out.shift

- util_remove_gems

- assert_match %r|Bulk updating|, out.shift

- util_remove_gems

- assert_match %r|Bulk updating|, out.shift

- def util_remove_gems

- FileUtils.rm_r File.join(@gemhome, 'gems')

- FileUtils.rm_r File.join(@gemhome, 'specifications')

- end

-

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

- @b1, @b1_gem = util_gem 'b', '1' do |s| s.add_dependency 'a' end

- si = util_setup_source_info_cache @a1, @b1, @d1, @d2, @x1_m, @x1_o, @w1,

- @y1, @y1_1_p, @z1

- @fetcher = FakeFetcher.new

- Gem::RemoteFetcher.instance_variable_set :@fetcher, @fetcher

- @fetcher.uri = URI.parse 'http://gems.example.com'

- @fetcher.data['http://gems.example.com/gems/yaml'] = si.to_yaml

- FileUtils.rm_rf File.join(@gemhome, 'gems')

- si = util_setup_source_info_cache @b1

- Gem::SourceInfoCache.instance_variable_set :@cache, nil

-

- assert_equal 'b requires a (>= 0)', e.message

- si = util_setup_source_info_cache @a1, a2_o

- assert_equal [[@b1, 'http://gems.example.com']],

- assert_equal 'http://gems.example.com', remote.last, 'remote path'

- si = util_setup_source_info_cache @a1, @b1, b2, c1

- @fetcher = FakeFetcher.new

- Gem::RemoteFetcher.instance_variable_set :@fetcher, @fetcher

- @fetcher.uri = URI.parse 'http://gems.example.com'

- @fetcher.data['http://gems.example.com/gems/yaml'] = si.to_yaml

- si = util_setup_source_info_cache @d1, @d2, e1

- @fetcher = FakeFetcher.new

- Gem::RemoteFetcher.instance_variable_set :@fetcher, @fetcher

- @fetcher.uri = URI.parse 'http://gems.example.com'

- @fetcher.data['http://gems.example.com/gems/yaml'] = si.to_yaml

- Gem.source_index = util_setup_source_info_cache @foo1, @foo2, @bar1, @bar2

- assert File.exist?(File.join(@tempdir, 'yaml'))

- assert File.exist?(File.join(@tempdir, 'yaml.Z'))

- assert File.exist?(File.join(@tempdir, "Marshal.#{@marshal_version}"))

- assert File.exist?(File.join(@tempdir, "Marshal.#{@marshal_version}.Z"))

- assert_no_match %r|a-1|, File.read(File.join(quickdir, 'latest_index'))

- deny_indexed quickdir, "#{@pl1.full_name}.gemspec.rz"

- deny_indexed quickdir, "#{@c1_2.full_name}.gemspec"

- deny_indexed marshal_quickdir, "#{@c1_2.full_name}.gemspec"

-Generating index for 6 gems in #{@tempdir}

-......

-Generating master indexes (this may take a while)

- def test_generate_index_contents

- yaml_path = File.join(@tempdir, 'yaml')

- dump_path = File.join(@tempdir, "Marshal.#{@marshal_version}")

- yaml_index = YAML.load_file(yaml_path)

- dump_str = nil

- File.open dump_path, 'rb' do |fp| dump_str = fp.read end

- dump_index = Marshal.load dump_str

- def deny_indexed(dir, name)

- assert_equal 'a requires b (> 2)', e.message

- assert_equal 'thefile', File.read(File.join(util_gem_dir, 'thefile'))

- s1 = URI.parse 'http://more-gems.example.com'

- s2 = URI.parse 'http://even-more-gems.example.com'

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

- assert_equal [s1, s2], Gem.sources

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

-#

- Gem::RemoteFetcher.instance_variable_set :@fetcher, nil

- def fetcher.connect_to(host, port)

- assert_equal "SocketError (SocketError)\n\tgetting size of #{uri}", e.message

- raise Gem::RemoteFetcher::FetchError, "haha!"

- assert_equal 'EOFError: EOFError reading uri', e.message

- assert_equal 'SocketError: SocketError reading uri', e.message

- assert_match %r|ECONNREFUSED:.*connect\(2\) reading uri\z|,

- assert_equal 'too many redirects', e.message

- def test_quick_index

- data = StringIO.new "GET /quick/index HTTP/1.0\r\n\r\n"

- @server.quick @req, @res

- assert_equal 'text/plain', @res['content-type']

- assert_equal "a-1", @res.body

- def test_quick_index_rz

- data = StringIO.new "GET /quick/index.rz HTTP/1.0\r\n\r\n"

- @server.quick @req, @res

- assert_equal 'text/plain', @res['content-type']

- assert_equal "a-1", Zlib::Inflate.inflate(@res.body)

- assert_equal 'text/plain', @res['content-type']

- spec = YAML.load Zlib::Inflate.inflate(@res.body)

- si = Gem::SourceIndex.new @a1.full_name => @a1, a1_p.full_name => a1_p

- @server.source_index = si

- assert_equal 'text/plain', @res['content-type']

- spec = YAML.load Zlib::Inflate.inflate(@res.body)

- si = Gem::SourceIndex.new @a1.full_name => @a1, ab1.full_name => ab1

- @server.source_index = si

- assert_equal 'text/plain', @res['content-type']

- spec = YAML.load Zlib::Inflate.inflate(@res.body)

- def test_quick_z_9_gemspec_rz

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}.Z"] = proc { raise SocketError }

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = proc { raise SocketError }

- @fetcher.data["#{@gem_repo}/yaml.Z"] = proc { raise SocketError }

- @fetcher.data["#{@gem_repo}/yaml"] = proc { raise SocketError }

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}", paths.shift

- assert_equal "#{@gem_repo}/yaml.Z", paths.shift

- assert_equal "#{@gem_repo}/yaml", paths.shift

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}.Z"] =

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] =

- @fetcher.data["#{@gem_repo}/yaml.Z"] = proc { raise SocketError }

- @fetcher.data["#{@gem_repo}/yaml"] = @source_index.to_yaml

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}", paths.shift

- assert_equal "#{@gem_repo}/yaml.Z", paths.shift

- assert_equal "#{@gem_repo}/yaml", paths.shift

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = marshal

- @fetcher.data["#{@gem_repo}/yaml"] = @source_index.to_yaml

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}", paths.shift

- assert_equal "#{@gem_repo}/yaml.Z", paths.shift

- assert_equal "#{@gem_repo}/yaml", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = index

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = latest_index

- assert_equal "#{@gem_repo}/quick/latest_index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = index

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = latest_index

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] =

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = index

- assert_equal "#{@gem_repo}/quick/latest_index.rz", paths.shift

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- repo = URI.parse "#{@gem_repo}/~nobody/mirror/"

- a1_spec_url = "#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{@a1.full_name}.gemspec.rz"

- repo = URI.parse "#{@gem_repo}/~nobody/mirror/"

- a1_spec_url = "#{@gem_repo}/quick/#{@a1.full_name}.gemspec.rz"

- assert_equal "#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{@a1.full_name}.gemspec.rz", paths.shift

- repo = URI.parse "#{@gem_repo}/~nobody/mirror/"

- util_setup_source_info_cache

- util_setup_source_info_cache updated

- util_setup_source_info_cache updated, updated_platform

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = latest_index

- assert_equal "#{@gem_repo}/quick/latest_index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = quick_index

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = quick_index

- yaml_uri = "#{@gem_repo}/quick/#{@b2.full_name}.gemspec.rz"

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- @fetcher.data["#{@gem_repo}/quick/index.rz"] = quick_index

- yaml_uri = "#{@gem_repo}/quick/#{@b2.full_name}.gemspec.rz"

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- @gem_repo = @gem_repo + "/subdir"

- uri = @uri.to_s + "/subdir"

- assert_equal "#{@gem_repo}/quick/index.rz", paths.shift

- assert_equal "#{@gem_repo}/Marshal.#{@marshal_version}.Z", paths.shift

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}.Z"] = util_zip source_index

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = source_index

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = si.dump

- assert_match %r|Bulk updating|, @ui.output

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = si.dump

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = si.dump

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = @source_index.dump

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}.Z"] =

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = @si.dump

- @fetcher.data["#{@gem_repo}/quick/index.rz"] =

- @fetcher.data["#{@gem_repo}/quick/latest_index.rz"] = util_zip a2_name

- @fetcher.data["#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{a1_name}.gemspec.rz"] = util_zip Marshal.dump(@a1)

- @fetcher.data["#{@gem_repo}/quick/Marshal.#{Gem.marshal_version}/#{a2_name}.gemspec.rz"] = util_zip Marshal.dump(@a2)

- @fetcher.data["#{@gem_repo}/Marshal.#{Gem.marshal_version}"] =

- sic_e.refresh @gem_repo, false

- @fetcher.data["#{@gem_repo}/Marshal.#{@marshal_version}"] = si.dump

- s.specification_version = #{Gem::Specification::CURRENT_SPECIFICATION_VERSION} if s.respond_to? :specification_version=

-

- s.specification_version = 2 if s.respond_to? :specification_version=

-

- s.add_dependency(%q<rake>, [\"> 0.4\"])

- s.add_dependency(%q<jabber4r>, [\"> 0.0.0\"])

- s.add_dependency(%q<pqa>, [\"> 0.4\", \"<= 0.6\"])

- v = Gem::Version.new("1.2")

- assert_equal true, v.eql?(@v1_2)

- assert_equal true, @v1_2.eql?(v)

- v = Gem::Version.new("1.2")

- assert_equal v.hash, @v1_2.hash

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