require 'rbconfig'

module Gem

end

# Must be first since it unloads the prelude from 1.9.2

# to avoid deprecation warnings in Ruby 2.7.

UNTAINT = RUBY_VERSION < '2.7' ? :untaint.to_sym : proc{}

##

# An Array of Regexps that match windows Ruby platforms.

val = RbConfig::CONFIG[key]

next unless val and not val.empty?

".#{val}"

].compact.uniq

end

end

def match_platform!

@sorted = nil

self

end

].freeze

ALIAS_COMMANDS = {

}.freeze

##

else

cmd_name = args.shift.downcase

cmd = find_command cmd_name

cmd.deprecation_warning if cmd.deprecated?

end

end

end

def execute

end

private

if gemspecs.size > 1

alert_error "Multiple gemspecs found: #{gemspecs}, please specify one"

gemspecs.first

end

else

terminate_interaction(1)

end

end

if spec

Gem::Package.build(

spec,

terminate_interaction 1

end

end

end

# It's simple, but is all we need

email =~ /\A.+@.+\z/

end

@command_manager.command_names.each do |cmd_name|

command = @command_manager[cmd_name]

summary =

if command

command.summary

def execute

@host = options[:host]

name = get_one_gem_name

add_owners name, options[:add]

private

def send_owner_request(method, name, owner)

request.set_form_data 'email' => owner

request.add_field "Authorization", api_key

request.add_field "OTP", options[:otp] if options[:otp]

end

end

end

:install_dir => spec.base_dir,

:env_shebang => env_shebang,

:build_args => spec.build_args,

}

if options[:only_executables]

options[:host]

end

send_gem(gem_name)

end

private

def send_push_request(name, args)

request.body = Gem.read_binary name

request.add_field "Content-Length", request.body.size

request.add_field "Content-Type", "application/octet-stream"

[

gem_metadata["default_gem_server"],

]

end

end

include Gem::QueryUtils

def initialize(name = 'query',

summary = 'Query gem information in local or remote repositories')

super name, summary,

add_query_options

end

end

# frozen_string_literal: true

require 'rubygems/command'

require 'rubygems/server'

class Gem::Commands::ServerCommand < Gem::Command

def initialize

super 'server', 'Documentation and gem repository HTTP server',

:port => 8808, :gemdir => [], :daemon => false

libs.each do |tool, path|

say "Installing #{tool}" if @verbose

Dir.chdir path do

end

end

end

specs_dir = File.join(options[:destdir], specs_dir) unless Gem.win_platform?

mkdir_p specs_dir, :mode => 0755

bundler_spec = Gem::Specification.load("bundler/bundler.gemspec")

bundler_spec.files = Dir.chdir("bundler") { Dir["{*.md,{lib,exe,man}/**/*}"] }

bundler_spec.executables -= %w[bundler bundle_ruby]

[lib_dir, bin_dir]

end

Dir.chdir dir do

end

end

# for installation of bundler as default gems

def bundler_man1_files_in(dir)

Dir.chdir dir do

end

end

# for installation of bundler as default gems

def bundler_man5_files_in(dir)

Dir.chdir dir do

end

end

lib_dirs = { File.join(lib_dir, 'rubygems') => 'lib/rubygems' }

lib_dirs[File.join(lib_dir, 'bundler')] = 'bundler/lib/bundler'

lib_dirs.each do |old_lib_dir, new_lib_dir|

to_remove = old_lib_files - lib_files

def remove_old_man_files(man_dir)

man_dirs = { man_dir => "bundler/man" }

man_dirs.each do |old_man_dir, new_man_dir|

end

end

options[:update] = value

end

add_proxy_option

end

Do you want to add this source?

QUESTION

end

end

Do you want to add this insecure source?

QUESTION

end

end

terminate_interaction 1

end

unless options[:all]

specs = [specs.max_by {|s| s.version }]

end

def execute

@host = options[:host]

version = get_version_from_requirements(options[:version])

platform = get_platform_from_requirements(options)

def yank_api_request(method, version, platform, api)

name = get_one_gem_name

request.add_field("Authorization", api_key)

request.add_field("OTP", options[:otp]) if options[:otp]

nil

end

end

end

private :gem_original_require

end

##

# When RubyGems is required, Kernel#require is replaced with our own which

# is capable of loading gems on demand.

end

end

end

private :require

# frozen_string_literal: true

# `uplevel` keyword argument of Kernel#warn is available since ruby 2.5.

module Kernel

rubygems_path = "#{__dir__}/" # Frames to be skipped start with this path.

remove_method :warn

module_function define_method(:warn) {|*messages, **kw|

unless uplevel = kw[:uplevel]

if Gem.java_platform?

else

end

end

end

end

end

end

}

end

end

[

File.dirname(RbConfig::CONFIG['sitedir']),

'Gems',

]

else

[

RbConfig::CONFIG['rubylibprefix'],

'gems',

]

end

if platform_only

matches.reject! do |spec|

end

end

:wrappers => true,

:build_args => nil,

:build_docs_in_background => false,

}.freeze

##

request_set.development_shallow = @dev_shallow

request_set.soft_missing = @force

request_set.prerelease = @prerelease

installer_set = Gem::Resolver::InstallerSet.new @domain

if consider_local?

if dep_or_name =~ /\.gem$/ and File.file? dep_or_name

dependency =

if spec = installer_set.local?(dep_or_name)

Gem::Dependency.new spec.name, version

elsif String === dep_or_name

Gem::Dependency.new dep_or_name, version

installer_set.add_always_install dependency

request_set.always_install = installer_set.always_install

if @ignore_dependencies

installer_set.ignore_dependencies = true

class Gem::Ext::Builder

include Gem::UserInteraction

attr_accessor :build_args # :nodoc:

def self.class_name

$1.downcase

end

raise Gem::InstallError, 'Makefile not found'

end

cmd = [

make_program,

destdir,

].join(' ').rstrip

begin

rescue Gem::InstallError

raise unless target == 'clean' # ignore clean failure

end

end

end

verbose = Gem.configuration.really_verbose

begin

rubygems_gemdeps, ENV['RUBYGEMS_GEMDEPS'] = ENV['RUBYGEMS_GEMDEPS'], nil

if verbose

p(command)

end

results << (command.respond_to?(:shelljoin) ? command.shelljoin : command)

require "open3"

# Set $SOURCE_DATE_EPOCH for the subprocess.

