-Thu Sep 12 14:58:58 2013 NARUSE, Yui <[email protected]>

-

- * lib/uri/generic.rb (URI::Generic.find_proxy): return nil if

- http_proxy environment variable is empty string.

- [ruby-core:57140] [Bug #8898]

-

-Fri Sep 13 10:40:28 2013 Eric Hodel <[email protected]>

- VERSION = '2.1.3'

- # An Array of Regexps that match windows Ruby platforms.

- ##

- # Subdirectories in a gem repository for default gems

-

- REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES = %w[

- gems

- specifications/default

- ]

-

- def self.spec_cache_dir

- paths.spec_cache_dir

- end

-

- ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES)

- end

-

- ##

- # Quietly ensure the Gem directory +dir+ contains all the proper

- # subdirectories for handling default gems. If we can't create a

- # directory due to a permission problem, then we will silently continue.

- #

- # If +mode+ is given, missing directories are created with this mode.

- #

- # World-writable directories will never be created.

-

- def self.ensure_default_gem_subdirectories dir = Gem.dir, mode = nil

- ensure_subdirectories(dir, mode, REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES)

- end

-

- def self.ensure_subdirectories dir, mode, subdirs # :nodoc:

- subdirs.each do |name|

- # versions of the same gem. See also find_latest_files

- files = find_files_from_load_path glob if check_load_path

- def self.find_files_from_load_path glob # :nodoc:

- $LOAD_PATH.map { |load_path|

- Dir["#{File.expand_path glob, load_path}#{Gem.suffix_pattern}"]

- }.flatten.select { |file| File.file? file.untaint }

- end

-

- ##

- # Returns a list of paths matching +glob+ from the latest gems that can be

- # used by a gem to pick up features from other gems. For example:

- #

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

- #

- # if +check_load_path+ is true (the default), then find_latest_files also

- # searches $LOAD_PATH for files as well as gems.

- #

- # Unlike find_files, find_latest_files will return only files from the

- # latest version of a gem.

-

- def self.find_latest_files(glob, check_load_path=true)

- files = []

-

- files = find_files_from_load_path glob if check_load_path

-

- files.concat Gem::Specification.latest_specs(true).map { |spec|

- spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")

- }.flatten

-

- # $LOAD_PATH might contain duplicate entries or reference

- # the spec dirs directly, so we prune.

- files.uniq! if check_load_path

-

- return files

- end

-

- # A Gem::Version for the currently running Ruby.

- # Load +plugins+ as Ruby files

- def self.load_plugin_files plugins # :nodoc:

- # Find the 'rubygems_plugin' files in the latest installed gems and load

- # them

- # Remove this env var by at least 3.0

- if ENV['RUBYGEMS_LOAD_ALL_PLUGINS']

- load_plugin_files find_files('rubygems_plugin', false)

- else

- load_plugin_files find_latest_files('rubygems_plugin', false)

- end

- # Register a Gem::Specification for default gem.

- #

- # Two formats for the specification are supported:

- #

- # * MRI 2.0 style, where spec.files contains unprefixed require names.

- # The spec's filenames will be registered as-is.

- # * New style, where spec.files contains files prefixed with paths

- # from spec.require_paths. The prefixes are stripped before

- # registering the spec's filenames. Unprefixed files are omitted.

- #

- new_format = Gem.default_gems_use_full_paths? || spec.require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } }

-

- if new_format

- prefix_group = spec.require_paths.map {|f| f + "/"}.join("|")

