require 'rbconfig'

module Gem

end

# Must be first since it unloads the prelude from 1.9.2

# For user documentation, see:

#

# * <tt>gem help</tt> and <tt>gem help [command]</tt>

#

# For gem developer documentation see:

#

# * Gem::Specification

# * Gem::Version for version dependency notes

#

# Further RubyGems documentation can be found at:

#

# <tt>gem server</tt>)

#

# == RubyGems Plugins

#

# $LOAD_PATH. Plugins must be named 'rubygems_plugin' (.rb, .so, etc) and

#

# For an example plugin, see the {Graph gem}[https://.com/seattlerb/graph]

# which adds a `gem graph` command.

doc

extensions

gems

specifications

].freeze

##

# The path where gems are to be installed.

def self.dir

paths.home

paths.spec_cache_dir

end

##

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

# subdirectories. If we can't create a directory due to a permission

private_class_method :find_home

##

# Top level install helper method. Allows you to install gems interactively:

#

@suffix_pattern ||= "{#{suffixes.join(',')}}"

end

def self.suffix_regexp

@suffix_regexp ||= /#{Regexp.union(suffixes)}\z/

end

##

# Suffixes for require-able paths.

def self.suffixes

end

##

def self.load_plugins

end

##

# Find all 'rubygems_plugin' files in $LOAD_PATH and load them

def self.load_env_plugins

end

##

end

end

##

# The SOURCE_DATE_EPOCH environment variable (or, if that's not set, the current time), converted to Time object.

# This is used throughout RubyGems for enabling reproducible builds.

MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/".freeze

require "rubygems/specification"

end

# Return all files in this gem that match for +glob+.

def matches_for_glob(glob) # TODO: rename?

glob = File.join(self.lib_dirs_glob, glob)

Dir[glob].map { |f| f.tap(&Gem::UNTAINT) } # FIX our tests are broken, run w/ SAFE=1

end

##

# Returns a string usable in Dir.glob to match all requirable paths

# for this spec.

result

end

private

def option_is_deprecated?(option)

http://localhost:8808/

with info about installed gems

Further information:

HELP

# :startdoc:

cmd_name = args.shift.downcase

cmd = find_command cmd_name

cmd.invoke_with_build_args args, build_args

end

end

* Create a gem:

* See information about RubyGems:

# frozen_string_literal: true

require 'rubygems/command'

def initialize

remove_option('-d')

defaults[:details] = true

gem_version ||= options[:version]

domain = options[:domain]

domain = :local unless options[:suggest_alternate]

begin

install_gem gem_name, gem_version

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

exit_code |= 1

rescue Gem::GemNotFoundException => e

exit_code |= 2

rescue Gem::UnsatisfiableDependencyError => e

"'#{gem_name}' (#{gem_version})"

exit_code |= 2

# frozen_string_literal: true

require 'rubygems/command'

##

def initialize

end

def arguments # :nodoc:

options[:only_executables] = value

end

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

'Rewrite executables with a shebang',

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

end

end

say "Skipped #{spec.full_name}, it needs to compile an extension"

next

end

gem = spec.cache_file

require 'rubygems/remote_fetcher'

say "Cached gem for #{spec.full_name} not found, attempting to fetch..."

if options[:only_executables]

installer = Gem::Installer.for_spec(spec, installer_options)

installer.generate_bin

else

installer = Gem::Installer.at(gem, installer_options)

installer.install

# frozen_string_literal: true

require 'rubygems/command'

end

def arguments # :nodoc:

:force => true,

:site_or_vendor => 'sitelibdir',

:destdir => '', :prefix => '', :previous_version => '',

add_option '--previous-version=VERSION',

'Previous version of RubyGems',

options[:regenerate_binstubs] = value

end

add_option '-f', '--[no-]force',

'Forcefully overwrite binstubs' do |value, options|

options[:force] = value

say "RubyGems #{Gem::VERSION} installed"

regenerate_binstubs if options[:regenerate_binstubs]

uninstall_old_gemcutter

command.invoke(*args)

end

private

def target_bin_path(bin_dir, bin_file)

its history:

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

* 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

To remove a source use the --remove argument:

EOF

end

say "Latest version already installed. Done."

terminate_interaction

end

end

def check_update_arguments # :nodoc:

return

end

if options[:explain]

say "Gems to update:"

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

hig[spec.name] = spec

Dir.chdir update_dir do

say "Installing RubyGems #{version}"

say "RubyGems system software updated" if installed

end

end

def rubygems_target_version

version = options[:system]

update_latest = version == true

end

end

end

['doc', ''],

['extensions', ''],

['gems', ''],

].freeze

missing =

next if installed_specs.include? basename

next if /^rubygems-\d/ =~ basename