env = {'SOURCE_DATE_EPOCH' => Gem.source_date_epoch_string}

if verbose

puts output

else

begin

FileUtils.mkdir_p dest_path

write_gem_make_out results.join "\n"

rescue => e

dest_path = @spec.extension_dir

FileUtils.rm_f @spec.gem_build_complete_path

@spec.extensions.each do |extension|

require_relative '../command'

class Gem::Ext::CmakeBuilder < Gem::Ext::Builder

cmd = "cmake . -DCMAKE_INSTALL_PREFIX=#{dest_path}"

cmd << " #{Gem::Command.build_args.join ' '}" unless Gem::Command.build_args.empty?

end

results

end

#++

class Gem::Ext::ConfigureBuilder < Gem::Ext::Builder

cmd = "sh ./configure --prefix=#{dest_path}"

cmd << " #{args.join ' '}" unless args.empty?

end

results

end

require 'shellwords'

class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder

require 'fileutils'

require 'tempfile'

# Some versions of `mktmpdir` return absolute paths, which will break make

# if the paths contain spaces. However, on Ruby 1.9.x on Windows, relative

# spaces do not work.

#

# Details: https://.com/rubygems/rubygems/issues/977#issuecomment-171544940

siteconf.puts "require 'rbconfig'"

siteconf.puts "dest_path = #{tmp_dest.dump}"

%w[sitearchdir sitelibdir].each do |dir|

destdir = ENV["DESTDIR"]

begin

cmd = Gem.ruby.shellsplit << "-I" << File.expand_path("../../..", __FILE__) <<

cmd.push(*args)

begin

unless s.success?

r << "To see why this extension failed to compile, please check" \

" the mkmf.log which can be found here:\n"

r << " " + File.join(dest_path, 'mkmf.log') + "\n"

end

end

end

siteconf.unlink

ENV["DESTDIR"] = nil

if tmp_dest

# TODO remove in RubyGems 3

if Gem.install_extension_in_lib and lib_dir

FileUtils.mkdir_p lib_dir

FileUtils.cp_r entries, lib_dir, :remove_destination => true

end

destent = ent.class.new(dest_path, ent.rel)

destent.exist? or FileUtils.mv(ent.path, destent.path)

end

private

path

end

end

require "shellwords"

class Gem::Ext::RakeBuilder < Gem::Ext::Builder

if File.basename(extension) =~ /mkrf_conf/i

end

rake = ENV['rake']

end

rake_args = ["RUBYARCHDIR=#{dest_path}", "RUBYLIBDIR=#{dest_path}", *args]

results

end

module Gem::GemcutterUtilities

ERROR_CODE = 1

include Gem::Text

attr_writer :host

##

# Add the --key option

#

# If +allowed_push_host+ metadata is present, then it will only allow that host.

require 'net/http'

self.host = host if host

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

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

end

end

ask 'Code: '

end

##

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

# key.

sign_in_host ||= self.host

return if api_key

say "Enter your #{pretty_host} credentials."

say "Don't have an account yet? " +

password = ask_for_password "Password: "

say "\n"

request.basic_auth email, password

request.add_field "OTP", options[:otp] if options[:otp]

end

with_response response do |resp|

set_api_key host, resp.body

end

end

end

end

end

# frozen_string_literal: true

require 'rubygems'

require 'rubygems/package'

require 'tmpdir'

##

options[:minimal_deps] = true

end

"Don't upgrade any dependencies that already",

"meet version requirements") do |value, options|

end

add_option(:"Install/Update", "--[no-]post-install-message",

require 'rubygems/package'

require 'rubygems/ext'

require 'rubygems/user_interaction'

##

# The installer installs the files contained in the .gem into the Gem.home.

#

def default_spec_file

end

##

mode = File.stat(bin_path).mode

dir_mode = options[:prog_mode] || (mode | 0111)

check_executable_overwrite filename

def generate_bin_script(filename, bindir)

bin_script_path = File.join bindir, formatted_program_filename(filename)

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

File.open bin_script_path, 'wb', 0755 do |file|

:env_shebang => false,

:force => false,

:only_install_dir => false,

}.merge options

@env_shebang = options[:env_shebang]

@build_args = options[:build_args] || Gem::Command.build_args

unless @build_root.nil?

end

end

#

# And returns a Gem::Installer for the @spec that installs into @gemhome

@gem = setup_base_gem

end

##

# lib/code.rb

# ext/a/mkrf_conf.rb

@spec.files << File.join('lib', 'code.rb')

@spec.extensions << File.join('ext', 'a', 'mkrf_conf.rb')

end

end

end

##

# Creates an installer for +spec+ that will install into +gem_home+. If

# +user+ is true a user-install will be performed.

Gem::Installer.at(spec.cache_file,

:install_dir => gem_home,

end

@@symlink_supported = nil

# Indicate if this NameTuple matches the current platform.

def match_platform?

end

##

# frozen_string_literal: true

end

require "rubygems"

require 'rubygems/security'

require 'rubygems/user_interaction'

class Gem::Package

include Gem::UserInteraction

# Creates a new package that will read or write to the file +gem+.

def initialize(gem, security_policy) # :notnew:

@gem = gem

@build_time = Gem.source_date_epoch

setup_signer(

signer_options: {

}

)

gname,

oct(devmajor, 7),

oct(devminor, 7),

]

header = header.pack PACK_FORMAT

ASCIIZ("wheel", 32), # char gname[32]; ASCIIZ

Z(to_oct(0, 7)), # char devmajor[8]; 0 padded, octal, null

Z(to_oct(0, 7)), # char devminor[8]; 0 padded, octal, null

]

h = arr.join

class Gem::Platform

@local = nil

def self.local

arch = RbConfig::CONFIG['arch']

end

def self.match(platform)

platform.nil? or

local_platform == platform or

(local_platform != Gem::Platform::RUBY and local_platform =~ platform)

end

end

def self.installable?(spec)

if spec.respond_to? :installable_platform?

spec.installable_platform?

else

end

end

"--local --name-matches // --no-details --versions --no-installed"

end

def execute

gem_names = Array(options[:name])

def initialize(proxy=nil, dns=nil, headers={})

require 'net/http'

require 'stringio'

require 'uri'

Socket.do_not_reverse_lookup = true

rescue Timeout::Error

raise UnknownHostError.new('timed out', uri)

rescue IOError, SocketError, SystemCallError,