- prefix_pattern = /^(#{prefix_group})/

- end

-

- if new_format

- file = file.sub(prefix_pattern, "")

- next unless $~

- end

-

- # Defaults the Ruby implementation wants to provide for RubyGems

-

- include Enumerable

-

- ##

- # Yields each Tuple in this AvailableSet

-

- def each

- return enum_for __method__ unless block_given?

-

- @set.each do |tuple|

- yield tuple

- end

- end

-

- ##

- # Yields the Gem::Specification for each Tuple in this AvailableSet

-

- def each_spec

- return enum_for __method__ unless block_given?

-

- each do |tuple|

- yield tuple.spec

- end

- end

-

- ##

- # Converts this AvailableSet into a RequestSet that can be used to install

- # gems.

- #

- # If +development+ is :none then no development dependencies are installed.

- # Other options are :shallow for only direct development dependencies of the

- # gems in this set or :all for all development dependencies.

-

- def to_request_set development = :none

- request_set = Gem::RequestSet.new

- request_set.development = :all == development

-

- each_spec do |spec|

- request_set.always_install << spec

-

- request_set.gem spec.name, spec.version

- request_set.import spec.development_dependencies if

- :shallow == development

- end

-

- request_set

- end

-

- ##

- #

- # Used by the DependencyResolver, the protocol to use a AvailableSet as a

- # search Set.

-

- def find_all(req)

- dep = req.dependency

-

- match = @set.find_all do |t|

- dep.matches_spec? t.spec

- end

-

- match.map do |t|

- Gem::DependencyResolver::InstalledSpecification.new(self, t.spec, t.source)

- end

- end

-

- def prefetch(reqs)

- end

-

- BUILTIN_COMMANDS = [ # :nodoc:

- :build,

- :cert,

- :check,

- :cleanup,

- :contents,

- :dependency,

- :environment,

- :fetch,

- :generate_index,

- :help,

- :install,

- :list,

- :lock,

- :mirror,

- :outdated,

- :owner,

- :pristine,

- :push,

- :query,

- :rdoc,

- :search,

- :server,

- :sources,

- :specification,

- :stale,

- :uninstall,

- :unpack,

- :update,

- :which,

- :yank,

- ]

-

-

- BUILTIN_COMMANDS.each do |name|

- register_command name

- end

- def description # :nodoc:

- <<-EOF

-The build command allows you to create a gem from a ruby gemspec.

-

-The best way to build a gem is to use a Rakefile and the Gem::PackageTask

-which ships with RubyGems.

-

-The gemspec can either be created by hand or extracted from an existing gem

-with gem spec:

-

- $ gem unpack my_gem-1.0.gem

- Unpacked gem: '.../my_gem-1.0'

- $ gem spec my_gem-1.0.gem --ruby > my_gem-1.0/my_gem-1.0.gemspec

- $ cd my_gem-1.0

- [edit gem contents]

- $ gem build my_gem-1.0.gemspec

- EOF

- end

-

-begin

- require 'openssl'

-rescue LoadError => e

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

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

-end

- passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']

- key = OpenSSL::PKey::RSA.new File.read(key_file), passphrase

- def add_certificate certificate # :nodoc:

- Gem::Security.trust_dir.trust_cert certificate

-

- say "Added '#{certificate.subject}'"

- end

-

- add_certificate certificate

- remove_certificates_matching filter

- list_certificates_matching filter

- sign_certificates unless options[:sign].empty?

- end

-

- def build name

- key, key_path = build_key

- cert_path = build_cert name, key

-

- say "Certificate: #{cert_path}"

-

- if key_path

- say "Private Key: #{key_path}"

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

- end

- def build_cert name, key # :nodoc:

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

- Gem::Security.write cert, "gem-public_cert.pem"

- def build_key # :nodoc:

- if options[:key] then

- options[:key]

- else

- passphrase = ask_for_password 'Passphrase for your Private Key:'

- say "\n"

-

- passphrase_confirmation = ask_for_password 'Please repeat the passphrase for your Private Key:'

- say "\n"

- raise Gem::CommandLineError,

- "Passphrase and passphrase confirmation don't match" unless passphrase == passphrase_confirmation

- key = Gem::Security.create_key

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

- return key, key_path

- end

- def list_certificates_matching filter # :nodoc:

- certificates_matching filter do |certificate, _|

- # this could probably be formatted more gracefully

- say certificate.subject.to_s

- end

- end

-

- passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']

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

- def load_defaults # :nodoc:

- load_default_cert unless options[:issuer_cert]

- load_default_key unless options[:key]

- end

-

- def remove_certificates_matching filter # :nodoc:

- certificates_matching filter do |certificate, path|

- FileUtils.rm path

- say "Removed '#{certificate.subject}'"

- end

- end

-

- def sign_certificates # :nodoc:

- load_defaults unless options[:sign].empty?

-

- options[:sign].each do |cert_file|

- sign cert_file

- end

- end

-

-end if defined?(OpenSSL::SSL)

- def description # :nodoc:

- <<-EOF

-The check command can list and repair problems with installed gems and

-specifications and will clean up gems that have been partially uninstalled.

- EOF

- end

-

- 'Clean up old versions of installed gems',

- add_option('-n', '-d', '--dryrun',

- 'Do not uninstall gems') do |value, options|

-The cleanup command removes old versions of gems from GEM_HOME that are not

-required to meet a dependency. If a gem is installed elsewhere in GEM_PATH

-the cleanup command won't delete it.

-If no gems are named all gems in GEM_HOME are cleaned.

-

- @path_kind = nil

- @spec_dirs = nil

- @version = nil

- def description # :nodoc:

- <<-EOF

-The contents command lists the files in an installed gem. The listing can

-be given as full file names, file names without the installed directory

-prefix or only the files that are requireable.

- EOF

- end

-

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

- @spec_dirs = specification_directories

- @path_kind = path_description @spec_dirs

-

- names = gem_names

-

- names.each do |name|

- found = gem_contents name

-

- terminate_interaction 1 unless found or names.length > 1

- end

- end

-

- def files_in spec

- if spec.default_gem? then

- files_in_default_gem spec

- else

- files_in_gem spec

- end

- end

- def files_in_gem spec

- gem_path = spec.full_gem_path

- extra = "/{#{spec.require_paths.join ','}}" if options[:lib_only]

- glob = "#{gem_path}#{extra}/**/*"

- prefix_re = /#{Regexp.escape(gem_path)}\//

-

- Dir[glob].map do |file|

- [gem_path, file.sub(prefix_re, "")]

- end

- end

- def files_in_default_gem spec

- spec.files.sort.map do |file|

- case file

- when /\A#{spec.bindir}\//

- [Gem::ConfigMap[:bindir], $POSTMATCH]

- when /\.so\z/

- [Gem::ConfigMap[:archdir], file]

- else

- [Gem::ConfigMap[:rubylibdir], file]

- end

- end

-

- def gem_contents name

- spec = spec_for name

-

- return false unless spec

- files = files_in spec

-

- show_files files

-

- true

- end

-

- def gem_names # :nodoc:

- if options[:all] then

- Gem::Specification.map(&:name)

- else

- get_all_gem_names

- end

- end

-

- def path_description spec_dirs # :nodoc:

- if spec_dirs.empty? then

- spec_dirs = Gem::Specification.dirs

- "default gem paths"

- else

- "specified path"

- end

- end

-

- def show_files files

- files.sort.each do |prefix, basename|

- absolute_path = File.join(prefix, basename)

- next if File.directory? absolute_path

-

- if options[:prefix] then

- say absolute_path

- say basename

- end

- end

-

- def spec_for name

- spec = Gem::Specification.find_all_by_name(name, @version).last

- return spec if spec

- say "Unable to find gem '#{name}' in #{@path_kind}"

-

- if Gem.configuration.verbose then

- say "\nDirectories searched:"

- @spec_dirs.sort.each { |dir| say dir }

-

- return nil

- end

-

- def specification_directories # :nodoc:

- options[:specdirs].map do |i|

- [i, File.join(i, "specifications")]

- end.flatten

- def description # :nodoc:

- <<-EOF

-The dependency commands lists which other gems a given gem depends on. For

-local gems only the reverse dependencies can be shown (which gems depend on

-the named gem).

-

-The dependency list can be displayed in a format suitable for piping for

-use with other commands.

- EOF

- end

-

- def fetch_remote_specs dependency # :nodoc:

- fetcher = Gem::SpecFetcher.fetcher

-

- ss, = fetcher.spec_for_dependency dependency

-

- ss.map { |spec, _| spec }

- end

-

- def fetch_specs dependency # :nodoc:

- specs = []

-

- specs.concat dependency.matching_specs if local?

- specs.concat fetch_remote_specs dependency if remote?

-

- ensure_specs specs

-

- specs.uniq.sort

- end

- def gem_dependency args, version, prerelease # :nodoc:

- args << '' if args.empty?

- pattern = if args.length == 1 and args.first =~ /\A\/(.*)\/(i)?\z/m then

- /\A#{Regexp.union(*args)}/

- Gem::Dependency.new pattern, version

- dependency.prerelease = prerelease

- dependency

- end

- def display_pipe specs # :nodoc:

- specs.each do |spec|

- unless spec.dependencies.empty? then

- spec.dependencies.sort_by { |dep| dep.name }.each do |dep|

- say "#{dep.name} --version '#{dep.requirement}'"

- end

- end

- end

- end

- def display_readable specs, reverse # :nodoc:

- response = ''

- specs.each do |spec|

- response << print_dependencies(spec)

- unless reverse[spec.full_name].empty? then

- response << " Used by\n"

- reverse[spec.full_name].each do |sp, dep|

- response << " #{sp} (#{dep})\n"

- end

- end

- response << "\n"

- say response

- end

- def execute

- ensure_local_only_reverse_dependencies

- dependency =

- gem_dependency options[:args], options[:version], options[:prerelease]

- specs = fetch_specs dependency

- reverse = reverse_dependencies specs

- display_pipe specs

- display_readable specs, reverse

- end

- end

- def ensure_local_only_reverse_dependencies # :nodoc:

- if options[:reverse_dependencies] and remote? and not local? then

- alert_error 'Only reverse dependencies for local gems are supported.'

- terminate_interaction 1

- def ensure_specs specs # :nodoc:

- return unless specs.empty?

-

- patterns = options[:args].join ','

- say "No gems found matching #{patterns} (#{options[:version]})" if

- Gem.configuration.verbose

-

- terminate_interaction 1

- end

-

- def print_dependencies(spec, level = 0) # :nodoc:

- def remote_specs dependency # :nodoc:

- fetcher = Gem::SpecFetcher.fetcher

-

- ss, _ = fetcher.spec_for_dependency dependency

-

- ss.map { |s,o| s }

- end

-

- def reverse_dependencies specs # :nodoc:

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

-

- return reverse unless options[:reverse_dependencies]

-

- specs.each do |spec|

- reverse[spec.full_name] = find_reverse_dependencies spec

- end

-

- reverse

- end

-

- def find_reverse_dependencies spec # :nodoc:

-The environment command lets you query rubygems for its configuration for

-use in shell scripts or as a debugging aid.

-

- out <<

- case arg

- when /^packageversion/ then

- Gem::RubyGemsPackageVersion

- when /^version/ then

- Gem::VERSION

- when /^gemdir/, /^gemhome/, /^home/, /^GEM_HOME/ then

- Gem.dir

- when /^gempath/, /^path/, /^GEM_PATH/ then

- Gem.path.join(File::PATH_SEPARATOR)

- when /^remotesources/ then

- Gem.sources.to_a.join("\n")

- when /^platform/ then

- Gem.platforms.join(File::PATH_SEPARATOR)

- when nil then

- show_environment

- else

- raise Gem::CommandLineError, "Unknown environment option [#{arg}]"

- say out

- true

- end

-

- def add_path out, path

- path.each do |component|

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

- end

- end

-

- def show_environment # :nodoc:

- out = "RubyGems Environment:\n"

-

- out << " - RUBYGEMS VERSION: #{Gem::VERSION}\n"

-

- out << " - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"

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

- out << ") [#{RUBY_PLATFORM}]\n"

-

- out << " - INSTALLATION DIRECTORY: #{Gem.dir}\n"

-

- out << " - RUBYGEMS PREFIX: #{Gem.prefix}\n" unless Gem.prefix.nil?

-

- out << " - RUBY EXECUTABLE: #{Gem.ruby}\n"

- out << " - EXECUTABLE DIRECTORY: #{Gem.bindir}\n"

- out << " - SPEC CACHE DIRECTORY: #{Gem.spec_cache_dir}\n"

-

- out << " - RUBYGEMS PLATFORMS:\n"

- Gem.platforms.each do |platform|

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

- end

-

- out << " - GEM PATHS:\n"

- out << " - #{Gem.dir}\n"

- gem_path = Gem.path.dup

- gem_path.delete Gem.dir

- add_path out, gem_path

- out << " - GEM CONFIGURATION:\n"

- Gem.configuration.each do |name, value|

- value = value.gsub(/./, '*') if name == 'gemcutter_key'

- out << " - #{name.inspect} => #{value.inspect}\n"

- end

- out << " - REMOTE SOURCES:\n"

- Gem.sources.each do |s|

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

-

- out << " - SHELL PATH:\n"

-

- shell_path = ENV['PATH'].split(File::PATH_SEPARATOR)

- add_path out, shell_path

-

- out

- def description # :nodoc:

- <<-EOF

-The fetch command fetches gem files that can be stored for later use or

-unpacked to examine their contents.

-

-See the build command help for an example of unpacking a gem, modifying it,

-then repackaging it.

- EOF

- end

-

- specs_and_sources, errors =

- Gem::SpecFetcher.fetcher.spec_for_dependency dep

-

- spec, source = specs_and_sources.max_by { |s,| s.version }

-

-* Update your local version of RubyGems

-

- gem update --system

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

- "universal" as the CPU or the local CPU starts with "arm" and the gem's

- CPU is exactly "arm" (for gems that support generic ARM architecture).

-For the ARM architecture, gems with a platform of "arm-linux" should run on a

-reasonable set of ARM CPUs and not depend on instructions present on a limited

-subset of the architecture. For example, the binary should run on platforms

-armv5, armv6hf, armv6l, armv7, etc. If you use the "arm-linux" platform

-please test your gem on a variety of ARM hardware before release to ensure it

-functions correctly.

-

- armv7-linux # Gem complied for an ARMv7 CPU running linux

- arm-linux # Gem compiled for any ARM CPU running linux

-

- @command_manager = Gem::CommandManager.instance

- show_commands

-

- elsif begins? "options", arg then

- say Gem::Command::HELP

- elsif begins? "examples", arg then

- say EXAMPLES

- elsif begins? "platforms", arg then

- say PLATFORMS

- elsif options[:help] then

- show_help

- elsif arg then

- show_command_help arg

- else

- say Gem::Command::HELP

- end

- end

- def show_commands # :nodoc:

- out = []

- out << "GEM commands are:"

- out << nil

- margin_width = 4

- desc_width = @command_manager.command_names.map { |n| n.size }.max + 4

- summary_width = 80 - margin_width - desc_width

- wrap_indent = ' ' * (margin_width + desc_width)

- format = "#{' ' * margin_width}%-#{desc_width}s%s"

- @command_manager.command_names.each do |cmd_name|

- command = @command_manager[cmd_name]

- summary =

- if command then

- command.summary

- else

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

- end

- summary = wrap(summary, summary_width).split "\n"

- out << sprintf(format, cmd_name, summary.shift)

- until summary.empty? do

- out << "#{wrap_indent}#{summary.shift}"

- end

- out << nil

- out << "For help on a particular command, use 'gem help COMMAND'."

- out << nil

- out << "Commands may be abbreviated, so long as they are unambiguous."

- out << "e.g. 'gem i rake' is short for 'gem install rake'."

-

- say out.join("\n")

- end

-

- def show_command_help command_name # :nodoc:

- command_name = command_name.downcase

-

- possibilities = @command_manager.find_command_possibilities command_name

-

- if possibilities.size == 1 then

- command = @command_manager[possibilities.first]

- command.invoke("--help")

- elsif possibilities.size > 1 then

- alert_warning "Ambiguous command #{command_name} (#{possibilities.join(', ')})"

- else

- alert_warning "Unknown command #{command_name}. Try: gem help commands"

- end

- end

- def show_help # :nodoc:

- command = @command_manager[options[:help]]

- if command then

- # help with provided command

- command.invoke("--help")

- alert_error "Unknown command #{options[:help]}. Try 'gem help commands'"

- add_option(:"Install/Update", '--default',

- 'Add the gem\'s full specification to',

- 'specifications/default and extract only its bin') do |v,o|

- o[:install_as_default] = v

- end

-

- def check_install_dir # :nodoc:

- if options[:install_dir] and options[:user_install] then

- alert_error "Use --install-dir or --user-install but not both"

- terminate_interaction 1

- end

- end

-

- def check_version # :nodoc:

- if options[:version] != Gem::Requirement.default and

- get_all_gem_names.size > 1 then

- alert_error "Can't use --version w/ multiple gems. Use name:ver instead."

- terminate_interaction 1

- end

- end

-

- def execute

- if gf = options[:gemdeps] then

- install_from_gemdeps gf

- return

- end

-

- @installed_specs = []

-

- ENV.delete 'GEM_PATH' if options[:install_dir].nil? and RUBY_VERSION > '1.9'

-

- check_install_dir

- check_version

-

- load_hooks

-

- exit_code = install_gems

-

- show_installed

-

- raise Gem::SystemExitException, exit_code

- end

-

- def install_from_gemdeps gf # :nodoc:

- def install_gem name, version # :nodoc:

- return if options[:conservative] and

- not Gem::Dependency.new(name, version).matching_specs.empty?

- inst = Gem::DependencyInstaller.new options

- inst.install name, Gem::Requirement.create(version)

- @installed_specs.push(*inst.installed_gems)

- show_install_errors inst.errors

- end

- def install_gems # :nodoc:

- install_gem gem_name, gem_version

- exit_code

- end

-

- ##

- # Loads post-install hooks

-

- def load_hooks # :nodoc:

- if options[:install_as_default]

- require 'rubygems/install_default_message'

- else

- require 'rubygems/install_message'

- require 'rubygems/rdoc'

- end

-

- def show_install_errors errors # :nodoc:

- return unless errors

- errors.each do |x|

- return unless Gem::SourceFetchProblem === x

-

- msg = "Unable to pull data from '#{x.source.uri}': #{x.error.message}"

-

- alert_warning msg

- end

- end

-

- def show_installed # :nodoc:

- return if @installed_specs.empty?

-

- gems = @installed_specs.length == 1 ? 'gem' : 'gems'

- say "#{@installed_specs.length} #{gems} installed"

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

- def description # :nodoc:

- <<-EOF

-The list command is used to view the gems you have installed locally.

-

-The --details option displays additional details including the summary, the

-homepage, the author, the locations of different versions of the gem.

-

-To search for remote gems use the search command.

- EOF

- end

-

- def description # :nodoc:

- <<-EOF

-The mirror command has been moved to the rubygems-mirror gem.

- EOF

- end

-

- def description # :nodoc:

- <<-EOF

-The outdated command lists gems you way wish to upgrade to a newer version.

-You can check for dependency mismatches using the dependency command and

-update the gems with the update or install commands.

- EOF

- end

- def execute

- Gem::Specification.outdated_and_latest_version.each do |spec, remote_version|

- say "#{spec.name} (#{spec.version} < #{remote_version})"

- <<-EOF

-The owner command lets you add and remove owners of a gem on a push

-server (the default is https://rubygems.org).

-

-The owner of a gem has the permission to push new versions, yank existing

-versions or edit the HTML page of the gem. Be careful of who you give push

-permission to.

- EOF

- super 'owner', 'Manage gem owners of a gem on the push server'

-

- add_option '-h', '--host HOST', 'Use another gemcutter-compatible host' do |value, options|

- options[:host] = value

- end

- @host = options[:host]

-

- add_option('-E', '--[no-]env-shebang',

- 'Rewrite executables with a shebang',

- 'of /usr/bin/env') do |value, options|

- options[:env_shebang] = value

- end

-

- env_shebang =

- if options.include? :env_shebang then

- options[:env_shebang]

- else

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

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

- end

- :env_shebang => env_shebang,

-

- <<-EOF

-The push command uploads a gem to the push server (the default is

-https://rubygems.org) and adds it to the index.

-

-The gem can be removed from the index (but only the index) using the yank

-command. For further discussion see the help for the yank command.

- EOF

- super 'push', 'Push a gem up to the gem server', :host => self.host

- def description # :nodoc:

- <<-EOF

-The query command is the basis for the list and search commands.

-

-You should really use the list and search commands instead. This command

-is too hard to use.

- EOF

- end

-

-The rdoc command builds documentation for installed gems. By default

-only documentation is built using rdoc, but additional types of

-documentation may be built through rubygems plugins and the

-Gem.post_installs hook.

-

-Use --overwrite to force rebuilding of documentation.

- super 'search', 'Display remote gems whose name contains STRING'

- def description # :nodoc:

- <<-EOF

-The search command displays remote gems whose name contains the given

-string.

-

-The --details option displays additional details from the gem but will

-take a little longer to complete as it must download the information

-individually from the index.

-

-To list local gems use the list command.

- EOF

- end

-

- def add_source source_uri # :nodoc:

- check_rubygems_https source_uri

- source = Gem::Source.new source_uri

- begin

- if Gem.sources.include? source_uri then

- say "source #{source_uri} already present in the cache"

- source.load_specs :released

- Gem.sources << source

- Gem.configuration.write

- say "#{source_uri} added to sources"

- rescue URI::Error, ArgumentError

- say "#{source_uri} is not a URI"

- terminate_interaction 1

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

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

- terminate_interaction 1

- end

- def check_rubygems_https source_uri # :nodoc:

- uri = URI source_uri

- if uri.scheme and uri.scheme.downcase == 'http' and

- uri.host.downcase == 'rubygems.org' then

- question = <<-QUESTION.chomp

- QUESTION

- terminate_interaction 1 unless ask_yes_no question

- end

- end

-

- def clear_all # :nodoc:

- path = Gem.spec_cache_dir

- FileUtils.rm_rf path

-

- unless File.exist? path then

- say "*** Removed specs cache ***"

- else

- unless File.writable? path then

- say "*** Unable to remove source cache (write protected) ***"

- else

- say "*** Unable to remove source cache ***"

- terminate_interaction 1

- end

-

- def defaults_str # :nodoc:

- '--list'

- end

-

- def description # :nodoc:

- <<-EOF

-RubyGems fetches gems from the sources you have configured (stored in your

-~/.gemrc).

-

-The default source is https://rubygems.org, but you may have older sources

-configured. This guide will help you update your sources or configure

-yourself to use your own gem server.

-

-Without any arguments the sources lists your currently configured sources:

-

- $ gem sources

- *** CURRENT SOURCES ***

-

- https://rubygems.org

-

-This may list multiple sources or non-rubygems sources. You probably

-configured them before or have an old `~/.gemrc`. If you have sources you

-do not recognize you should remove them.

-

-RubyGems has been configured to serve gems via the following URLs through

-its history:

-

-* http://gems.rubyforge.org (RubyGems 1.3.6 and earlier)

-* http://rubygems.org (RubyGems 1.3.7 through 1.8.25)

-* https://rubygems.org (RubyGems 2.0.1 and newer)

-Since all of these sources point to the same set of gems you only need one

-of them in your list. https://rubygems.org is recommended as it brings the

-protections of an SSL connection to gem downloads.

-To add a source use the --add argument:

-

- $ gem sources --add https://rubygems.org

- https://rubygems.org added to sources

-

-RubyGems will check to see if gems can be installed from the source given

-before it is added.

-

-To remove a source use the --remove argument:

-

- $ gem sources --remove http://rubygems.org

- http://rubygems.org removed from sources

-

- EOF

- end

-

- def list # :nodoc:

- say "*** CURRENT SOURCES ***"

- say

- Gem.sources.each do |src|

- say src

- end

-

- def list? # :nodoc:

- !(options[:list] ||

- options[:add] ||

- options[:clear_all] ||

- options[:remove] ||

- options[:update])

- end

- def execute

- clear_all if options[:clear_all]

-

- source_uri = options[:add]

- add_source source_uri if source_uri

-

- source_uri = options[:remove]

- remove_source source_uri if source_uri

-

- update if options[:update]

- list if list?

- end

- def remove_source source_uri # :nodoc:

- unless Gem.sources.include? source_uri then

- say "source #{source_uri} not present in cache"

- else

- Gem.sources.delete source_uri

- Gem.configuration.write

- say "#{source_uri} removed from sources"

- def update # :nodoc:

- Gem.sources.each_source do |src|

- src.load_specs :released

- src.load_specs :latest

- end

-

- say "source cache successfully updated"

- end

- def remove_cache_file desc, path # :nodoc:

- def description # :nodoc:

- <<-EOF

-The specification command allows you to extract the specification from

-a gem for examination.

-

-The specification can be output in YAML, ruby or Marshal formats.

-

-Specific fields in the specification can be extracted in YAML format:

-

- $ gem spec rake summary

- --- Ruby based make-like utility.

- ...

-

- EOF

- end

-

- def description # :nodoc:

- <<-EOF

-The stale command lists the latest access time for all the files in your

-installed gems.

-

-You can use this command to discover gems and gem versions you are no

-longer using.

- EOF

- end

-

-require 'fileutils'

- :install_dir => Gem.dir, :check_dev => false

- add_option('--[no-]abort-on-dependent',

- 'Prevent uninstalling gems that are',

- 'depended on by other gems.') do |value, options|

- options[:abort_on_dependent] = value

- end

-

- def description # :nodoc:

- <<-EOF

-The uninstall command removes a previously installed gem.

-

-RubyGems will ask for confirmation if you are attempting to uninstall a gem

-that is a dependency of an existing gem. You can use the

---ignore-dependencies option to skip this check.

- EOF

- end

-

- if options[:all] and not options[:args].empty? then

- alert_error 'Gem names and --all may not be used together'

- terminate_interaction 1

- elsif options[:all] then

- uninstall_all

- else

- uninstall_specific

- end

- end

-

- def uninstall_all

- _, specs = Gem::Specification.partition { |spec| spec.default_gem? }

-

- specs.each do |spec|

- options[:version] = spec.version

-

- begin

- Gem::Uninstaller.new(spec.name, options).uninstall

- rescue Gem::InstallError

- end

- end

-

- alert "Uninstalled all gems in #{options[:install_dir]}"

- end

-

- def uninstall_specific

-

- def description

- <<-EOF

-The unpack command allows you to examine the contents of a gem or modify

-them to help diagnose a bug.

-

-You can add the contents of the unpacked gem to the load path using the

-RUBYLIB environment variable or -I:

-

- $ gem unpack my_gem

- Unpacked gem: '.../my_gem-1.0'

- [edit my_gem-1.0/lib/my_gem.rb]

- $ ruby -Imy_gem-1.0/lib -S other_program

-

-You can repackage an unpacked gem using the build command. See the build

-command help for an example.

- EOF

- end

-

- def description # :nodoc:

- <<-EOF

-The update command will update your gems to the latest version.

-

-The update comamnd does not remove the previous version. Use the cleanup

-command to remove old versions.

- EOF

- end

-

- def check_latest_rubygems version # :nodoc:

- if Gem.rubygems_version == version then

- say "Latest version currently installed. Aborting."

- terminate_interaction

- end

-

- options[:user_install] = false

- end

-

- def check_update_arguments # :nodoc:

- unless options[:args].empty? then

- alert_error "Gem names are not allowed with the --system option"

- terminate_interaction 1

- end

- end

-

- end

- say "Updating installed gems"

- hig = highest_installed_gems

- def fetch_remote_gems spec # :nodoc:

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

- dependency.prerelease = options[:prerelease]

-

- fetcher = Gem::SpecFetcher.fetcher

-

- spec_tuples, _ = fetcher.search_for_dependency dependency

- spec_tuples

- end

- def highest_installed_gems # :nodoc:

- hig = {} # highest installed gems

- Gem::Specification.each do |spec|

- if hig[spec.name].nil? or hig[spec.name].version < spec.version then

- hig[spec.name] = spec

- end

- hig

- def highest_remote_version spec # :nodoc:

- spec_tuples = fetch_remote_gems spec

-

- matching_gems = spec_tuples.select do |g,_|

- g.name == spec.name and g.match_platform?

- highest_remote_gem = matching_gems.sort_by { |g,_| g.version }.last

-

- highest_remote_gem ||= [Gem::NameTuple.null]

-

- highest_remote_gem.first.version

- def install_rubygems version # :nodoc:

- args = update_rubygems_arguments

- update_dir = File.join Gem.dir, 'gems', "rubygems-update-#{version}"

- Dir.chdir update_dir do

- say "Installing RubyGems #{version}"

- # Make sure old rubygems isn't loaded

- old = ENV["RUBYOPT"]

- ENV.delete("RUBYOPT") if old

- installed = system Gem.ruby, 'setup.rb', *args

- say "RubyGems system software updated" if installed

- ENV["RUBYOPT"] = old if old

- end

- end

- def rubygems_target_version

- update_latest = version == true

-

- if update_latest then

- _, up_ver = gems_to_update.first

- target = if update_latest then

- return target, requirement

- end

-

- def update_gem name, version = Gem::Requirement.default

- return if @updated.any? { |spec| spec.name == name }

-

- @installer ||= Gem::DependencyInstaller.new options

-

- success = false

-

- say "Updating #{name}"

- begin

- @installer.install name, Gem::Requirement.new(version)

- success = true

- rescue Gem::InstallError => e

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

- success = false

- end

-

- @installer.installed_gems.each do |spec|

- @updated << spec

- end

- def update_gems gems_to_update

- gems_to_update.uniq.sort.each do |(name, version)|

- update_gem name, version

- end

-

- @updated

- end

-

- ##

- # Update RubyGems software to the latest version.

-

- def update_rubygems

- check_update_arguments

-

- version, requirement = rubygems_target_version

-

- check_latest_rubygems version

-

- update_gem 'rubygems-update', version

- install_rubygems version

- end

-

- def update_rubygems_arguments # :nodoc:

- args

- highest_remote_ver = highest_remote_version l_spec

- def description # :nodoc:

- <<-EOF

-The which command is like the shell which command and shows you where

-the file you wish to require lives.

-

-You can use the which command to help determine why you are requiring a

-version you did not expect or to look at the content of a file you are

-requiring to see why it does not behave as you expect.

- EOF

- end

-

- <<-EOF

-The yank command removes a gem you pushed to a server from the server's

-index.

-

-Note that if you push a gem to rubygems.org the yank command does not

-prevent other people from downloading the gem via the download link.

-

-Once you have pushed a gem several downloads will happen automatically

-via the webhooks. If you accidentally pushed passwords or other sensitive

-data you will need to change them immediately and yank your gem.

-

-If you are yanking a gem due to intellectual property reasons contact

-http://help.rubygems.org for permanant removal. Be sure to mention this

-as the reason for the removal request.

- EOF

- super 'yank', 'Remove a pushed gem from the index'

- # Path name of directory or file of openssl client certificate, used for remote https connection with client authentication

-

- attr_reader :ssl_client_cert

-

- ##

- @ssl_client_cert = @hash[:ssl_client_cert] if @hash.key? :ssl_client_cert

-To fix this error run:

-

-\tchmod 0600 #{credentials_path}

-

- YAMLErrors = [ArgumentError]

- YAMLErrors << Psych::SyntaxError if defined?(Psych::SyntaxError)

-

- rescue *YAMLErrors => e

- warn "Failed to load #{filename}, #{e.to_s}"

- begin

- RUBYGEMS_ACTIVATION_MONITOR.exit

- return gem_original_require(path)

- ensure

- RUBYGEMS_ACTIVATION_MONITOR.enter

- end

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

- begin

- RUBYGEMS_ACTIVATION_MONITOR.exit

- return gem_original_require(path)

- ensure

- RUBYGEMS_ACTIVATION_MONITOR.enter

- end if spec

- begin

- RUBYGEMS_ACTIVATION_MONITOR.exit

- return gem_original_require(path)

- ensure

- RUBYGEMS_ACTIVATION_MONITOR.enter

- end

- begin

- RUBYGEMS_ACTIVATION_MONITOR.exit

- return gem_original_require(path)

- ensure

- RUBYGEMS_ACTIVATION_MONITOR.enter

- end

- # Default spec directory path to be used if an alternate value is not

- # specified in the environment

-

- def self.default_spec_cache_dir

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

- end

-

- ##

-

- ##

- # Whether to expect full paths in default gems - true for non-MRI

- # ruby implementations

- def self.default_gems_use_full_paths?

- ruby_engine != 'ruby'

- end

- alias === =~

-

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

- }.map(&:to_spec)

-require 'rubygems/dependency_resolver'

-require 'rubygems/source'

- DEFAULT_OPTIONS = { # :nodoc:

- :install_as_default => false

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

-

- attr_reader :document

-

- ##

- # Errors from SpecFetcher while searching for remote specifications

-

- attr_reader :errors

-

- ##

- #--

- # TODO remove, no longer used

-

- attr_reader :gems_to_install # :nodoc:

-

- ##

- # List of gems installed by #install in alphabetic order

-

- attr_reader :installed_gems

-

- ##

- def initialize options = {}

- @only_install_dir = !!options[:install_dir]

- @install_as_default = options[:install_as_default]

- ##

- #--

- # TODO remove, no longer used

-

- def add_found_dependencies to_do, dependency_list # :nodoc:

- seen = {}

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

-

- until to_do.empty? do

- spec = to_do.shift

-

- # HACK why is spec nil?

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

- seen[spec.name] = true

-

- deps = spec.runtime_dependencies

-

- if @development

- if @dev_shallow

- if @toplevel_specs.include? spec.full_name

- deps |= spec.development_dependencies

- end

- else

- deps |= spec.development_dependencies

- end

- end

-

- deps.each do |dep|

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

-

- if @minimal_deps

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

- dep.name == installed_spec.name and

- dep.requirement.satisfied_by? installed_spec.version

- end

- end

-

- results = find_gems_with_sources(dep)

-

- results.sorted.each do |t|

- to_do.push t.spec

- end

-

- results.remove_installed! dep

-

- @available << results

- results.inject_into_list dependency_list

- end

- end

- dependency_list.remove_specs_unsatisfied_by dependencies

- end

- def find_gems_with_sources dep # :nodoc:

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

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

- # installation of the gem.

-

- def find_spec_by_name_and_version gem_name,

- version = Gem::Requirement.default,

- prerelease = false

- set = Gem::AvailableSet.new

-

- if consider_local?

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

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

- set.add src.spec, src

- else

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

-

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

- set.add s, local

- end

- end

- end

-

- if set.empty?

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

- dep.prerelease = true if prerelease

-

- set = find_gems_with_sources(dep)

- set.match_platform!

- end

-

- if set.empty?

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

- end

-

- @available = set

- end

-

- ##

- #--

- # TODO remove, no longer used

- def gather_dependencies # :nodoc:

- def in_background what # :nodoc:

- fork_happened = false

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

- begin

- Process.fork do

- yield

- fork_happened = true

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

- rescue NotImplementedError

- yield unless fork_happened

- request_set = resolve_dependencies dep_or_name, version

- options = {

- :bin_dir => @bin_dir,

- :build_args => @build_args,

- :env_shebang => @env_shebang,

- :force => @force,

- :format_executable => @format_executable,

- :ignore_dependencies => @ignore_dependencies,

- :security_policy => @security_policy,

- :user_install => @user_install,

- :wrappers => @wrappers,

- :install_as_default => @install_as_default

- }

- options[:install_dir] = @install_dir if @only_install_dir

- request_set.install options do |_, installer|

- @installed_gems << installer.spec if installer

- end

- @installed_gems.sort!

- def install_development_deps # :nodoc:

- if @development and @dev_shallow then

- :shallow

- elsif @development then

- :all

- else

- :none

- end

- end

-

- def resolve_dependencies dep_or_name, version # :nodoc:

- as = available_set_for dep_or_name, version

-

- request_set = as.to_request_set install_development_deps

- request_set.soft_missing = @force

-

- installer_set = Gem::DependencyResolver::InstallerSet.new @domain

- installer_set.always_install.concat request_set.always_install

- installer_set.ignore_installed = @only_install_dir

-

- if @ignore_dependencies then

- installer_set.ignore_dependencies = true

- request_set.soft_missing = true

-

- request_set.resolve Gem::DependencyResolver.compose_sets(as, installer_set)

-

- request_set

-

-require 'rubygems/util/list'

-##

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

-# set of available specs via +set+, calculates a set of ActivationRequest

-# objects which indicate all the specs that should be activated to meet the

-# all the requirements.

-class Gem::DependencyResolver

-

- ##

- # Contains all the conflicts encountered while doing resolution

- attr_reader :conflicts

- attr_accessor :development

- attr_reader :missing

- ##

- # When a missing dependency, don't stop. Just go on and record what was

- # missing.

- attr_accessor :soft_missing

- def self.compose_sets *sets

- Gem::DependencyResolver::ComposedSet.new(*sets)

- ##

- # Provide a DependencyResolver that queries only against the already

- # installed gems.

- def self.for_current_gems needed

- new needed, Gem::DependencyResolver::CurrentSet.new

- ##

- # Create DependencyResolver object which will resolve the tree starting

- # with +needed+ Depedency objects.

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

- # satisify the Dependencies. This defaults to IndexSet, which will query

- # rubygems.org.

-

- def initialize needed, set = nil

- @set = set || Gem::DependencyResolver::IndexSet.new

- @needed = needed

-

- @conflicts = nil

- @development = false

- @missing = []

- @soft_missing = false

- end

- def requests s, act, reqs=nil

- s.dependencies.reverse_each do |d|

- next if d.type == :development and not @development

- reqs = Gem::List.new Gem::DependencyResolver::DependencyRequest.new(d, act), reqs

- @set.prefetch reqs

- reqs

- end

- ##

- # Proceed with resolution! Returns an array of ActivationRequest objects.

- def resolve

- @conflicts = []

- needed = nil

- @needed.reverse_each do |n|

- request = Gem::DependencyResolver::DependencyRequest.new n, nil

- needed = Gem::List.new request, needed

- res = resolve_for needed, nil

- raise Gem::DependencyResolutionError, res if

- res.kind_of? Gem::DependencyResolver::DependencyConflict

- res.to_a

- end

- ##

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

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

- # ActivationRequest objects.

-

- def resolve_for needed, specs

- while needed

- dep = needed.value

- needed = needed.tail

-

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

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

-

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

- # existing spec.

- next if dep.matches_spec? existing

-

- # There is a conflict! We return the conflict

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

- # handled at the right level.

-

- # If the existing activation indicates that there

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

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

- # it on the requester's request itself.

- #

- if existing.others_possible?

- conflict =

- Gem::DependencyResolver::DependencyConflict.new dep, existing

- else

- depreq = existing.request.requester.request

- conflict =

- Gem::DependencyResolver::DependencyConflict.new depreq, existing, dep

- @conflicts << conflict

- return conflict

- # Get a list of all specs that satisfy dep and platform

- possible = @set.find_all dep

- possible = select_local_platforms possible

- case possible.size

- when 0

- @missing << dep

- unless @soft_missing

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

- raise Gem::UnsatisfiableDependencyError, dep

- when 1

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

- # and process the specs dependencies by adding

- # them to needed.

-

- spec = possible.first

- act = Gem::DependencyResolver::ActivationRequest.new spec, dep, false

-

- specs = Gem::List.prepend specs, act

-

- # Put the deps for at the beginning of needed

- # rather than the end to match the depth first

- # searching done by the multiple case code below.

- #

- # This keeps the error messages consistent.

- needed = requests(spec, act, needed)

- else

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

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

-

- # Sort them so that we try the highest versions

- # first.

- possible = possible.sort_by do |s|

- [s.source, s.version, s.platform == Gem::Platform::RUBY ? -1 : 1]

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

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

- conflicts = []

-

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

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

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

- #

- # We use an until loop rather than #reverse_each

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

- # algorithm.

- #

- until possible.empty?

- s = possible.pop

-

- # Recursively call #resolve_for with this spec

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

-

- act = Gem::DependencyResolver::ActivationRequest.new s, dep

-

- try = requests(s, act, needed)

-

- res = resolve_for try, Gem::List.prepend(specs, act)

-

- # While trying to resolve these dependencies, there may

- # be a conflict!

-

- if res.kind_of? Gem::DependencyResolver::DependencyConflict

- # The conflict might be created not by this invocation

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

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

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

- return res unless res.for_spec? s

-

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

- conflicts << [s, res]

-

- # Optimization:

- #

- # Because the conflict indicates the dependency that trigger

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

- #

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

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

- else

- # No conflict, return the specs

- return res

- end

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

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

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

- raise Gem::ImpossibleDependenciesError.new(dep, conflicts)

- specs

- end

- ##

- # Returns the gems in +specs+ that match the local platform.

- def select_local_platforms specs # :nodoc:

- specs.select do |spec|

- Gem::Platform.match spec.platform

- end

-end

-require 'rubygems/dependency_resolver/api_set'

-require 'rubygems/dependency_resolver/api_specification'

-require 'rubygems/dependency_resolver/activation_request'

-require 'rubygems/dependency_resolver/composed_set'

-require 'rubygems/dependency_resolver/current_set'

-require 'rubygems/dependency_resolver/dependency_conflict'

-require 'rubygems/dependency_resolver/dependency_request'

-require 'rubygems/dependency_resolver/index_set'

-require 'rubygems/dependency_resolver/index_specification'

-require 'rubygems/dependency_resolver/installed_specification'

-require 'rubygems/dependency_resolver/installer_set'

-

- ##

- #--

- # TODO: remove in RubyGems 3, nobody sets this

-

- attr_accessor :source_exception # :nodoc:

-

-# Raised by Gem::DependencyResolver when a Gem::DependencyConflict reaches the

-# toplevel. Indicates which dependencies were incompatible through #conflict

-# and #conflicting_dependencies

-

-class Gem::DependencyResolutionError < Gem::Exception

-

- attr_reader :conflict

-

- def initialize conflict

- @conflict = conflict

- a, b = conflicting_dependencies

-

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

- end

-

- def conflicting_dependencies

- @conflict.conflicting_dependencies

- end

-

-end

-

-##

-##

-# Raised by Gem::DependencyResolver when dependencies conflict and create the

-# inability to find a valid possible spec for a request.

-

-class Gem::ImpossibleDependenciesError < Gem::Exception

-

- attr_reader :conflicts

- attr_reader :request

-

- def initialize request, conflicts

- @request = request

- @conflicts = conflicts

-

- super build_message

- end

-

- def build_message # :nodoc:

- requester = @request.requester

- requester = requester ? requester.spec.full_name : 'The user'

- dependency = @request.dependency

-

- message = "#{requester} requires #{dependency} but it conflicted:\n"

-

- @conflicts.each do |_, conflict|

- message << conflict.explanation

- end

-

- message

- end

-

- def dependency

- @request.dependency

- end

-

-end

-

-##

-# Raised by DependencyResolver when a dependency requests a gem for which

-# there is no spec.

-

-class Gem::UnsatisfiableDependencyError < Gem::Exception

-

- attr_reader :dependency

-

- def initialize dep

- requester = dep.requester ? dep.requester.request : '(unknown)'

-

- super "Unable to resolve dependency: #{requester} requires #{dep}"

-

- @dependency = dep

- end

-

-end

-

-##

-# Backwards compatible typo'd exception class for early RubyGems 2.0.x

-

-Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError # :nodoc:

-

-require 'rubygems/user_interaction'

-require 'thread'

-

- include Gem::UserInteraction

-

- ##

- # The builder shells-out to run various commands after changing the

- # directory. This means multiple installations cannot be allowed to build

- # extensions in parallel as they may change each other's directories leading

- # to broken extensions or failed installations.

-

- CHDIR_MUTEX = Mutex.new # :nodoc:

-

- attr_accessor :build_args # :nodoc:

-

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

- ##

- # Creates a new extension builder for +spec+ using the given +build_args+.

- # The gem for +spec+ is unpacked in +gem_dir+.

-

- def initialize spec, build_args

- @spec = spec

- @build_args = build_args

- @gem_dir = spec.gem_dir

-

- @ran_rake = nil

- end

-

- ##

- # Chooses the extension builder class for +extension+

-

- def builder_for extension # :nodoc:

- case extension

- when /extconf/ then

- Gem::Ext::ExtConfBuilder

- when /configure/ then

- Gem::Ext::ConfigureBuilder

- when /rakefile/i, /mkrf_conf/i then

- @ran_rake = true

- Gem::Ext::RakeBuilder

- when /CMakeLists.txt/ then

- Gem::Ext::CmakeBuilder

- else

- extension_dir = File.join @gem_dir, File.dirname(extension)

-

- message = "No builder for extension '#{extension}'"

- build_error extension_dir, message

- end

- end

-

- ##

- # Logs the build +output+ in +build_dir+, then raises ExtensionBuildError.

-

- def build_error build_dir, output, backtrace = nil # :nodoc:

- gem_make_out = File.join build_dir, 'gem_make.out'

-

- open gem_make_out, 'wb' do |io| io.puts output end

-

- message = <<-EOF

-ERROR: Failed to build gem native extension.

-

- #{output}

-

-Gem files will remain installed in #{@gem_dir} for inspection.

-Results logged to #{gem_make_out}

-EOF

-

- raise Gem::Installer::ExtensionBuildError, message, backtrace

- end

-

- def build_extension extension, dest_path # :nodoc:

- results = []

-

- extension ||= '' # I wish I knew why this line existed

- extension_dir = File.join @gem_dir, File.dirname(extension)

-

- builder = builder_for extension

-

- begin

- FileUtils.mkdir_p dest_path

-

- CHDIR_MUTEX.synchronize do

- Dir.chdir extension_dir do

- results = builder.build(extension, @gem_dir, dest_path,

- results, @build_args)

-

- say results.join("\n") if Gem.configuration.really_verbose

- end

- end

- rescue

- build_error extension_dir, results.join("\n"), $@

- end

- end

-

- ##

- # Builds extensions. Valid types of extensions are extconf.rb files,

- # configure scripts and rakefiles or mkrf_conf files.

-

- def build_extensions

- return if @spec.extensions.empty?

-

- if @build_args.empty?

- say "Building native extensions. This could take a while..."

- else

- say "Building native extensions with: '#{@build_args.join ' '}'"

- say "This could take a while..."

- end

-

- dest_path = File.join @gem_dir, @spec.require_paths.first

-

- @ran_rake = false # only run rake once

-

- @spec.extensions.each do |extension|

- break if @ran_rake

-

- build_extension extension, dest_path

- end

- end

-

- def run args

- build_args = extract_build_args args

-

- ##

- # Separates the build arguments (those following <code>--</code>) from the

- # other arguments in the list.

-

- def extract_build_args args # :nodoc:

- return [] unless offset = args.index('--')

-

- build_args = args.slice!(offset...args.length)

-

- build_args.shift

-

- build_args

- end

-

-##

-# Utility methods for using the RubyGems API.

-

-

- attr_writer :host

-

- ##

- # The API key from the command options or from the user's configuration.

-

- ##

- # The host to connect to either from the RUBYGEMS_HOST environment variable

- # or from the user's configuration

-

- def host

- configured_host = Gem.host unless

- Gem.configuration.disable_default_gem_server

-

- @host ||=

- begin

- env_rubygems_host = ENV['RUBYGEMS_HOST']

- env_rubygems_host = nil if

- env_rubygems_host and env_rubygems_host.empty?

-

- env_rubygems_host|| configured_host

- end

- end

-

- ##

- # Creates an RubyGems API to +host+ and +path+ with the given HTTP +method+.

-

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

- require 'net/http'

-

- self.host = host if host

- unless self.host

- alert_error "You must specify a gem server"

- terminate_interaction 1 # TODO: question this

- end

-

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

-

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

-

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

- end

-

- ##

- # Signs in with the RubyGems API at +sign_in_host+ and sets the rubygems API

- # key.

-

- def sign_in sign_in_host = nil

- sign_in_host ||= self.host

- ##

- # Retrieves the pre-configured API key +key+ or terminates interaction with

- # an error.

- def verify_api_key(key)

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

- Gem.configuration.api_keys[key]

- else

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

- ##

- # If +response+ is an HTTP Success (2XX) response, yields the response if a

- # block was given or shows the response body to the user.

- #

- # If the response was not successful, shows an error to the user including

- # the +error_prefix+ and the response body.

-

- def with_response response, error_prefix = nil

- case response

- yield response

- say response.body

- message = response.body

-end

- raise OptionParser::InvalidArgument, 'OpenSSL not installed' unless

- defined?(Gem::Security::HighSecurity)

-

- # :format_executable:: Format the executable the same as the Ruby executable.

- # If your Ruby is ruby18, foo_exec will be installed as

- # to run a regexp against Ruby code.

- spec.loaded_from = spec_file

-

- if @options[:install_as_default]

- extract_bin

- write_default_spec

- else

- extract_files

- build_extensions

- write_build_info_file

- run_post_build_hooks

- generate_bin

- write_spec

- write_cache_file

- end

- # The location of of the default spec file for default gems.

- #

-

- def default_spec_file

- File.join gem_home, "specifications/default", "#{spec.full_name}.gemspec"

- end

-

- ##

- # Writes the full .gemspec specification (in Ruby) to the gem home's

- # specifications/default directory.

-

- def write_default_spec

- File.open(default_spec_file, "w") do |file|

- file.puts spec.to_ruby

- end

- end

-

- ##

- @install_dir = options[:install_dir]

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

- # return the stub script text used to launch the true Ruby script

- builder = Gem::Ext::Builder.new spec, @build_args

- builder.build_extensions

- #

- # TODO: Delete this for RubyGems 3. It remains for API compatibility

- def extension_build_error(build_dir, output, backtrace = nil) # :nodoc:

- builder = Gem::Ext::Builder.new spec, @build_args

- builder.build_error build_dir, output, backtrace

- # Extracts only the bin/ files from the gem into the gem directory.

- # This is used by default gems to allow a gem-aware stub to function

- # without the full gem installed.

-

- def extract_bin

- @package.extract_files gem_dir, "bin/*"

- end

-

- ##

- # repository is writable and its directories exist, required Ruby and

- if options[:install_as_default]

- Gem.ensure_default_gem_subdirectories gem_home

- else

- Gem.ensure_gem_subdirectories gem_home

- end

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

- # included if it is not the default Ruby platform. This mimics the behavior

- # of Gem::Specification#full_name.

-

- def full_name

- case @platform

- when nil, 'ruby', ''

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

- else

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

- end

- end

-

- ##

- "#{full_name}.gemspec"

- def inspect # :nodoc:

- alias to_s inspect # :nodoc:

-

-# #files are the files in the .gem tar file, not the Ruby files in the gem

- [Gem::Security::DIGEST_NAME].compact

- digester =

- if defined?(OpenSSL::Digest) then

- OpenSSL::Digest.new algorithm

- else

- Digest.const_get(algorithm).new

- end

- #

- # If +pattern+ is specified, only entries matching that glob will be

- # extracted.

- def extract_files destination_dir, pattern = "*"

- extract_tar_gz entry, destination_dir, pattern

- #

- # If +pattern+ is specified, only entries matching that glob will be

- # extracted.

- def extract_tar_gz io, destination_dir, pattern = "*" # :nodoc:

- # Some entries start with "./" which fnmatch does not like, see

- # issue #644

- full_name = entry.full_name.sub %r%\A\./%, ''

-

- next unless File.fnmatch pattern, full_name

-

- destination = install_location full_name, destination_dir

- passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']

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

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

- # Verifies +entry+ in a .gem file.

-

- def verify_entry entry

- file_name = entry.full_name

- @files << file_name

-

- case file_name

- when /\.sig$/ then

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

- return

- else

- digest entry

- end

-

- case file_name

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

- load_spec entry

- when 'data.tar.gz' then

- verify_gz entry

- end

- rescue => e

- message = "package is corrupt, exception while verifying: " +

- "#{e.message} (#{e.class})"

- raise Gem::Package::FormatError.new message, @gem

- end

-

- ##

- verify_entry entry

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

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

- def tar_dir_header(name, prefix, mode, mtime)

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

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

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

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

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

- util_entry tar_dir_header("foo", "bar", 0, Time.now)

-require 'digest'

-

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

- :mtime => Time.now

- digest_name =

- if digest.respond_to? :name then

- digest.name

- else

- /::([^:]+)$/ =~ digest_algorithm.name

- $1

- end

-

- [digest_name, digest]

- Digest::SHA512,

- ].compact.uniq

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

- digest_name =

- if digest.respond_to? :name then

- digest.name

- else

- /::([^:]+)$/ =~ digest.class.name

- $1

- end

-

- digest_name == signer.digest_name

- if signer.key then

- signature = signer.sign signature_digest.digest

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

- io.write signature

- end

- end

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

- :mtime => Time.now).to_s

- :prefix => prefix,

- :mtime => Time.now

- # Directory with spec cache

- attr_reader :spec_cache_dir # :nodoc:

-

- ##

-

- @spec_cache_dir =

- env["GEM_SPEC_CACHE"] || ENV["GEM_SPEC_CACHE"] ||

- Gem.default_spec_cache_dir

-

- @spec_cache_dir = @spec_cache_dir.dup.untaint

-#

-# See `gem help platform` for information on platform matching.

- #

- # Additionally, the platform will match if the local CPU is 'arm' and the

- # other CPU starts with "arm" (for generic ARM family support).

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

- (@cpu == 'arm' and other.cpu =~ /\Aarm/)) and