next if 'specifications' == sub_directory and 'default' == basename

type = File.directory?(child) ? 'directory' : 'file'

##

# Base exception class for RubyGems. All exception raised by RubyGems are a

# subclass of this one.

class Gem::CommandLineError < Gem::Exception; end

class Gem::GemRunner

end

##

#++

require 'rubygems/command'

require 'rubygems/exceptions'

require 'rubygems/deprecate'

require 'rubygems/package'

include Gem::UserInteraction

##

# Filename of the gem being installed.

require 'fileutils'

@options = options

process_options

end

generate_bin

unless @options[:install_as_default]

write_spec

else

generate_bin_symlink filename, @bin_dir

end

end

end

ruby_exe = "ruby.exe" if ruby_exe.empty?

if File.exist?(File.join bindir, ruby_exe)

<<-TEXT

@ECHO OFF

@"%~dp0#{ruby_exe}" "%~dpn0" %*

end

##

# Reads the file index and extracts each file into the gem directory.

#

# Ensures that files can't be installed outside the gem directory.

##

# Sets up the base @gem, builds it and returns an installer for it.

#

@gem = setup_base_gem

end

##

# Example using a Gem::Package

#

# Builds a .gem file given a Gem::Specification. A .gem file is a tarball

#

# require 'rubygems'

# require 'rubygems/package'

require 'rubygems/uri_parsing'

require 'rubygems/user_interaction'

require 'resolv'

##

# RemoteFetcher handles the details of fetching gems and gem information from

class Gem::RemoteFetcher

include Gem::UserInteraction

include Gem::UriParsing

##

end

##

# Performs a Net::HTTP request of type +request_class+ on +uri+ returning

# a Net::HTTP response object. request maintains a table of persistent

# connections to reduce connect overhead.

return unless (groups & @without_groups).empty?

dependencies.each do |dep|

end

end

##

# Creates a new APISet that will retrieve gems from +uri+ using the RubyGems

# API URL +dep_uri+ which is described at

def initialize(dep_uri = 'https://rubygems.org/api/v1/dependencies')

super()

# Creates an APISpecification for the given +set+ from the rubygems.org

# +api_data+.

#

# format of the +api_data+.

def initialize(set, api_data)

#

# $ tar tf your-gem-1.0.gem

# metadata.gz

# metadata.gz.sig # metadata signature

# data.tar.gz

# data.tar.gz.sig # data signature

#

# === Manually signing gems

#

# -K, --private-key KEY Key for --sign or --build

# -s, --sign CERT Signs CERT with the key from -K

# and the certificate from -C

#

# We've already covered the <code>--build</code> option, and the

# <code>--add</code>, <code>--list</code>, and <code>--remove</code> commands

# 2. Grab the public key from the gemspec

#

# gem spec some_signed_gem-1.0.gem cert_chain | \

#

# 3. Generate a SHA1 hash of the data.tar.gz

#

}.freeze

##

def self.re_sign_cert(expired_cert, expired_cert_path, private_key)

return unless expired_cert.not_after < Time.now

"only_one_executable" => true,

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

"has_deps" => false,

"name" => 'rubygems',

"ri_installed" => true,

"summary" => "RubyGems itself",

# "mailing_list_uri" => "https://groups.example.com/bestgemever",

# "source_code_uri" => "https://example.com/user/bestgemever",

# "wiki_uri" => "https://example.com/user/bestgemever/wiki"

# }

#

# These links will be used on your gem's page on rubygems.org and must pass

_latest_specs Gem::Specification._all, prerelease

end

def self._latest_specs(specs, prerelease = false) # :nodoc:

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

native = {}

#

# [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]]

out = []

Gem::Specification.each do |spec|

if self.satisfies_requirement?(dep)

sats = []

find_all_satisfiers(dep) do |sat|

end

##

def executables=(value)

@executables = Array(value)

end

##

def extensions=(extensions)

@extensions = Array extensions

end

##

def extra_rdoc_files=(files)

@extra_rdoc_files = Array files

end

end

##

def rdoc_options=(options)

@rdoc_options = Array options

end

end

##

def requirements=(req)

@requirements = Array req

end

mailing_list_uri

source_code_uri

wiki_uri

].freeze # :nodoc:

def initialize(specification)

end

def help_text # :nodoc:

end

end

# original value when the block ends

#

def bindir(value)

end

end

@tempdir.tap(&Gem::UNTAINT)

end

@gemhome = File.join @tempdir, 'gemhome'

@userhome = File.join @tempdir, 'userhome'

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

ruby

end

Gem.ensure_gem_subdirectories @gemhome

ENV.replace(@orig_env)

Gem.ruby = @orig_ruby if @orig_ruby