if e.message =~ /getaddrinfo/

raise UnknownHostError.new('no such name', uri)

else

# frozen_string_literal: true

require 'net/http'

require 'rubygems/user_interaction'

class Gem::Request

end

def self.configure_connection_for_https(connection, cert_files)

connection.use_ssl = true

connection.verify_mode =

Gem.configuration.ssl_verify_mode || OpenSSL::SSL::VERIFY_PEER

def connection_for(uri)

@connection_pool.checkout

Errno::EHOSTDOWN => e

raise Gem::RemoteFetcher::FetchError.new(e.message, uri)

end

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

if @last_modified

request.add_field 'If-Modified-Since', @last_modified.httpdate

end

:truffleruby => Gem::Platform::RUBY,

:x64_mingw => x64_mingw,

:x64_mingw_20 => x64_mingw,

}.freeze

gt_eq_0 = Gem::Requirement.new '>= 0'

Gem::Requirement.create requirements

end

groups = gem_group name, options

# Handles the platforms: option from +options+. Returns true if the

# platform matches the current platform.

platform_names = Array(options.delete :platform)

platform_names.concat Array(options.delete :platforms)

platform_names.concat @current_platforms if @current_platforms

raise ArgumentError, "unknown platform #{platform_name.inspect}" unless

platform = PLATFORM_MAP[platform_name]

if engines = ENGINE_MAP[platform_name]

next false unless engines.include? Gem.ruby_engine

"<" => lambda {|v, r| v < r },

">=" => lambda {|v, r| v >= r },

"<=" => lambda {|v, r| v <= r },

}.freeze

SOURCE_SET_REQUIREMENT = Struct.new(:for_lockfile).new "!" # :nodoc:

amount_constrained(dependency),

conflicts[name] ? 0 : 1,

activated.vertex_named(name).payload ? 0 : search_for(dependency).count,

]

end

end

when Gem::Specification

@spec == other

when Gem::Resolver::ActivationRequest

else

false

end

end

##

# Is this activation request for a development dependency?

@dependencies == other.dependencies

end

def fetch_development_dependencies # :nodoc:

spec = source.fetch_spec Gem::NameTuple.new @name, @version, @platform

end

def installable_platform? # :nodoc:

end

def pretty_print(q) # :nodoc:

activated, requirement,

request_path(@activated).reverse.join(", depends on\n "),

request_path(@failed_dep).reverse.join(", depends on\n "),

]

end

when Gem::Dependency

@dependency == other

when Gem::Resolver::DependencyRequest

else

false

end

spec.dependencies

end

def inspect # :nodoc:

'#<%s %s source %s>' % [self.class, full_name, @source]

end

super()

@domain = domain

@f = Gem::SpecFetcher.fetcher

always_install = @always_install.map {|s| s.full_name }

'#<%s domain: %s specs: %p always install: %p>' % [

]

end

def add(name, version, platform) # :nodoc:

version = Gem::Version.new version

specs = [

]

@specs.concat specs

# frozen_string_literal: true

# Gem::Resolver::Molinillo is a generic dependency resolution algorithm.

module Gem::Resolver::Molinillo

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# @!visibility private

module Delegates

current_state = state || Gem::Resolver::Molinillo::ResolutionState.empty

current_state.conflicts

end

end

end

end

# frozen_string_literal: true

module Gem::Resolver::Molinillo

module Delegates

# Delegates all {Gem::Resolver::Molinillo::SpecificationProvider} methods to a

# frozen_string_literal: true

require 'set'

require 'tsort'

module Gem::Resolver::Molinillo

# A directed acyclic graph that is tuned to hold named dependencies

dot.join("\n")

end

# @return [Boolean] whether the two dependency graphs are equal, determined

# by a recursive traversal of each {#root_vertices} and its

# {Vertex#successors}

vertex = add_vertex(name, payload, root)

vertex.explicit_requirements << requirement if root

parent_names.each do |parent_name|

end

vertex

end

# @return [Edge] the added edge

def add_edge(origin, destination, requirement)

if destination.path_to?(origin)

end

add_edge_no_circular(origin, destination, requirement)

end

def add_edge_no_circular(origin, destination, requirement)

log.add_edge_no_circular(self, origin.name, destination.name, requirement)

end

end

end

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# An action that modifies a {DependencyGraph} that is reversible.

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# @!visibility private

end

# (see Action#up)

end

# (see Action#down)

end

# @!group Tag

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class DependencyGraph

# A vertex in a {DependencyGraph} that encapsulates a {#name} and a

# @return [Array<Object>] all of the requirements that required

# this vertex

def requirements

end

# @return [Array<Edge>] the edges of {#graph} that have `self` as their

incoming_edges.map(&:origin)

end

# {#descendent?}

def recursive_predecessors

vertices

end

# @return [Array<Vertex>] the vertices of {#graph} that have an edge with

# `self` as their {Edge#origin}

outgoing_edges.map(&:destination)

end

# {#ancestor?}

def recursive_successors

vertices

end

# @return [String] a string suitable for debugging

def inspect

# dependency graph?

# @return true iff there is a path following edges within this {#graph}

def path_to?(other)

end

alias descendent? path_to?

# Is there a path from `other` to `self` following edges in the

# dependency graph?

# @return true iff there is a path following edges within this {#graph}

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# An error that occurred during the resolution process

class ResolverError < StandardError; end

# @param [Array<Object>] required_by @see {#required_by}

def initialize(dependency, required_by = [])

@dependency = dependency

super()

end

attr_reader :dependencies

# Initializes a new error with the given circular vertices.

# that caused the error

end

end

# resolution to fail

attr_reader :conflicts

# Initializes a new error with the given version conflicts.

# @param [{String => Resolution::Conflict}] conflicts see {#conflicts}

pairs = []

conflicting.each do |source, conflict_requirements|

conflict_requirements.each do |c|

pairs << [c, source]

super "Unable to satisfy the following requirements:\n\n" \

"#{pairs.map { |r, d| "- `#{r}` required by `#{d}`" }.join("\n")}"

@conflicts = conflicts

end

end

end

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# The version of Gem::Resolver::Molinillo.

end

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# Provides information about specifcations and dependencies to the resolver,

# allowing the {Resolver} class to remain generic while still providing power

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# Conveys information about the resolution process to a user.

module UI

if debug?

debug_info = yield

debug_info = debug_info.inspect unless debug_info.is_a?(String)

end

end