- # A pure-Ruby gem that may use Gem::Specification#extensions to build

- # A platform-specific gem that is built for the packaging Ruby's platform.

-module Psych # :nodoc:

-require 'rubygems/request'

-require 'rubygems/uri_formatter'

- @proxy = proxy

- source_path = Gem::UriFormatter.new(source_path).unescape

- request = Gem::Request.new uri, request_class, last_modified, @proxy

- request.fetch do |req|

- yield req if block_given?

-class Gem::RequestSet

- include TSort

- ##

- # Array of gems to install even if already installed

- attr_reader :always_install

-

- attr_reader :dependencies

-

- attr_accessor :development

-

- ##

- # Treat missing dependencies as silent errors

-

- attr_accessor :soft_missing

- def initialize *deps

- @dependencies = deps

- @always_install = []

- @development = false

- @requests = []

- @soft_missing = false

- @sorted = nil

- @specs = nil

- yield self if block_given?

- end

- ##

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

- def gem name, *reqs

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

- end

- ##

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

- def import deps

- @dependencies += deps

- end

- def install options, &block

- if dir = options[:install_dir]

- return install_into dir, false, options, &block

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

- specs = []

- sorted_requests.each do |req|

- if req.installed? and

- @always_install.none? { |spec| spec == req.spec.spec } then

