- :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 }