# frozen_string_literal: true

module Gem::Resolver::Molinillo

class Resolver

# A specific resolution from a given {Resolver}

# @attr [{String,Nil=>[Object]}] requirements the requirements that caused the conflict

# @attr [Object, nil] existing the existing spec that was in conflict with

# the {#possibility}

# @attr [Object] locked_requirement the relevant locking requirement.

# @attr [Array<Array<Object>>] requirement_trees the different requirement

# trees that led to every requirement for the conflicting name.

# @attr [{String=>Object}] activated_by_name the already-activated specs.

Conflict = Struct.new(

:requirement,

:requirements,

:existing,

:locked_requirement,

:requirement_trees,

)

# @return [SpecificationProvider] the provider that knows about

# dependencies, requirements, specifications, versions, etc.

attr_reader :specification_provider

start_resolution

while state

indicate_progress

if state.respond_to?(:pop_possibility_state) # DependencyState

debug(depth) { "Creating possibility state for #{requirement} (#{possibilities.count} remaining)" }

process_topmost_state

end

ensure

end_resolution

end

def start_resolution

@started_at = Time.now

debug { "Starting resolution (#{@started_at})\nUser-requested dependencies: #{original_requested}" }

resolver_ui.before_resolution

end

# Ends the resolution process

# @return [void]

def end_resolution

debug { 'Activated: ' + Hash[activated.vertices.select { |_n, v| v.payload }].keys.join(', ') } if state

end

include Gem::Resolver::Molinillo::Delegates::ResolutionState

include Gem::Resolver::Molinillo::Delegates::SpecificationProvider

if possibility

attempt_to_activate

else

end

end

# @return [Object] the current possibility that the resolution is trying

states.last

end

# {#requested} dependencies

graph = DependencyGraph.new.tap do |dg|

dg.tag(:initial_state)

end

end

# Unwinds the states stack because a conflict has been encountered

# @return [void]

def unwind_for_conflict

conflicts.tap do |c|

activated.rewind_to(sliced_states.first || :initial_state) if sliced_states

state.conflicts = c

index = states.size - 1

@parents_of.each { |_, a| a.reject! { |i| i >= index } }

end

end

end

end

end

end

# @return [Object] the requirement that led to `requirement` being added

# to the list of requirements.

def parent_of(requirement)

parent_state.requirement

end

# @return [Object] the requirement that led to a version of a possibility

# with the given name being activated.

def requirement_for_existing_name(name)

states.find { |s| s.name == name }.requirement

end

# @return [ResolutionState] the state whose `requirement` is the given

# `requirement`.

def find_state_for(requirement)

return nil unless requirement

end

# @return [Conflict] a {Conflict} that reflects the failure to activate

# the {#possibility} in conjunction with the current {#state}

vertex = activated.vertex_named(name)

locked_requirement = locked_requirement_named(name)

requirements[name_for_explicit_dependency_source] = vertex.explicit_requirements

end

requirements[name_for_locking_dependency_source] = [locked_requirement] if locked_requirement

activated_by_name = {}

conflicts[name] = Conflict.new(

requirement,

requirements,

possibility,

locked_requirement,

requirement_trees,

)

end

vertex.requirements.map { |r| requirement_tree_for(r) }

end

# @return [Array<Object>] the list of requirements that led to

# `requirement` being required.

def requirement_tree_for(requirement)

# @return [void]

def attempt_to_activate

debug(depth) { 'Attempting to activate ' + possibility.to_s }

else

end

end

end

end

# @return [void]

else

create_conflict

unwind_for_conflict

end

end

end

# @param [String] requirement_name the spec name to search for

# Add the current {#possibility} to the dependency graph of the current

# {#state}

# @return [void]

conflicts.delete(name)

debug(depth) { "Activated #{name} at #{possibility}" }

activated.set_payload(name, possibility)

end

# Requires the dependencies that the recently activated spec has

# activated

# @return [void]

debug(depth) { "Requiring nested dependencies (#{nested_dependencies.join(', ')})" }

nested_dependencies.each do |d|

parent_index = states.size - 1

parents = @parents_of[d]

parents << parent_index if parents.empty?

# Pushes a new {DependencyState} that encapsulates both existing and new

# requirements

# @param [Array] new_requirements

# @return [void]

def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated)

new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts) if requires_sort

new_name = new_requirement ? name_for(new_requirement) : ''.freeze

handle_missing_or_push_dependency_state DependencyState.new(

new_name, new_requirements, new_activated,

)

end

# Pushes a new {DependencyState}.

# If the {#specification_provider} says to

# {SpecificationProvider#allow_missing?} that particular requirement, and

# there are no possibilities for that requirement, then `state` is not

# resolving the remaining requirements.

# @param [DependencyState] state

# @return [void]

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# This class encapsulates a dependency resolver.

#

#

class Resolver

# @return [SpecificationProvider] the specification provider used

# in the resolution process

# frozen_string_literal: true

module Gem::Resolver::Molinillo

# A state that a {Resolution} can be in

# @attr [String] name the name of the current requirement

# @attr [Object] requirement the current requirement

# @attr [Object] possibilities the possibilities to satisfy the current requirement

# @attr [Integer] depth the depth of the resolution

ResolutionState = Struct.new(

:name,

:requirements,

:requirement,

:possibilities,

:depth,

)

class ResolutionState

# Returns an empty resolution state

# @return [ResolutionState] an empty state

def self.empty

end

end

requirement,

[possibilities.pop],

depth + 1,

).tap do |state|

state.activated.tag(state)

end

# Returns true if this specification is installable on this platform.

def installable_platform?

end

def local? # :nodoc:

"AWS4-HMAC-SHA256",

date_time,

credential_info,

].join("\n")

end

#++

require 'rubygems/exceptions'

require_relative 'openssl'

##

end

require 'rubygems/security/policy'

require 'rubygems/security/policies'

require 'rubygems/security/trust_dir'

("[Policy: %s - data: %p signer: %p chain: %p root: %p " +

"signed-only: %p trusted-only: %p]") % [

@name, @verify_chain, @verify_data, @verify_root, @verify_signer,

]

end

attr_reader :options

DEFAULT_OPTIONS = {

}.freeze

##

doc_items << {

:name => base_name,

:url => doc_root(new_path),

}

end

def dependency_resolver_set # :nodoc:

return Gem::Resolver::IndexSet.new self if 'file' == uri.scheme