- yield req, nil if block_given?

- next

- path = req.download cache_dir

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

- yield req, inst if block_given?

- specs << inst.install

- end

- specs

- end

- def install_into dir, force = true, options = {}

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

- existing.delete_if { |s| @always_install.include? s }

- dir = File.expand_path dir

- installed = []

- sorted_requests.each do |req|

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

- yield req, nil if block_given?

- next

- path = req.download(dir)

- unless path then # already installed

- yield req, nil if block_given?

- next

- options[:install_dir] = dir

- options[:only_install_dir] = true

-

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

- yield req, inst if block_given?

- inst.install

- installed << req

- end

- installed

- end

- ##

- # Load a dependency management file.

- def load_gemdeps path

- gf = Gem::RequestSet::GemDepedencyAPI.new self, path

- gf.load

- end

- ##

- # Resolve the requested dependencies and return an Array of Specification

- # objects to be activated.

- def resolve set = nil

- resolver = Gem::DependencyResolver.new @dependencies, set

- resolver.development = @development

- resolver.soft_missing = @soft_missing

- @requests = resolver.resolve

- end

- ##

- # Resolve the requested dependencies against the gems available via Gem.path

- # and return an Array of Specification objects to be activated.

- def resolve_current

- resolve Gem::DependencyResolver::CurrentSet.new