if Gem.java_platform?

def install_gem(spec, options = {})

require 'rubygems/installer'

unless File.exist? gem

use_ui Gem::MockGemUi.new do

end

end

end

Gem::Installer.at(gem, options.merge({:wrappers => true})).install

yield(s) if block_given?

end

written_path = write_file spec.spec_file do |io|

io.write spec.to_ruby_for_cache

end

util_build_gem spec

FileUtils.rm spec.spec_file

end

end

end

class << self

# :nodoc:

require 'fileutils'

require 'rubygems'

require 'rubygems/dependency_list'

require 'rubygems/rdoc'

require 'rubygems/user_interaction'

include Gem::UserInteraction

##

# The directory a gem's executables will be installed into

end

remove_executables @spec

remove @spec

Gem.post_uninstall_hooks.each do |hook|

hook.call self

end

end

##

def remove_executables(spec)

executables = spec.executables.clone

##

# spec:: the spec of the gem to be uninstalled

def remove(spec)

unless path_ok?(@gem_home, spec) or

end

##

# Is +spec+ in +gem_dir+?

def path_ok?(gem_dir, spec)

s.name == spec.name && s.full_name != spec.full_name

end

unless siblings.any? { |s| s.satisfies_requirement? dep }

msg << "#{dep_spec.name}-#{dep_spec.version} depends on #{dep}"

end

end

##

# Terminate the application with exit code +status+, running any exit

# handlers that might have been defined.

class Gem::Version

include Comparable

assert_match(/on or after 2099-03-01/, err)

end

end

raise "rubygems/bundler tests do not work correctly if there is #{ File.join(Dir.tmpdir, "Gemfile") }"

end

class TestGem < Gem::TestCase

PLUGINS_LOADED = [] # rubocop:disable Style/MutableConstant

def test_self_install_permissions_with_format_executable_and_non_standard_ruby_install_name

Gem::Installer.exec_format = nil

end

ensure

Gem::Installer.exec_format = nil

end

def test_self_ruby_escaping_spaces_in_path

end

end

end

def test_self_ruby_path_without_spaces

end

end

end

util_restore_RUBY_VERSION

end

util_set_RUBY_VERSION '2.6.0', -1, 63539, 'ruby 2.6.0preview2 (2018-05-31 trunk 63539) [x86_64-linux]'

assert_equal Gem::Version.new('2.6.0.preview2'), Gem.ruby_version

util_restore_RUBY_VERSION

end

def test_self_ruby_version_with_non_mri_implementations_with_mri_prerelase_compatibility

util_set_RUBY_VERSION '2.6.0', -1, 63539, 'weirdjruby 9.2.0.0 (2.6.0preview2) 2018-05-24 81156a8 OpenJDK 64-Bit Server VM 25.171-b11 on 1.8.0_171-8u171-b11-0ubuntu0.16.04.1-b11 [linux-x86_64]', 'weirdjruby', '9.2.0.0'

util_restore_RUBY_VERSION

end

util_set_RUBY_VERSION '1.9.2', -1, 23493, 'ruby 1.9.2dev (2009-05-20 trunk 23493) [x86_64-linux]'

assert_equal Gem::Version.new('1.9.2.dev'), Gem.ruby_version

util_restore_RUBY_VERSION

end

def test_self_rubygems_version

assert_equal Gem::Version.new(Gem::VERSION), Gem.rubygems_version

end

install_gem foo2

end

Gem::Specification.reset

gem 'foo'

end

def ruby_install_name(name)

end

end

end

end

def with_plugin(path)

test_plugin_path = File.expand_path("test/rubygems/plugin/#{path}",

PROJECT_DIR)

end

#check defaults