begin

fetcher = Gem::RemoteFetcher.fetcher

spec_file_name = name_tuple.spec_name

cache_dir = cache_dir source_uri

file = FILES[type]

fetcher = Gem::RemoteFetcher.fetcher

file_name = "#{file}.#{Gem.marshal_version}"

cache_dir = cache_dir spec_path

local_file = File.join(cache_dir, file_name)

retried = false

def typo_squatting?(host, distance_threshold=4)

return if @uri.host.nil?

end

end

found[source] = specs.select do |tup|

if dependency.match?(tup)

pm = (

rejected_specs[dependency] ||= \

Gem::PlatformMismatch.new(tup.name, tup.version))

-1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'],

1 => [

'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"',

],

2 => [

'Added "required_rubygems_version"',

'Now forward-compatible with future versions',

],

3 => [

],

4 => [

}.freeze

MARSHAL_FIELDS = { # :nodoc:

stubs = stubs.uniq {|stub| stub.full_name }

_resort!(stubs)

stubs

end

end

@@stubs_by_name[name]

else

pattern = "#{name}-*.gemspec"

stubs = stubs.uniq {|stub| stub.full_name }.group_by(&:name)

stubs.each_value {|v| _resort!(v) }

true, # has_rdoc

@new_platform,

@licenses,

]

end

:version,

:has_rdoc,

:default_executable,

]

@@attributes.each do |attr_name|

# in their require paths, so lets take advantage of that by pre-allocating

# a require path list for that case.

REQUIRE_PATH_LIST = { # :nodoc:

}.freeze

def initialize(data, extensions)

msg = message(msg) do

'Expected output containing make command "%s": %s' % [

('%s %s' % [make_command, target]).rstrip,

]

end

else

msg = message(msg) do

'Expected make command "%s": %s' % [

('%s %s' % [make_command, target]).rstrip,

]

end

end

@git = ENV['GIT'] || (win_platform? ? 'git.exe' : 'git')

Gem.ensure_gem_subdirectories @gemhome

@orig_LOAD_PATH = $LOAD_PATH.dup

$LOAD_PATH.map! do |s|

Gem.send :remove_instance_variable, :@ruby_version if

Gem.instance_variables.include? :@ruby_version

FileUtils.mkdir_p @userhome

ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = PRIVATE_KEY_PASSPHRASE

if Gem.java_platform?

@orig_default_gem_home = RbConfig::CONFIG['default_gem_home']

else

end

Gem::Specification.unresolved_deps.clear

Gem.use_paths(@gemhome)

Gem.loaded_specs.clear

Gem.instance_variable_set(:@activated_gem_paths, 0)

Gem.clear_default_specs

Gem.ruby = @orig_ruby if @orig_ruby

if Gem.java_platform?

RbConfig::CONFIG['default_gem_home'] = @orig_default_gem_home

else

def install_specs(*specs)

specs.each do |spec|

end

Gem.searcher = nil

# Installs the provided default specs including writing the spec file

def install_default_gems(*specs)

specs.each do |spec|

installer = Gem::Installer.for_spec(spec, :install_as_default => true)

installer.install

def new_default_spec(name, version, deps = nil, *files)

spec = util_spec name, version, deps

spec.files = files

lib_dir = File.join(@tempdir, "default_gems", "lib")

PRIVATE_KEY = nil

PUBLIC_KEY = nil

PUBLIC_CERT = nil

end

require 'rubygems/test_utilities'

# frozen_string_literal: true

##

# The UriFormatter handles URIs from user-input and escaping.

# Creates a new URI formatter for +uri+.

def initialize(uri)

@uri = uri

end

end

end

end

require 'net/http'

require 'rubygems/openssl'

warn 'Skipping bundled certificates tests. openssl not found.'

end

assert_https('rubygems.org')

end

end

def test_accessing_new_index

end

:prog_mode => win_platform? ? 0410 : 0510,

:data_mode => 0640,

:wrappers => true,

}

Dir.chdir @tempdir do

Dir.mkdir 'bin'

expected = [

File.expand_path('test/rubygems/sff/discover.rb', PROJECT_DIR),

].sort

assert_equal expected, Gem.find_files('sff/discover').sort

tests = [

[:dir0, [ Gem.dir, Gem.user_dir], m0],

]

tests.each do |_name, _paths, expected|

end

assert_equal '', @ui.output

end

def test_execute_outside_dir

assert_equal "this is a summary", spec.summary

end

def test_can_find_gemspecs_without_dot_gemspec

File.open gemspec_file + ".gemspec", 'w' do |gs|

gs.write @gem.to_ruby

end

def test_build_signed_gem

trust_dir = Gem::Security.trust_dir

end

def test_build_signed_gem_with_cert_expiration_length_days

gem_path = File.join Gem.user_home, ".gem"

Dir.mkdir gem_path

end

def test_build_auto_resign_cert

gem_path = File.join Gem.user_home, ".gem"

Dir.mkdir gem_path

require 'rubygems/test_case'

require 'rubygems/commands/cert_command'

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

end

assert_equal "invalid argument: --sign #{nonexistent}: does not exist",

e.message

end

@b_2 = util_spec 'b', 3

install_gem @b_1

install_gem @b_2

@cmd.options[:args] = []

nil, "default/gem.rb")

default_gem_spec.executables = ["default_command"]

default_gem_spec.files += ["default_gem.so"]

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

expected = [

[RbConfig::CONFIG['bindir'], 'default_command'],

[RbConfig::CONFIG['rubylibdir'], 'default/gem.rb'],

].sort.map{|a|File.join a }.join "\n"

assert_equal expected, @ui.output.chomp

util_gem 'commands' do |out, err|

mgr.command_names.each do |cmd|

end

assert_empty err

refute_match 'No command found for ', out

end

end

def test_gem_no_args_shows_help

util_gem do |out, err|

assert_match(/Usage:/, out)

expected = [

"ERROR: Could not find a valid gem 'non-existent_with-hint' (>= 0) in any repository",

]

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

@stub_fetcher.data["#{Gem.host}/api/v1/gems/freewill/owners"] = [

[response_fail, 401, 'Unauthorized'],

]

@otp_ui = Gem::MockGemUi.new "111111\n"

assert_match 'Code: ', @otp_ui.output

assert_equal '111111', @stub_fetcher.last_request['OTP']

end

end