- end

- def sorted_requests

- @sorted ||= strongly_connected_components.flatten

- end

- def specs

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

- end

-

- def specs_in dir

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

- Gem::Specification.load g

- end

- end

- def tsort_each_node &block # :nodoc:

- @requests.each(&block)

- end

- def tsort_each_child node # :nodoc:

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

- next if dep.type == :development and not @development

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

- if match

- begin

- yield match

- rescue TSort::Cyclic

- end

- else

- unless @soft_missing

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

- end

-

-

-require 'rubygems/request_set/gem_dependency_api'

- DIGEST_ALGORITHM =

- if defined?(OpenSSL::Digest) then

- OpenSSL::Digest::SHA1

- end

- DIGEST_NAME = # :nodoc:

- if DIGEST_ALGORITHM then

- DIGEST_ALGORITHM.new.name

- end

- KEY_ALGORITHM =

- if defined?(OpenSSL::PKey) then

- OpenSSL::PKey::RSA

- end

- # Cipher used to encrypt the key pair used to sign gems.

- # Must be in the list returned by OpenSSL::Cipher.ciphers

-

- KEY_CIPHER = OpenSSL::Cipher.new('AES-256-CBC') if defined?(OpenSSL::Cipher)

-

- ##

- # +permissions+. If passed +cipher+ and +passphrase+ those arguments will be

- # passed to +to_pem+.

- def self.write pemmable, path, permissions = 0600, passphrase = nil, cipher = KEY_CIPHER

- if passphrase and cipher

- io.write pemmable.to_pem cipher, passphrase

- else

- io.write pemmable.to_pem

- end

-if defined?(OpenSSL::SSL) then

- require 'rubygems/security/policy'

- require 'rubygems/security/policies'

- require 'rubygems/security/trust_dir'

-end

-

-require 'rubygems/user_interaction'

-

- include Gem::UserInteraction

-

- ##

- # Extracts the email or subject from +certificate+

-

- def subject certificate # :nodoc:

- certificate.extensions.each do |extension|

- next unless extension.oid == 'subjectAltName'

-

- return extension.value

- end

-

- certificate.subject.to_s

- end

-

- # For +full_name+, verifies the certificate +chain+ is valid, the +digests+

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

- # +policy+ settings.

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

- full_name = '(unknown)'

- if signatures.empty? then

- if @only_signed then

- raise Gem::Security::Exception,

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

- elsif digests.empty? then

- # lack of signatures is irrelevant if there is nothing to check

- # against

- else

- alert_warning "#{full_name} is not signed"

- end

- if @only_trusted then