assert_equal(//, check_options[:name])

assert_equal :local, check_options[:domain]

assert_equal false, check_options[:details]

#check settings

check_options = nil

assert_equal(/foobar/i, check_options[:name])

assert_equal :local, check_options[:domain]

assert_equal true, check_options[:details]

#remote domain

check_options = nil

assert_equal :remote, check_options[:domain]

#both (local/remote) domains

check_options = nil

assert_equal :both, check_options[:domain]

end

assert_equal Dir.pwd, check_options[:install_dir]

end

end

error = @ui.error.split "\n"

assert_equal "WARNING: licenses is empty, but is recommended. Use a license identifier from", error.shift

assert_equal "http://spdx.org/licenses or 'Nonstandard' for a nonstandard license.", error.shift

assert_equal [], error

gem_file = File.join @tempdir, File.basename(@gem.cache_file)

io.write "# extconf.rb\nrequire 'mkmf'; create_makefile 'a'"

end

install_gem a

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

refute File.exist? gem_lib

end

def test_execute_bindir

a = util_spec 'a' do |s|

s.name = "test_gem"

File.join @gemhome, 'bin', name

end

def test_execute_regenerate_binstubs

gem_bin_path = gem_install 'a'

write_file gem_bin_path do |io|

assert_equal "I changed it!\n", File.read(gem_bin_path)

end

def test_execute_informs_about_installed_executables

use_ui @ui do

@cmd.execute

end

def test_execute_add_http_rubygems_org

spec_fetcher do |fetcher|

fetcher.spec 'a', 1

assert_empty @ui.error

end

def test_execute_add_bad_uri

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

assert_empty out

end

def test_execute_system_specifically_to_latest_version

spec_fetcher do |fetcher|

fetcher.download 'rubygems-update', 8 do |s|

end

def test_execute_user_install

@cmd.handle_options %w[--user-install]

installer = @cmd.installer

user_install = installer.instance_variable_get :@user_install

end

def test_fetch_remote_gems

@cfg_args = %W[--config-file #{@temp_conf}]

Gem::ConfigFile::OPERATING_SYSTEM_DEFAULTS.clear

Gem::ConfigFile::PLATFORM_DEFAULTS.clear

def teardown

Gem::ConfigFile::OPERATING_SYSTEM_DEFAULTS.clear

Gem::ConfigFile::PLATFORM_DEFAULTS.clear

ENV['GEMRC'] = @env_gemrc

e1 = util_spec 'e', '1', nil, 'extconf.rb' do |s|

s.extensions << 'extconf.rb'

end

_, f1_gem = util_gem 'f', '1', 'e' => nil

assert true # count

end

def test_gem_repository_eh

doctor = Gem::Doctor.new @gemhome

assert_equal %w[--foo], args

end

end

assert_match(/#{default_shebang}/, shebang_line)

end

def test_initialize

spec = util_spec 'a' do |s|

s.platform = Gem::Platform.new 'mswin32'

end

def test_install_creates_binstub_that_prefers_user_installed_gem_to_default

installer = util_setup_installer do |spec|

spec.name = 'default'

end

end

e = assert_raises RuntimeError do

instance_eval File.read(exe)

end

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

end

fetcher = Gem::RemoteFetcher.new nil

@fetcher = fetcher

e = assert_raises ArgumentError do

end

assert_equal 'uri scheme is invalid: nil', e.message

end

fetcher = Gem::RemoteFetcher.new nil

@fetcher = fetcher

def fetcher.request(uri, request_class, last_modified = nil)

uri = 'http://gems.example.com/yaml'

e = assert_raises Gem::RemoteFetcher::FetchError do

end

assert_equal "SocketError: oops (#{uri})", e.message

def test_no_proxy

use_ui @stub_ui do

assert_data_from_server @fetcher.fetch_path(@server_uri)

end

end

end

def test_ssl_client_cert_auth_connection

skip 'openssl in jruby fails' if java_platform?

ssl_server = self.class.start_ssl_server({

end

def test_do_not_allow_invalid_client_cert_auth_connection

ssl_server = self.class.start_ssl_server({

:SSLVerifyClient =>

OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT})

DIR = File.expand_path(File.dirname(__FILE__))

def start_ssl_server(config = {})

null_logger = NilLog.new

server = WEBrick::HTTPServer.new({

:Port => 0,

begin

server.start

rescue Exception => ex

puts "ERROR during server thread: #{ex.message}"

ensure

server.shutdown

end

assert_path_exists File.join @gemhome, 'specifications', 'b-1.gemspec'

end

def test_install_from_gemdeps_version_mismatch

spec_fetcher do |fetcher|

fetcher.gem 'a', 2

add_runtime_dependency 'l', '~> 1.2', '> 1.2.3'

#{w}: open-ended dependency on o (>= 0) is not recommended

use a bounded requirement, such as '~> x.y'

EXPECTED

assert_equal expected, @ui.error, 'warning'

end

assert_equal <<-EXPECTED, @ui.error

EXPECTED

end

end

end

end

end

def test_validate_executables

assert_equal '"ftp://rubygems.org" is not a valid HTTP URI', e.message

assert_equal true, @a1.validate

@a1.homepage = 'https://rubygems.org'

@a1.validate

end

end

def test_version

s.metadata = {

"one" => "two",

"home" => "three",

}

end

end

end

def test_path_ok_eh

uninstaller = Gem::Uninstaller.new nil

assert_match %r!Successfully uninstalled q-1!, lines.last

end

def test_uninstall_no_permission

uninstaller = Gem::Uninstaller.new @spec.name, :executables => true

end

end

end

assert_equal expected, v(version).approximate_recommendation

end

def assert_approximate_satisfies_itself(version)

gem_version = v(version)