assert_equal([

"Restoring gems to pristine condition...",

"Cached gem for a-2 not found, attempting to fetch...",

], @ui.output.split("\n"))

assert_empty @ui.error

def test_execute_default_gem

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

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

keys = {

:rubygems_api_key => 'KEY',

}

FileUtils.mkdir_p File.dirname Gem.configuration.credentials_path

keys = {

:rubygems_api_key => 'KEY',

}

FileUtils.mkdir_p File.dirname Gem.configuration.credentials_path

keys = {

:rubygems_api_key => 'KEY',

}

FileUtils.mkdir_p File.dirname Gem.configuration.credentials_path

api_key = "PRIVKEY"

keys = {

}

FileUtils.mkdir_p File.dirname Gem.configuration.credentials_path

@fetcher.data["#{Gem.host}/api/v1/gems"] = [

[response_fail, 401, 'Unauthorized'],

]

@otp_ui = Gem::MockGemUi.new "111111\n"

assert_equal '111111', @fetcher.last_request['OTP']

end

private

def singleton_gem_class

spec_fetcher {|fetcher| fetcher.spec 'a', 2 }

a1 = new_default_spec 'a', 1

use_ui @stub_ui do

@cmd.execute

def test_execute_show_default_gems_with_platform

a1 = new_default_spec 'a', 1

a1.platform = 'java'

use_ui @stub_ui do

@cmd.execute

end

a1 = new_default_spec 'a', 1

@cmd.handle_options %w[-l -d]

bundler/exe/bundle

bundler/lib/bundler.rb

bundler/lib/bundler/b.rb

bundler/lib/bundler/templates/.circleci/config.yml

bundler/lib/bundler/templates/.travis.yml

bundler/man/bundle-b.1

bundler/man/gemfile.5

]

create_dummy_files(filelist)