- check_trust chain, digester, trust_dir

- elsif signatures.empty? and digests.empty? then

- # trust is irrelevant if there's no signatures to verify

- else

- alert_warning "#{subject signer} is not trusted for #{full_name}"

- end

- verify chain, nil, digests, signatures, spec.full_name

- def initialize key, cert_chain, passphrase = nil

- @key = OpenSSL::PKey::RSA.new File.read(@key), passphrase if

- # Extracts the full name of +cert+. If the certificate has a subjectAltName

- # this value is preferred, otherwise the subject is used.

-

- def extract_name cert # :nodoc:

- subject_alt_name = cert.extensions.find { |e| 'subjectAltName' == e.oid }

-

- if subject_alt_name then

- /\Aemail:/ =~ subject_alt_name.value

-

- $' || subject_alt_name.value

- else

- cert.subject

- end

- end

-

- ##

- full_name = extract_name @cert_chain.last

-

- Gem::Security::SigningPolicy.verify @cert_chain, @key, {}, {}, full_name

- # === Additional trick - install documentation for Ruby core

- # 1. install Ruby sources

- # This allows additional documentation folders like 'core' for the Ruby core

- case other

- when Gem::Source::Installed,

- Gem::Source::Local,

- Gem::Source::SpecificFile then

- -1

- when Gem::Source then

- if !@uri

- return 0 unless other.uri

- return 1

- end

- return -1 if !other.uri

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

- else

- nil

- end

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

-

- def pretty_print q # :nodoc:

- q.group 2, '[Remote:', ']' do

- q.breakable

- q.text @uri.to_s

- end

- end

-

-

-require 'rubygems/source/installed'

-require 'rubygems/source/specific_file'

-require 'rubygems/source/local'

-require 'rubygems/source_local'

-# TODO warn upon require, this file is deprecated.

-require 'rubygems/source/specific_file'

-# TODO warn upon require, this file is deprecated.

- if dependency.name.is_a?(String) && specs.respond_to?(:bsearch)

- start_index = (0 ... specs.length).bsearch{ |i| specs[i].name >= dependency.name }

- end_index = (0 ... specs.length).bsearch{ |i| specs[i].name > dependency.name }

- specs = specs[start_index ... end_index] if start_index && end_index

- end

-

- names =

- tuples_for(source, :prerelease, true) +

-

- names.sort

- tuples =

- raise unless gracefully_ignore

-

- tuples.sort_by { |tup| tup.name }

-

-require 'rubygems/basic_specification'

-require 'rubygems/stub_specification'

-# Starting in RubyGems 2.0, a Specification can hold arbitrary

-class Gem::Specification < Gem::BasicSpecification

- LOAD_CACHE = {}

-

- private_constant :LOAD_CACHE if defined? private_constant

-

- Dupable = { }

-

- @@default_value.each do |k,v|

- case v

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

- Dupable[k] = false

- else

- Dupable[k] = true

- end

- end

-

- # found in bindir. These files must be executable Ruby files. Files that

- # The version of Ruby required by this gem

- def self._all # :nodoc:

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

- @@all = stubs.map(&:to_spec)

-

- # After a reset, make sure already loaded specs

- # are still marked as activated.

- specs = {}

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

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

-

- _resort!(@@all)

- @@all

- end

- def self._clear_load_cache # :nodoc:

- LOAD_CACHE.clear

- end

-

- # :nodoc:

- def self.each_gemspec(dirs)

- dirs.each do |dir|

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

- yield path.untaint

- end

- end

- # :nodoc:

- def self.each_stub(dirs)

- each_gemspec(dirs) do |path|

- stub = Gem::StubSpecification.new(path)

- yield stub if stub.valid?

- end

- # :nodoc:

- def self.each_spec(dirs)

- each_gemspec(dirs) do |path|

- spec = self.load path

- yield spec if spec

- ##

- # Returns a Gem::StubSpecification for every installed gem

- def self.stubs

- @@stubs ||= begin

- stubs = {}

- each_stub([default_specifications_dir] + dirs) do |stub|

- stubs[stub.full_name] ||= stub

- stubs = stubs.values

- _resort!(stubs)

- stubs

- def self._resort!(specs) # :nodoc:

- specs.sort! { |a, b|

- each_spec([default_specifications_dir]) do |spec|

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

- # it at this stage

- stubs << spec

- _resort!(_all)

- _resort!(stubs)

- @@all = @@stubs = specs

- stub = stubs.find { |s|

- s.contains_requirable_file? path unless s.activated?

- stub && stub.to_spec

- }.sort_by{ |tup| tup.name }

- spec = LOAD_CACHE[file]

- return spec if spec

-

- LOAD_CACHE[file] = spec

- # Return a list of all outdated local gem names. This method is HEAVY

- #

- # Use outdated_and_latest_version if you wish to retrieve the latest remote

- # version as well.

- outdated_and_latest_version.map { |local, _| local.name }

- end

-

- ##

- # Enumerates the outdated local gems yielding the local specification and

- # the latest remote version.

- #

- # This method may take some time to return as it must check each local gem

- # against the server's index.

-

- def self.outdated_and_latest_version

- return enum_for __method__ unless block_given?

- latest_specs(true).each do |local_spec|

- dependency =

- Gem::Dependency.new local_spec.name, ">= #{local_spec.version}"

- remotes, = fetcher.search_for_dependency dependency

- remotes = remotes.map { |n, _| n.version }

-

- latest_remote = remotes.sort.last

-

- yield [local_spec, latest_remote] if

- latest_remote and local_spec.version < latest_remote

- nil

- stubs.delete_if { |s| s.full_name == spec.full_name }

- @@stubs = nil

- _clear_load_cache

- # :nodoc:

- def find_full_gem_path

- super || File.expand_path(File.join(gems_dir, original_name))

- private :find_full_gem_path

- @full_name ||= super

- name.hash ^ version.hash

- self.loaded_from = nil

- value = Dupable[key] ? default.dup : default

- def loaded_from= path # :nodoc:

- super

- def respond_to_missing? m, include_private = false # :nodoc:

- false

- end

-

- # Used by Gem::DependencyResolver to order Gem::Specification objects

-

- def source # :nodoc:

- self

- end

-

- ##

- result << "#{Gem::StubSpecification::PREFIX}#{name} #{version} #{platform} #{require_paths.join("\0")}"

- ##

- # Returns self

-

- def to_spec

- self

- end

-

- # Allows setting path to Ruby. This method is available when requiring

- def assert_activate expected, *specs

- specs.each do |spec|

- case spec

- when String then

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

- when Gem::Specification then

- spec.activate

- else

- flunk spec.inspect

- end

- end

-

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

-

- assert_equal expected.sort, loaded.sort if expected

- end

-

- ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache'

- ruby = Gem.ruby

- Gem.ruby = ENV['RUBY']

- @orig_gem_private_key_passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']

- ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = PRIVATE_KEY_PASSPHRASE

-

- Gem.ruby = @orig_ruby if @orig_ruby

-

- ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = @orig_gem_private_key_passphrase

-

- Gem::Specification._clear_load_cache

- end

-

- def common_installer_setup

- common_installer_teardown

-

- Gem.post_build do |installer|

- @post_build_hook_arg = installer

- true

- end

-

- Gem.post_install do |installer|

- @post_install_hook_arg = installer

- end

-

- Gem.post_uninstall do |uninstaller|

- @post_uninstall_hook_arg = uninstaller

- end

-

- Gem.pre_install do |installer|

- @pre_install_hook_arg = installer

- true

- end

-

- Gem.pre_uninstall do |uninstaller|

- @pre_uninstall_hook_arg = uninstaller

- end

- end

-

- def common_installer_teardown

- Gem.post_build_hooks.clear

- Gem.post_install_hooks.clear

- Gem.done_installing_hooks.clear

- Gem.post_reset_hooks.clear

- Gem.post_uninstall_hooks.clear

- Gem.pre_install_hooks.clear

- Gem.pre_reset_hooks.clear

- Gem.pre_uninstall_hooks.clear

- def loaded_spec_names

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

- end

-

- def unresolved_names

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

- end

-

- def save_loaded_features

- old_loaded_features = $LOADED_FEATURES.dup

- yield

- ensure

- $LOADED_FEATURES.replace old_loaded_features

- end

-

- @x = quick_gem('x', '1', &init)

- write_file File.join(*%W[gems #{@a1.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@a2.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@a3a.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@a_evil9.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@b2.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@c1_2.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@pl1.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@x.original_name} lib code.rb])

- write_file File.join(*%W[gems #{@dep_x.original_name} lib code.rb])

- # Finds the path to the Ruby executable

- # Constructs a Gem::DependencyResolver::DependencyRequest from a

- # Gem::Dependency +dep+, a +from_name+ and +from_version+ requesting the

- # dependency and a +parent+ DependencyRequest

-

- def dependency_request dep, from_name, from_version, parent = nil

- remote = Gem::Source.new @uri

-

- parent ||= Gem::DependencyResolver::DependencyRequest.new \

- dep, nil

-

- spec = Gem::DependencyResolver::IndexSpecification.new \

- nil, from_name, from_version, remote, Gem::Platform::RUBY

- activation = Gem::DependencyResolver::ActivationRequest.new spec, parent

-

- Gem::DependencyResolver::DependencyRequest.new dep, activation

- end

-

- ##

- @specs = specs

- end

-

- def add spec

- @specs << spec

- def load_spec name, ver, platform, source

- dep = Gem::Dependency.new name, ver

- spec = find_spec dep

-

- Gem::Specification.new spec.name, spec.version do |s|

- s.platform = spec.platform

- end

- end

-

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

- def self.load_key key_name, passphrase = nil

- OpenSSL::PKey::RSA.new key, passphrase

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

- PRIVATE_KEY_PASSPHRASE = 'Foo bar'

-

- PRIVATE_KEY = load_key 'private'

- PRIVATE_KEY_PATH = key_path 'private'

- # ENCRYPTED_PRIVATE_KEY is PRIVATE_KEY encrypted with PRIVATE_KEY_PASSPHRASE

- ENCRYPTED_PRIVATE_KEY = load_key 'encrypted_private', PRIVATE_KEY_PASSPHRASE

- ENCRYPTED_PRIVATE_KEY_PATH = key_path 'encrypted_private'

-

- PUBLIC_KEY = PRIVATE_KEY.public_key

-

- PUBLIC_CERT = load_cert 'public'

- PUBLIC_CERT_PATH = cert_path 'public'

- end if defined?(OpenSSL::SSL)

- @gem = gem

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

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

- @force_executables = options[:executables]

- @force_all = options[:all]

- @force_ignore = options[:ignore]

- @bin_dir = options[:bin_dir]

- @format_executable = options[:format_executable]

- @abort_on_dependent = options[:abort_on_dependent]

- if abort_on_dependent? || !ask_if_ok(spec)

- def abort_on_dependent?

- @abort_on_dependent

- end

-

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

- def version

- @version.dup

- end

-

- @@all = {}

-

- def self.new version

- @@all[version] ||= super

- end

-

- @version = version.to_s.strip.gsub("-",".pre.")

- @segments = nil

- options[:explicit_prerelease] = true

- Gem::Requirement.new(*value.split(/\s*,\s*/))

-

- explicit_prerelease_set = !options[:explicit_prerelease].nil?

- options[:explicit_prerelease] = false unless explicit_prerelease_set

-

- options[:prerelease] = value.prerelease? unless

- options[:explicit_prerelease]

-

------BEGIN CERTIFICATE-----

-MIIDtTCCAp2gAwIBAgIJANz6ehBcVuuiMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV

-BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX

-aWRnaXRzIFB0eSBMdGQwHhcNMTMwNTAxMTQ0NTQxWhcNMjMwMzEwMTQ0NTQxWjBF

-MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50

-ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB

-CgKCAQEAzlpZwhEYoALOEKU4lmMw5l3YI/gadzDOoELtdcidvVvovKK8IIOTDwbA

-3XcjwV0UPGEPOK4Uk1aD0EKkOQVg8ivSre2a3FFGffs2kXck+doJMzAA+pf8tvFk

-QsETVOurOp74GN+er2xbbRSDVxQKq6d+QTe1E60btyXQS5M1Nt5SvLn8dazZJgvv

-3yzJQ1IOQl+xeEO0WVVhPIx5Mx3VtjjcDyl8aewPkYkzia6UOrAyQZnl5sIzWGOb

-kYKCNeKjTPepzlbMx0dN6jBupPYGNB+4FYY9GezInjGbRP5np5382wd3EWwsVzic

-Nau8kXHTL2r7GzNvoy0p//iPCqx9FQIDAQABo4GnMIGkMB0GA1UdDgQWBBS7B027

-H/ZIkW3ngm1SrR0X/aTCwDB1BgNVHSMEbjBsgBS7B027H/ZIkW3ngm1SrR0X/aTC

-wKFJpEcwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNV

-BAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZIIJANz6ehBcVuuiMAwGA1UdEwQF

-MAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAC0glUrUiylTfuOWlwkQvi74oiYC5CzW

-Jfusg6o/Gg1XEuJhaHiYMsK/do16gSc6Za3934rHQbYu3mesyFkCWF9kD4J6/hEO

-OQL8xmmgN7wS6GXy6oIODpny0MgnFrV4gd1aEx69NIfL/wXaM8Gw2sj1TnuGLs8+

-HFmWLRRH3WSR7ZLnqYzPVJwhHu8vtZBL9HZk1J6xyq00Nwi2Cz5WdiHamgaza3TS

-OgBdWwDeSClwhrTJni4d30dbq+eNMByIZ7QNGBQivpFzDxeNV/2UBrTU0CilKG5Q

-j7ZwknfKeA4xUTd8TMK3vKab5JJCfjbXOTHZQsYUcEEGSjOMS8/YVQs=

------END CERTIFICATE-----

- PLUGINS_LOADED = []

-

- PLUGINS_LOADED.clear

-

- common_installer_setup

-

- Gem.refresh

- def test_self_find_latest_files

- cwd = File.expand_path("test/rubygems", @@project_dir)

- $LOAD_PATH.unshift cwd

-

- discover_path = File.join 'lib', 'sff', 'discover.rb'

-

- _, foo2 = %w(1 2).map { |version|

- spec = quick_gem 'sff', version do |s|

- s.files << discover_path

- end

-

- write_file(File.join 'gems', spec.full_name, discover_path) do |fp|

- fp.puts "# #{spec.full_name}"

- end

-

- spec

- }

-

- Gem.refresh

-

- expected = [

- File.expand_path('test/rubygems/sff/discover.rb', @@project_dir),

- File.join(foo2.full_gem_path, discover_path),

- ]

-

- assert_equal expected, Gem.find_latest_files('sff/discover')

- assert_equal expected, Gem.find_latest_files('sff/**.rb'), '[ruby-core:31730]'

- ensure

- assert_equal cwd, $LOAD_PATH.shift

- end

-

- fp.puts "class TestGem; PLUGINS_LOADED << 'plugin'; end"

- end

-

- foo1 = quick_spec 'foo', '1' do |s|

- s.files << plugin_path

- install_gem foo1

-

- foo2 = quick_spec 'foo', '2' do |s|

- install_gem foo2

- assert_equal %w[plugin], PLUGINS_LOADED

- def test_register_default_spec

- Gem.clear_default_specs

-

- old_style = Gem::Specification.new do |spec|

- spec.files = ["foo.rb", "bar.rb"]

- end

-

- Gem.register_default_spec old_style

-

- assert_equal old_style, Gem.find_unresolved_default_spec("foo.rb")

- assert_equal old_style, Gem.find_unresolved_default_spec("bar.rb")

- assert_equal nil, Gem.find_unresolved_default_spec("baz.rb")

-

- Gem.clear_default_specs

-

- new_style = Gem::Specification.new do |spec|

- spec.files = ["lib/foo.rb", "ext/bar.rb", "bin/exec", "README"]

- spec.require_paths = ["lib", "ext"]

- end

-

- Gem.register_default_spec new_style

-

- assert_equal new_style, Gem.find_unresolved_default_spec("foo.rb")

- assert_equal new_style, Gem.find_unresolved_default_spec("bar.rb")

- assert_equal nil, Gem.find_unresolved_default_spec("exec")

- assert_equal nil, Gem.find_unresolved_default_spec("README")

- end

-

- def test_default_gems_use_full_paths

- begin

- if defined?(RUBY_ENGINE) then

- engine = RUBY_ENGINE

- Object.send :remove_const, :RUBY_ENGINE

- end

- Object.const_set :RUBY_ENGINE, 'ruby'

-

- refute Gem.default_gems_use_full_paths?

- ensure

- Object.send :remove_const, :RUBY_ENGINE

- Object.const_set :RUBY_ENGINE, engine if engine

- end

-

- begin

- if defined?(RUBY_ENGINE) then

- engine = RUBY_ENGINE

- Object.send :remove_const, :RUBY_ENGINE

- end

- Object.const_set :RUBY_ENGINE, 'jruby'

- assert Gem.default_gems_use_full_paths?

- ensure

- Object.send :remove_const, :RUBY_ENGINE

- Object.const_set :RUBY_ENGINE, engine if engine

- end

- end

-

- @command_manager.run %w[interrupt]

- @command_manager.run %w[crash]

- @command_manager.process_args %w[--bad-arg]

- @command_manager.process_args %w[install]

- @command_manager.process_args %w[

- install --force --local --rdoc --install-dir .

- --version 3.0 --no-wrapper --bindir .

- ]

- @command_manager.process_args %w[install --remote]

- @command_manager.process_args %w[install --both]

- @command_manager.process_args %w[install --both]

- @command_manager.process_args %w[uninstall]

- @command_manager.process_args %w[uninstall foobar --version 3.0]

- @command_manager.process_args %w[check]

- @command_manager.process_args %w[check foobar --alien]

- @command_manager.process_args %w[build]

- @command_manager.process_args %w[build foobar.rb]

- @command_manager.process_args %w[query]

- @command_manager.process_args %w[query --name foobar --local --details]

- @command_manager.process_args %w[query --remote]

- @command_manager.process_args %w[query --both]

- @command_manager.process_args %w[update]

- @command_manager.process_args %w[update --force --rdoc --install-dir .]

-unless defined?(OpenSSL::SSL) then

- warn 'Skipping `gem cert` tests. openssl not found.'

- passphrase = 'Foo bar'

-

- @build_ui = Gem::MockGemUi.new "#{passphrase}\n#{passphrase}"

-

- use_ui @build_ui do

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

- assert_equal "Passphrase for your Private Key: ",

- output.shift

- assert_equal "Please repeat the passphrase for your Private Key: ",

- output.shift

- assert_empty @build_ui.error

- def test_execute_build_bad_passphrase_confirmation

- passphrase = 'Foo bar'

- passphrase_confirmation = 'Fu bar'

-

- @cmd.handle_options %W[--build [email protected]]

-

- @build_ui = Gem::MockGemUi.new "#{passphrase}\n#{passphrase_confirmation}"

-

- use_ui @build_ui do

- e = assert_raises Gem::CommandLineError do

- @cmd.execute

- end

-

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

-

- assert_equal "Passphrase for your Private Key: ",

- output.shift

- assert_equal "Please repeat the passphrase for your Private Key: ",

- output.shift

-

- assert_empty output

-

- assert_equal "Passphrase and passphrase confirmation don't match",

- e.message

-

- end

-

- refute_path_exists File.join(@tempdir, 'gem-private_key.pem')

- refute_path_exists File.join(@tempdir, 'gem-public_cert.pem')

- end

-

- assert_empty output

- assert_empty @ui.error

-

- assert_path_exists File.join(@tempdir, 'gem-public_cert.pem')

- end

-

- def test_execute_build_encrypted_key

- @cmd.handle_options %W[

- --build [email protected]

- --private-key #{ENCRYPTED_PRIVATE_KEY_PATH}

- ]

-

- use_ui @ui do

- @cmd.execute

- end

-

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

-

- assert_equal "Certificate: #{File.join @tempdir, 'gem-public_cert.pem'}",

- def test_execute_encrypted_private_key

- use_ui @ui do

- @cmd.send :handle_options, %W[--private-key #{ENCRYPTED_PRIVATE_KEY_PATH}]

- end

-

- assert_equal '', @ui.output

- assert_equal '', @ui.error

-

- assert_equal ENCRYPTED_PRIVATE_KEY.to_pem, @cmd.options[:key].to_pem

- end

-

- def test_execute_sign_encrypted_key

- path = File.join @tempdir, 'cert.pem'

- Gem::Security.write ALTERNATE_CERT, path, 0600

-

- assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s

-

- @cmd.handle_options %W[

- --private-key #{ENCRYPTED_PRIVATE_KEY_PATH}

- --certificate #{PUBLIC_CERT_FILE}

-

- --sign #{path}

- ]

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_equal '', @ui.output

- assert_equal '', @ui.error

-

- cert = OpenSSL::X509::Certificate.new File.read path

-

- assert_equal '/CN=nobody/DC=example', cert.issuer.to_s

-

- mask = 0100600 & (~File.umask)

-

- assert_equal mask, File.stat(path).mode unless win_platform?

- end

-

- def test_execute_sign_default_encrypted_key

- FileUtils.mkdir_p File.join(Gem.user_home, '.gem')

-

- private_key_path = File.join Gem.user_home, '.gem', 'gem-private_key.pem'

- Gem::Security.write ENCRYPTED_PRIVATE_KEY, private_key_path, 0600, PRIVATE_KEY_PASSPHRASE

-

- public_cert_path = File.join Gem.user_home, '.gem', 'gem-public_cert.pem'

- Gem::Security.write PUBLIC_CERT, public_cert_path

-

- path = File.join @tempdir, 'cert.pem'

- Gem::Security.write ALTERNATE_CERT, path, 0600

-

- assert_equal '/CN=alternate/DC=example', ALTERNATE_CERT.issuer.to_s

-

- @cmd.handle_options %W[--sign #{path}]

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_equal '', @ui.output

- assert_equal '', @ui.error

-

- cert = OpenSSL::X509::Certificate.new File.read path

-

- assert_equal '/CN=nobody/DC=example', cert.issuer.to_s

-

- mask = 0100600 & (~File.umask)

-

- assert_equal mask, File.stat(path).mode unless win_platform?

- end

-

- def test_handle_options_sign_encrypted_key

- @cmd.handle_options %W[

- --private-key #{ALTERNATE_KEY_FILE}

- --private-key #{ENCRYPTED_PRIVATE_KEY_PATH}

-

- --certificate #{ALTERNATE_CERT_FILE}

- --certificate #{PUBLIC_CERT_FILE}

-

- --sign #{ALTERNATE_CERT_FILE}

- --sign #{CHILD_CERT_FILE}

- ]

-

- assert_equal ENCRYPTED_PRIVATE_KEY.to_pem, @cmd.options[:key].to_pem

- assert_equal PUBLIC_CERT.to_pem, @cmd.options[:issuer_cert].to_pem

-

- assert_equal [ALTERNATE_CERT_FILE, CHILD_CERT_FILE], @cmd.options[:sign]

- end

-

-end if defined?(OpenSSL::SSL)

- def test_handle_options_d

- @cmd.handle_options %w[-d]

- assert @cmd.options[:dryrun]

- end

-

- def test_handle_options_dry_run

- @cmd.handle_options %w[--dryrun]

- assert @cmd.options[:dryrun]

- end

-

- def test_handle_options_n

- @cmd.handle_options %w[-n]

- assert @cmd.options[:dryrun]

- end

-

- def test_execute_missing_single

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

-

- assert_raises Gem::MockGemUi::TermError do

- use_ui @ui do

- @cmd.execute

- end

- end

-

- assert_match "Unable to find gem 'foo'", @ui.output

- assert_empty @ui.error

- end

-

- def test_execute_missing_multiple

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

-

- gem 'foo'

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_match "lib/foo.rb", @ui.output

- assert_match "Unable to find gem 'bar'", @ui.output

-

- assert_empty @ui.error

- end

-

- expected = [

- File.join(Gem::ConfigMap[:bindir], 'default_command'),

- File.join(Gem::ConfigMap[:rubylibdir], 'default/gem.rb'),

- File.join(Gem::ConfigMap[:archdir], 'default_gem.so')

- orig_path, ENV['PATH'] = ENV['PATH'], %w[/usr/local/bin /usr/bin /bin].join(File::PATH_SEPARATOR)

-

- assert_match %r|- SHELL PATH:|, @ui.output

- assert_match %r|- /usr/local/bin$|, @ui.output

- assert_match %r|- /usr/bin$|, @ui.output

- assert_match %r|- /bin$|, @ui.output

-

- assert_empty @ui.error

- ENV['PATH'] = orig_path

- def test_execute_latest

- util_setup_fake_fetcher

- util_setup_spec_fetcher @a1, @a2

-

- @fetcher.data["#{@gem_repo}gems/#{@a1.file_name}"] =

- File.read(@a1.cache_file)

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

- File.read(@a2.cache_file)

-

- refute_path_exists File.join(@tempdir, 'cache'), 'sanity check'

-

- @cmd.options[:args] = [@a2.name]

- @cmd.options[:version] = req('>= 0.1')

-

- use_ui @ui do

- Dir.chdir @tempdir do

- @cmd.execute

- end

- end

-

- assert_path_exists(File.join(@tempdir, @a2.file_name),

- "#{@a2.full_name} not fetched")

- refute_path_exists File.join(@tempdir, 'cache'),

- 'gem repository directories must not be created'

- end

-

- assert_path_exists(File.join(@tempdir, @a2.file_name),

- "#{@a2.full_name} not fetched")

- assert_match "Unknown command bad", err

- if defined?(OpenSSL::SSL) then

- assert_empty err

-

- refute_match 'No command found for ', out

- end

- common_installer_setup

- path = File.join Gem.spec_cache_dir, "not-there.nothing%80", "latest_specs.4.8"

- ENV["RUBYGEMS_HOST"] = nil

- def test_show_owners_setting_up_host_through_env_var

- response = "- email: [email protected]\n"

- host = "http://rubygems.example"

- ENV["RUBYGEMS_HOST"] = host

-

- @fetcher.data["#{host}/api/v1/gems/freewill/owners.yaml"] = [response, 200, 'OK']

-

- use_ui @ui do

- @cmd.show_owners("freewill")

- end

-

- assert_match %r{Owners for gem: freewill}, @ui.output

- assert_match %r{- [email protected]}, @ui.output

- end

-

- def test_show_owners_setting_up_host

- response = "- email: [email protected]\n"

- host = "http://rubygems.example"

- @cmd.host = host

-

- @fetcher.data["#{host}/api/v1/gems/freewill/owners.yaml"] = [response, 200, 'OK']

-

- use_ui @ui do

- @cmd.show_owners("freewill")

- end

-

- assert_match %r{Owners for gem: freewill}, @ui.output

- assert_match %r{- [email protected]}, @ui.output

- end

-

- def test_add_owner_with_host_option_through_execute

- host = "http://rubygems.example"

- add_owner_response = "Owner added successfully."

- show_owners_response = "- email: [email protected]\n"

- @fetcher.data["#{host}/api/v1/gems/freewill/owners"] = [add_owner_response, 200, 'OK']

- @fetcher.data["#{host}/api/v1/gems/freewill/owners.yaml"] = [show_owners_response, 200, 'OK']

-

- @cmd.handle_options %W[--host #{host} --add [email protected] freewill]

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_match add_owner_response, @ui.output

- assert_match %r{Owners for gem: freewill}, @ui.output

- assert_match %r{- [email protected]}, @ui.output

- end

-

- def test_execute_env_shebang

- a = quick_spec 'a' do |s|

- s.executables = %w[foo]

- s.files = %w[bin/foo]

- end

- write_file File.join(@tempdir, 'bin', 'foo') do |fp|

- fp.puts "#!/usr/bin/ruby"

- end

-

- install_gem a

-

- gem_exec = File.join @gemhome, 'bin', 'foo'

-

- FileUtils.rm gem_exec

-

- @cmd.handle_options %w[--all --env-shebang]

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_path_exists gem_exec

-

- if win_platform?

- assert_match %r%\A#!\s*ruby%, File.read(gem_exec)

- else

- assert_match %r%\A#!\s*/usr/bin/env ruby%, File.read(gem_exec)

- end

- end

-

- dir = Gem.spec_cache_dir

- def test_execute_all_gem_names

- @cmd.options[:args] = %w[a b]

- @cmd.options[:all] = true

-

- assert_raises Gem::MockGemUi::TermError do

- use_ui @ui do

- @cmd.execute

- end

- end

-

- assert_match(/\A(?:WARNING: Unable to use symlinks on Windows, installing wrapper\n)?ERROR: Gem names and --all may not be used together\n\z/,

- @ui.error)

- end

-

-

- def test_execute_all

- util_make_gems

-

- default = new_default_spec 'default', '1'

- install_default_gems default

-

- gemhome2 = "#{@gemhome}2"

-

- a_4 = quick_spec 'a', 4

- install_gem a_4, :install_dir => gemhome2

-

- Gem::Specification.dirs = [@gemhome, gemhome2]

-

- assert_includes Gem::Specification.all_names, 'a-1'

- assert_includes Gem::Specification.all_names, 'a-4'

- assert_includes Gem::Specification.all_names, 'default-1'

-

- @cmd.options[:all] = true

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

-

- use_ui @ui do

- @cmd.execute

- end

-

- assert_equal %w[a-4 default-1], Gem::Specification.all_names.sort

- end

-

- common_installer_setup

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

-To fix this error run:

-

-\tchmod 0600 #{@cfg.credentials_path}

-

- def test_load_ssl_client_cert_from_config

- File.open @temp_conf, 'w' do |fp|

- fp.puts ":ssl_client_cert: /home/me/mine.pem"

- end

- util_config_file

- assert_equal('/home/me/mine.pem', @cfg.ssl_client_cert)

- end

-

- common_installer_setup

- FileUtils.mv e1_gem, @tempdir

-

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

- 'sanity check'

-

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

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

- inst.install 'a', req("= 2")

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

- 'sanity check'

-

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

- FileUtils.mv a3_gem, @tempdir

- Gem::DependencyInstaller.new.install 'a', req("= 2")

- inst = nil

-

- def test_install_minimal_deps

- util_setup_gems

-

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

- s.add_dependency 'b'

- end

-

- _, b2_gem = util_gem 'b', '2' do |s|

- s.add_dependency 'a'

- end

-

- util_clear_gems

-

- FileUtils.mv @a1_gem, @tempdir

- FileUtils.mv @b1_gem, @tempdir

- FileUtils.mv b2_gem, @tempdir

- FileUtils.mv e1_gem, @tempdir

-

- inst = nil

-

- Dir.chdir @tempdir do

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

- inst.install 'b', req('= 1')

- end

-

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

- 'sanity check'

-

- Dir.chdir @tempdir do

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

- inst.install 'e'

- end

-

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

- end

-

- e = assert_raises Gem::UnsatisfiableDependencyError do

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

-

- remote, local = gems

-

- msg = "Set of gems was not the same: #{exp.map { |x| x.full_name}.inspect} != #{act.map { |x| x.full_name}.inspect}"

-

- assert_equal exp, act, msg

- def test_picks_best_platform

- is = Gem::DependencyResolver::IndexSpecification

- unknown = Gem::Platform.new 'unknown'

- a2_p1 = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end

- a3_p2 = quick_spec 'a', 3 do |s| s.platform = unknown end

- v2 = v(2)

- v3 = v(3)

- source = Gem::Source.new @gem_repo

-

- s = set

-

- a2 = is.new s, 'a', v2, source, Gem::Platform::RUBY

- a2_p1 = is.new s, 'a', v2, source, Gem::Platform.local.to_s

- a3_p2 = is.new s, 'a', v3, source, unknown

-

- s.add a3_p2

- s.add a2_p1

- s.add a2

-

- ad = make_dep "a"

-

- res = Gem::DependencyResolver.new([ad], s)

-

- assert_set [a2_p1], res.resolve

- end

-

- assert_equal "Unable to resolve dependency: (unknown) requires a (>= 0)",

- e.message

- assert_match "a-1 requires c (>= 2) but it conflicted", e.message

-

- def test_select_local_platforms

- r = Gem::DependencyResolver.new nil, nil

-

- a1 = quick_spec 'a', 1

- a1_p1 = quick_spec 'a', 1 do |s| s.platform = Gem::Platform.local end

- a1_p2 = quick_spec 'a', 1 do |s| s.platform = 'unknown' end

-

- selected = r.select_local_platforms [a1, a1_p1, a1_p2]

-

- assert_equal [a1, a1_p1], selected

- end

-

-

-require 'rubygems/installer'

-

- @spec = quick_spec 'a'

-

- @builder = Gem::Ext::Builder.new @spec, ''

- def test_build_extensions_none

- use_ui @ui do

- @builder.build_extensions

- end

-

- assert_equal '', @ui.output

- assert_equal '', @ui.error

-

- refute File.exist?('gem_make.out')

- end

-

- def test_build_extensions_extconf_bad

- @spec.extensions << 'extconf.rb'

-

- e = assert_raises Gem::Installer::ExtensionBuildError do

- use_ui @ui do

- @builder.build_extensions

- end

- end

-

- assert_match(/\AERROR: Failed to build gem native extension.$/, e.message)

-

- assert_equal "Building native extensions. This could take a while...\n",

- @ui.output

- assert_equal '', @ui.error

-

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

-

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

- File.read(gem_make_out)

- assert_match %r%#{Regexp.escape Gem.ruby}: No such file%,

- File.read(gem_make_out)

- end

-

- def test_build_extensions_unsupported

- FileUtils.mkdir_p @spec.gem_dir

- gem_make_out = File.join @spec.gem_dir, 'gem_make.out'

- @spec.extensions << nil

-

- e = assert_raises Gem::Installer::ExtensionBuildError do

- use_ui @ui do

- @builder.build_extensions

- end

- end

-

- assert_match(/^\s*No builder for extension ''$/, e.message)

-

- assert_equal "Building native extensions. This could take a while...\n",

- @ui.output

- assert_equal '', @ui.error

-

- assert_equal "No builder for extension ''\n", File.read(gem_make_out)

- ensure

- FileUtils.rm_f gem_make_out

- end

-

- def test_build_extensions_with_build_args

- args = ["--aa", "--bb"]

- @builder.build_args = args

- @spec.extensions << 'extconf.rb'

-

- FileUtils.mkdir_p @spec.gem_dir

-

- open File.join(@spec.gem_dir, "extconf.rb"), "w" do |f|

- f.write <<-'RUBY'

- puts "IN EXTCONF"

- extconf_args = File.join File.dirname(__FILE__), 'extconf_args'

- File.open extconf_args, 'w' do |f|

- f.puts ARGV.inspect

- end

-

- File.open 'Makefile', 'w' do |f|

- f.puts "default:\n\techo built"

- f.puts "install:\n\techo installed"

- end

- RUBY

- end

-

- use_ui @ui do

- @builder.build_extensions

- end

-

- path = File.join @spec.gem_dir, "extconf_args"

-

- assert_equal args.inspect, File.read(path).strip

- assert File.directory? File.join(@spec.gem_dir, 'lib')

- end

-

-ruby =

- if ENV['RUBY'] then

- ENV['RUBY']

- else

- ruby_exe = "#{CONFIG['RUBY_INSTALL_NAME']}#{CONFIG['EXEEXT']}"

- File.join CONFIG['bindir'], ruby_exe

- end

- @runner = Gem::GemRunner.new

- def test_extract_build_args

- args = %w[]

- assert_equal [], @runner.extract_build_args(args)

- assert_equal %w[], args

- args = %w[foo]

- assert_equal [], @runner.extract_build_args(args)

- assert_equal %w[foo], args

- args = %w[--foo]

- assert_equal [], @runner.extract_build_args(args)

- assert_equal %w[--foo], args

- args = %w[--foo --]

- assert_equal [], @runner.extract_build_args(args)

- assert_equal %w[--foo], args

- args = %w[--foo -- --bar]

- assert_equal %w[--bar], @runner.extract_build_args(args)

- assert_equal %w[--foo], args

- util_sign_in [api_key, 200, 'OK'], 'http://example.com', ['http://example.com']

- def test_sign_in_with_host_nil

- api_key = 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'

-

- util_sign_in [api_key, 200, 'OK'], nil, [nil]

-

- assert_match "Enter your RubyGems.org credentials.",

- @sign_in_ui.output

- assert @fetcher.last_request["authorization"]

- assert_match %r{Signed in.}, @sign_in_ui.output

-

- credentials = YAML.load_file Gem.configuration.credentials_path

- assert_equal api_key, credentials[:rubygems_api_key]

- end

-

- def util_sign_in response, host = nil, args = []

- ENV['RUBYGEMS_HOST'] = host

- if args.length > 0 then

- @cmd.sign_in(*args)

- args.concat %w[-P HighSecurity] if defined?(OpenSSL::SSL)

-

- skip 'openssl is missing' unless defined?(OpenSSL::SSL)

-

- common_installer_setup

- common_installer_teardown

-

- assert_path_exists installed_exec

- assert_path_exists installed_exec

- assert_path_exists installed_exec

- assert_path_exists installed_exec

- skip 'openssl is missing' unless defined?(OpenSSL::SSL)

-

- assert_path_exists installed_exec

- assert_path_exists installed_exec