assert_match %r{\A#!\s*#{bin_env}#{ruby_exec}}, File.read(gem_bin_path)

end

end

def test_bundler_man1_files_in

@cmd.bundler_man1_files_in('bundler/man').sort

end

def test_bundler_man5_files_in

@cmd.bundler_man5_files_in('bundler/man').sort

end

assert_path_exists File.join(dir, 'bundler.rb')

assert_path_exists File.join(dir, 'bundler/b.rb')

assert_path_exists File.join(dir, 'bundler/templates/.travis.yml')

end

end

@cmd.install_man dir

assert_path_exists File.join("#{dir}/man1", 'bundle-b.1')

assert_path_exists File.join("#{dir}/man5", 'gemfile.5')

end

end

@cmd.remove_old_lib_files lib

files_that_stay.each {|file| assert_path_exists file }

end

gemfile_5_ronn = File.join man, 'man5', 'gemfile.5.ronn'

gemfile_5_txt = File.join man, 'man5', 'gemfile.5.txt'

create_dummy_files(files_that_go + files_that_stay)

assert_equal api_key, credentials[:rubygems_api_key]

end

# Utility method to capture IO/UI within the block passed

api_key ||= 'a5fdbb6ba150cbb83aad2bb2fede64cf040453903'

response = [api_key, 200, 'OK']

email = '[email protected]'

password = 'secret'

# Set the expected response for the Web-API supplied

ENV['RUBYGEMS_HOST'] = host || Gem::DEFAULT_HOST

fetcher.data[data_key] = response

Gem::RemoteFetcher.fetcher = fetcher

use_ui sign_in_ui do

yield

assert_empty ui.error

end

def test_execute_add_deny_typo_squatting_source

rubygems_org = "https://rubyems.org"

assert_empty @ui.error

end

def test_execute_add_https_rubygems_org

https_rubygems_org = 'https://rubygems.org/'

assert_equal Gem::Version.new("1"), spec.version

end

def test_execute_remote_without_prerelease

spec_fetcher do |fetcher|

fetcher.spec 'foo', '2.0.0'

def test_execute_system_specific_newer_than_or_equal_to_3_2_leaves_plugins_dir_alone

spec_fetcher do |fetcher|

s.files = %w[setup.rb]

end

end

@cmd.options[:args] = []

FileUtils.mkdir_p Gem.plugindir

plugin_file = File.join(Gem.plugindir, 'a_plugin.rb')

yank_uri = 'http://example/api/v1/gems/yank'

@fetcher.data[yank_uri] = [

[response_fail, 401, 'Unauthorized'],

]

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

assert_equal 'key', @fetcher.last_request['Authorization']

assert_equal [yank_uri], @fetcher.paths

end

end

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

end

def test_install_no_document

util_setup_gems

inst = nil

Dir.chdir @tempdir do

inst.install 'a'

end

require 'rubygems/openssl'

def test_install_security_policy

util_setup_gems

exp = {

"b" => [

}

assert_equal exp, @deplist.why_not_ok?

ENV['DESTDIR'] = 'destination'

results = []

all:

\t@#{Gem.ruby} -e "puts %Q{all: \#{ENV['DESTDIR']}}"

install:

\t@#{Gem.ruby} -e "puts %Q{install: \#{ENV['DESTDIR']}}"

end

results = results.join("\n").b

assert_match %r{"DESTDIR=#{ENV['DESTDIR']}" clean$}, results

ENV['DESTDIR'] = 'destination'

results = []

all:

\t@#{Gem.ruby} -e "puts %Q{all: \#{ENV['DESTDIR']}}"

install:

\t@#{Gem.ruby} -e "puts %Q{install: \#{ENV['DESTDIR']}}"

end

results = results.join("\n").b

assert_match %r{"DESTDIR=#{ENV['DESTDIR']}" clean$}, results

output = []

output = output.join "\n"

output = []

error = assert_raises Gem::InstallError do

end

output = output.join "\n"

output = []

output = output.join "\n"

output = []

assert_match(/^current directory:/, output.shift)

assert_equal "sh ./configure --prefix=#{@dest_path}", output.shift

output = []

error = assert_raises Gem::InstallError do

end

shell_error_msg = %r{(\./configure: .*)|((?:[Cc]an't|cannot) open '?\./configure'?(?:: No such file or directory)?)}

end

output = []

assert_contains_make_command 'clean', output[1]

assert_contains_make_command '', output[4]

output = []

assert_match(/^current directory:/, output[0])

assert_match(/^#{Gem.ruby}.* extconf.rb/, output[1])

output = []

assert_equal "creating Makefile\n", output[2]

assert_contains_make_command 'clean', output[4]

output = []

assert_raises Gem::InstallError do

end

assert_equal "creating Makefile\n", output[2]

output = []

error = assert_raises Gem::InstallError do

end

assert_equal 'extconf failed, exit code 1', error.message

output = []

refute_includes(output, "To see why this extension failed to compile, please check the mkmf.log which can be found here:\n")

output = []

assert_contains_make_command 'clean', output[4]

assert_contains_make_command '', output[7]

makefile.puts "install:"

end

assert_contains_make_command 'clean', output[1]

assert_contains_make_command '', output[4]

def test_class_make_no_Makefile

error = assert_raises Gem::InstallError do

end

assert_equal 'Makefile not found', error.message

output = []

build_rake_in do |rake|

output = output.join "\n"

output = []

build_rake_in do |rake|

output = output.join "\n"

output = []

build_rake_in do |rake|

output = output.join "\n"

build_rake_in(false) do |rake|

error = assert_raises Gem::InstallError do

end

assert_match %r{^rake failed}, error.message

args = %w[query]

use_ui @ui do

end

assert_match(/WARNING: query command is deprecated. It will be removed in Rubygems [0-9]+/, @ui.error)

end

def test_info_succeeds

args = %w[info]

use_ui @ui do

end

assert_empty @ui.error

args = %w[list]

use_ui @ui do

end

assert_empty @ui.error

args = %w[search]

use_ui @ui do

end

assert_empty @ui.error

def test_alternate_key_alternate_host

keys = {

:rubygems_api_key => 'KEY',

}

FileUtils.mkdir_p File.dirname Gem.configuration.credentials_path

assert_match 'You have enabled multi-factor authentication. Please enter OTP code.', @sign_in_ui.output

assert_match 'Code: ', @sign_in_ui.output

assert_equal '111111', @fetcher.last_request['OTP']

end

@fetcher.data["#{host}/api/v1/api_key"] = response

Gem::RemoteFetcher.fetcher = @fetcher

use_ui @sign_in_ui do

if args.length > 0

args.concat %w[--vendor] unless Gem.java_platform?

assert @cmd.handles?(args)

end

end

def test_security_policy

@cmd.handle_options %w[-P HighSecurity]

end

def test_security_policy_unknown

@cmd.add_install_update_options

assert_equal true, @cmd.options[:post_install_message]

end

end

end

def test_check_executable_overwrite_default_bin_dir

bindir(Gem.bindir) do

util_conflict_executable false

end

def test_check_executable_overwrite_other_gem

util_conflict_executable true

end

def test_ensure_loadable_spec_security_policy

_, a_gem = util_gem 'a', 2 do |s|

s.add_dependency 'garbage ~> 5'

options = {

:bin_dir => bin_dir,

}

inst = Gem::Installer.at '', options

assert_equal spec, installer.install

assert File.exist?(user_path), 'plugin not written to user plugins_dir'

end

def test_keeps_plugins_up_to_date

# NOTE: version a-2 is already installed by setup hooks

Gem::Package.build @spec

end

end

build_rake_in do

use_ui @ui do

assert_equal @spec, installer.install

assert_path_exists gem_dir

end

def test_install_missing_dirs

installer = setup_base_installer

# reinstall the gem, this is also the same as pristine

use_ui @ui do

installer.install

end

installer = setup_base_installer

@spec.add_dependency 'b', '> 5'

installer = util_setup_gem

use_ui @ui do

assert_raises Gem::InstallError do

def test_process_options_build_root

build_root = File.join @tempdir, 'build_root'

@gem = setup_base_gem

end

def test_shebang_arguments

assert_equal ['exe/executable'], default_spec.files

end

def test_package_attribute

gem = quick_gem 'c' do |spec|

util_make_exec spec, '#!/usr/bin/ruby', 'exe'

'SHA256' => {

'metadata.gz' => metadata_sha256,

'data.tar.gz' => Digest::SHA256.hexdigest(tar),

}

assert_equal expected, YAML.load(checksums)

end

def test_build_auto_signed

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

end

def test_build_auto_signed_encrypted_key

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

end

def test_build_signed

spec = Gem::Specification.new 'build', '1'

spec.summary = 'build'

end

def test_build_signed_encrypted_key

spec = Gem::Specification.new 'build', '1'

spec.summary = 'build'

end

def test_verify_security_policy

package = Gem::Package.new @gem

package.security_policy = Gem::Security::HighSecurity

end

def test_verify_security_policy_low_security

@spec.cert_chain = [PUBLIC_CERT.to_pem]

@spec.signing_key = PRIVATE_KEY

end

def test_verify_security_policy_checksum_missing

@spec.cert_chain = [PUBLIC_CERT.to_pem]

@spec.signing_key = PRIVATE_KEY

end

def test_contents_security_policy

@package.security_policy = Gem::Security::AlmostNoSecurity

end

def test_extract_files_security_policy

@package.security_policy = Gem::Security::AlmostNoSecurity

end

def test_spec_security_policy

@package.security_policy = Gem::Security::AlmostNoSecurity

end

def test_verify

assert @package.verify

end

def test_add_file_signer

signer = Gem::Security::Signer.new PRIVATE_KEY, [PUBLIC_CERT]

end

def test_self_match

end

def test_self_new

require 'rubygems/test_case'

require 'webrick'

warn 'Skipping Gem::RemoteFetcher tests. openssl not found.'

end

def test_fetch_s3_config_creds

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

def test_fetch_s3_config_creds_with_region

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

def test_fetch_s3_config_creds_with_token

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

ENV['AWS_SECRET_ACCESS_KEY'] = 'testpass'

ENV['AWS_SESSION_TOKEN'] = nil

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

ENV['AWS_SECRET_ACCESS_KEY'] = 'testpass'

ENV['AWS_SESSION_TOKEN'] = nil

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

ENV['AWS_SECRET_ACCESS_KEY'] = 'testpass'

ENV['AWS_SESSION_TOKEN'] = 'testtoken'

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

Time.stub :now, Time.at(1561353581) do

def test_fetch_s3_instance_profile_creds

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

def test_fetch_s3_instance_profile_creds_with_region

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

def test_fetch_s3_instance_profile_creds_with_token

Gem.configuration[:s3_source] = {

}

url = 's3://my-bucket/gems/specs.4.8.gz'

def test_fetch_s3_no_host

Gem.configuration[:s3_source] = {

}

url = 's3://other-bucket/gems/specs.4.8.gz'

:SSLCertificate => cert('ssl_cert.pem'),

:SSLPrivateKey => key('ssl_key.pem'),

:SSLVerifyClient => nil,

}.merge(config))

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

res.body = "--- true\n"

def key(filename)

OpenSSL::PKey::RSA.new(File.read(File.join(__dir__, filename)))

end

require 'ostruct'

require 'base64'

warn 'Skipping Gem::Request tests. openssl not found.'

end

@response

end

end

expected = [

'DEPENDENCIES',

' a',

]

assert_equal expected, out

expected = [

'DEPENDENCIES',

' a (~> 2.0)',

]

assert_equal expected, out

' a (2)',

' b',

' b (2)',

]

assert_equal expected, out

'PLATFORMS',

' ruby',

' x86-darwin-8',

]

assert_equal expected, out

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a"] = Marshal.dump data

a_dep = @DR::DependencyRequest.new dep('a'), nil

expected = [

]

assert_equal expected, set.find_all(a_dep)

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a"] = Marshal.dump data

set.prefetch [a_dep]

expected = [

]

assert_equal expected, set.find_all(a_dep)

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a,b"] = Marshal.dump data

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a"] = Marshal.dump data

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a,b"] = Marshal.dump data

{ :name => 'a',

:number => '1',

:platform => 'ruby',

]

@fetcher.data["#{@dep_uri}?gems=a,b"] = Marshal.dump data

expected = [

'net-ssh (>= 2.0.13), 2.2.2 activated',

]

assert_equal expected, conflict.request_path(child.requester)

source = Gem::Source::Vendor.new directory

expected = [

]

assert_equal expected, found

require 'rubygems/test_case'

require 'rubygems/security'

warn 'Skipping Gem::Security tests. openssl not found.'

end

assert_equal key.to_pem, key_from_file.to_pem

end

require 'rubygems/test_case'

warn 'Skipping Gem::Security::Policy tests. openssl not found.'

end

return digests, signatures

end

# frozen_string_literal: true

require 'rubygems/test_case'

warn 'Skipping Gem::Security::Signer tests. openssl not found.'

end

signer.sign 'hello'

end

end

# frozen_string_literal: true

require 'rubygems/test_case'

warn 'Skipping Gem::Security::TrustDir tests. openssl not found.'

end

assert_equal mask, File.stat(@dest_dir).mode unless win_platform?

end

refute rubygems_source.typo_squatting?("rubysertgems.org")

end

def test_typo_squatting_custom_distance_threshold

rubygems_source = Gem::Source.new("https://rubgems.org")

distance_threshold = 5

# frozen_string_literal: true

require 'benchmark'

require 'rubygems/test_case'

require 'pathname'

require 'stringio'

require 'rubygems/ext'

test_cases = {

'i386-mswin32' => 'a-1-x86-mswin32-60',

'i386-mswin32_80' => 'a-1-x86-mswin32-80',

}

test_cases.each do |arch, expected|

specification.define_singleton_method(:find_all_by_name) do |dep_name|

[

specification.new {|s| s.name = "z", s.version = Gem::Version.new("1") },

]

end

"one" => "two",

"home" => "three",

"homepage_uri" => "https://example.com/user/repo",

}

end

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

write_file(spec_path) do |file|

file.print(default_gem_spec.to_ruby)

end

@spec.files += %w[lib/rubygems_plugin.rb]

plugin_path = File.join Gem.plugindir, 'a_plugin.rb'

assert File.exist?(plugin_path), 'plugin not written'

@spec.files += %w[lib/rubygems_plugin.rb]

plugin_path = File.join Gem.plugindir, 'a_plugin.rb'

assert File.exist?(plugin_path), 'plugin not written'

@spec.files += %w[lib/rubygems_plugin.rb]

plugin_path = File.join Gem.plugindir, 'a_plugin.rb'

assert File.exist?(plugin_path), 'plugin not written'

use_ui @ui do

path = Gem::Package.build @spec

installer.install

end

plugin_path = File.join Gem.plugindir, 'a_plugin.rb'

@spec.version = '1'

refute File.exist?(plugin_path), 'version without plugin installed, but plugin written'

@spec.files += %w[lib/rubygems_plugin.rb]

@spec.version = '2'

assert File.exist?(plugin_path), 'version with plugin installed, but plugin not written'

assert_match %r{\Arequire.*a-2/lib/rubygems_plugin\.rb}, File.read(plugin_path), 'written plugin has incorrect content'

@spec.version = '3'

assert File.exist?(plugin_path), 'version with plugin installed, but plugin removed'

assert_match %r{\Arequire.*a-3/lib/rubygems_plugin\.rb}, File.read(plugin_path), 'old version installed, but plugin updated'

@spec.file_name => [

Gem::Validator::ErrorData.new('lib/b.rb', 'Missing file'),

Gem::Validator::ErrorData.new('lib/c.rb', 'Extra file'),

}

assert_equal expected, alien

@cmd.handle_options %w[--platform ruby]

expected = [

]

assert_equal expected, Gem.platforms

c1 = new_default_spec "c", "1", nil, "c/c.rb"

c2 = new_default_spec "c", "2", nil, "c/c.rb"

dir = Dir.mktmpdir("test_require", @tempdir)

dash_i_arg = File.join dir, 'lib'

# Remove an old default gem version directly from disk as if someone ran

# gem cleanup.

# Require gems that have not been removed.

assert_require 'a/b'

def test_default_gem_only

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

assert_require "default/gem"

assert_equal %w[default-2.0.0.0], loaded_spec_names

end

def test_default_gem_require_activates_just_once

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

assert_require "default/gem"

def test_default_gem_and_normal_gem

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

normal_gem_spec = util_spec("default", "3.0", nil,

"lib/default/gem.rb")

install_specs(normal_gem_spec)

def test_default_gem_prerelease

default_gem_spec = new_default_spec("default", "2.0.0",

nil, "default/gem.rb")

normal_gem_higher_prerelease_spec = util_spec("default", "3.0.0.rc2", nil,

"lib/default/gem.rb")

assert_require "default/gem"

assert_equal %w[default-3.0.0.rc2], loaded_spec_names

def test_require_when_gem_defined

default_gem_spec = new_default_spec("default", "2.0.0.0",

nil, "default/gem.rb")

c = Class.new do

def self.gem(*args)

raise "received #gem with #{args.inspect}"

end

end

end

end

private