- @set.reject! {|t| !Gem::Platform.match(t.spec.platform) }

- 'i' => 'install'

- cmd.invoke_with_build_args args, build_args

- gem_name = get_one_optional_argument || find_gemspec

- build_gem(gem_name)

- def find_gemspec

- gemspecs = Dir.glob("*.gemspec").sort

- def build_gem(gem_name)

- gemspec = File.exist?(gem_name) ? gem_name : "#{gem_name}.gemspec"

-

- if File.exist?(gemspec)

- spec = Gem::Specification.load(gemspec)

-

- if options[:build_path]

- Dir.chdir(File.dirname(gemspec)) do

- spec = Gem::Specification.load(File.basename(gemspec))

- build_package(spec)

- end

- else

- build_package(spec)

- end

- alert_error "Gemspec file not found: #{gemspec}"

- def build_package(spec)

-end if defined?(OpenSSL::SSL)

- sign_in

- rubygems_api_request method, "api/v1/gems/#{name}/owners" do |request|

- :bin_dir => bin_dir

- sign_in @host

- rubygems_api_request(*args) do |request|

- gem_metadata["allowed_push_host"]

- lib_files = rb_files_in path

- lib_files.concat(bundler_template_files) if tool == 'Bundler'

-

- pem_files = pem_files_in path

- install_file_list(lib_files + pem_files, lib_dir)

- # Workaround for non-git environment.

- gemspec = File.open('bundler/bundler.gemspec', 'rb'){|f| f.read.gsub(/`git ls-files -z`/, "''") }

- File.open('bundler/bundler.gemspec', 'w'){|f| f.write gemspec }

-

- def pem_files_in(dir)

- Dir.chdir dir do

- Dir[File.join('**', '*pem')]

- end

- end

-

- def rb_files_in(dir)

- Dir[File.join('**', '*rb')]

- Dir['bundle*.1{,.txt,.ronn}']

- Dir['gemfile.5{,.txt,.ronn}']

- end

- end

-

- def bundler_template_files

- Dir.chdir "bundler/lib" do

- Dir.glob(File.join('bundler', 'templates', '**', '*'), File::FNM_DOTMATCH).

- select{|f| !File.directory?(f) }

- end

- end

-

- # for cleanup old bundler files

- def template_files_in(dir)

- Dir.chdir dir do

- Dir.glob(File.join('templates', '**', '*'), File::FNM_DOTMATCH).

- select{|f| !File.directory?(f) }

- lib_files = rb_files_in(new_lib_dir)

- lib_files.concat(template_files_in(new_lib_dir)) if new_lib_dir =~ /bundler/

- old_lib_files = rb_files_in(old_lib_dir)

- old_lib_files.concat(template_files_in(old_lib_dir)) if old_lib_dir =~ /bundler/

- ["1", "5"].each do |section|

- man_files = send(:"bundler_man#{section}_files_in", new_man_dir)

- old_man_dir_with_section = "#{old_man_dir}/man#{section}"

- old_man_files = send(:"bundler_man#{section}_files_in", old_man_dir_with_section)

- man_to_remove = old_man_files - man_files

- remove_file_list(man_to_remove, old_man_dir_with_section)

- end

- terminate_interaction 1 unless ask_yes_no question

- terminate_interaction 1 unless ask_yes_no question

- sign_in @host

- response = rubygems_api_request(method, api, host) do |request|

- def get_platform_from_requirements(requirements)

- Gem.platforms[1].to_s if requirements.key? :added_platform

-if RUBY_VERSION >= "2.5"

- original_warn = method(:warn)

- return original_warn.call(*messages)

- return original_warn.call(*messages, **kw)

- uplevel = start

- kw[:uplevel] = uplevel

- original_warn.call(*messages, **kw)

- RbConfig::CONFIG['ruby_version']

- RbConfig::CONFIG['ruby_version']

- spec.nil? || !Gem::Platform.match(spec.platform)

- :install_as_default => false

- request_set.remote = false unless consider_remote?

- installer_set.ignore_installed = @only_install_dir

- ##

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

-

- def self.make(dest_path, results)

- unless File.exist? 'Makefile'

- target

- run(cmd, results, "make #{target}".rstrip)

- def self.run(command, results, command_name = nil)

- puts("current directory: #{Dir.pwd}")

- results << "current directory: #{Dir.pwd}"

- output, status = Open3.capture2e(env, *command)

- CHDIR_MUTEX.synchronize do

- pwd = Dir.getwd

- Dir.chdir extension_dir

- begin

- results = builder.build(extension, dest_path,

- results, @build_args, lib_dir)

-

- verbose { results.join("\n") }

- ensure

- begin

- Dir.chdir pwd

- rescue SystemCallError

- Dir.chdir dest_path

- end

- end

- end

- def self.build(extension, dest_path, results, args=[], lib_dir=nil)

- unless File.exist?('Makefile')

- run cmd, results

- make dest_path, results

- def self.build(extension, dest_path, results, args=[], lib_dir=nil)

- unless File.exist?('Makefile')

- run cmd, results

- make dest_path, results

- def self.build(extension, dest_path, results, args=[], lib_dir=nil)

- tmp_dest = Dir.mktmpdir(".gem.", ".")

- tmp_dest = get_relative_path(tmp_dest)

- Tempfile.open %w[siteconf .rb], "." do |siteconf|

- "-r" << get_relative_path(siteconf.path) << File.basename(extension)

- run(cmd, results) do |s, r|

- if File.exist? 'mkmf.log'

- FileUtils.mv 'mkmf.log', dest_path

- make dest_path, results

- entries = Dir.entries(tmp_dest) - %w[. ..]

- entries = entries.map {|entry| File.join tmp_dest, entry }

- FileUtils::Entry_.new(tmp_dest).traverse do |ent|

- def self.get_relative_path(path)

- path[0..Dir.pwd.length - 1] = '.' if path.start_with?(Dir.pwd)

- def self.build(extension, dest_path, results, args=[], lib_dir=nil)

- run([Gem.ruby, File.basename(extension), *args], results)

- run(rake + rake_args, results)

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

- return response unless mfa_unauthorized?(response)

- Gem::RemoteFetcher.fetcher.request(uri, request_method) do |req|

- req.add_field "OTP", get_otp

- block.call(req)

- def sign_in(sign_in_host = nil)

- pretty_host = if Gem::DEFAULT_HOST == sign_in_host

- 'RubyGems.org'

- else

- sign_in_host

- end

- response = rubygems_api_request(:get, "api/v1/api_key",

- sign_in_host) do |request|

- say "Signed in."

-require 'time'

- add_option(:"Install/Update", "--minimal-deps",

- options[:minimal_deps] = true

-require 'fileutils'

- File.join Gem.default_specifications_dir, "#{spec.full_name}.gemspec"

- FileUtils.chmod dir_mode, bin_path unless dir_mode == mode

- :post_install_message => true

- require 'pathname'

- @build_root = Pathname.new(@build_root).expand_path

- @bin_dir = File.join(@build_root, options[:bin_dir] || Gem.bindir(@gem_home))

- @gem_home = File.join(@build_root, @gem_home)

- alert_warning "You build with buildroot.\n Build root: #{@build_root}\n Bin dir: #{@bin_dir}\n Gem home: #{@gem_home}"

- def setup_base_installer

- util_installer @spec, @gemhome

- def util_setup_gem(ui = @ui)

- Gem::Installer.at @gem

- def util_installer(spec, gem_home, user=false)

- :user_install => user)

- Gem::Platform.match @platform

-begin

- require "openssl"

-rescue LoadError => e

- raise unless e.path == 'openssl'

-require 'zlib'

- expiration_length_days: Gem.configuration.cert_expiration_length_days

- prefix

- ASCIIZ(dname, 155) # char prefix[155]; ASCII + (Z unless filled)

- attr_accessor :cpu

-

- attr_accessor :os

-

- attr_accessor :version

- Gem.platforms.any? do |local_platform|

- match spec.platform

- 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

-

- require 'time'

- *(OpenSSL::SSL::SSLError if defined?(OpenSSL)) => e

-require 'time'

- require 'openssl'

- rescue defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : Errno::EHOSTDOWN,

- :x64_mingw_21 => x64_mingw

- return unless gem_platforms options

- def gem_platforms(options) # :nodoc:

- next false unless Gem::Platform.match platform

- "~>" => lambda {|v, r| v >= r && v.release < r.bump }

- i # for stable sort

- @spec == other.spec && @request == other.request

- Gem::Platform.match @platform

- matching,

- @dependency == other.dependency && @requester == other.requester

- @remote = consider_remote?

- self.class, @domain, @specs.keys, always_install,

- Gem::Resolver::LockSpecification.new(self, name, version, @sources, platform)

-require 'rubygems/resolver/molinillo/lib/molinillo/gem_metadata'

-require 'rubygems/resolver/molinillo/lib/molinillo/errors'

-require 'rubygems/resolver/molinillo/lib/molinillo/resolver'

-require 'rubygems/resolver/molinillo/lib/molinillo/modules/ui'

-require 'rubygems/resolver/molinillo/lib/molinillo/modules/specification_provider'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/log'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/vertex'

- parent_node = vertex_named(parent_name)

- add_edge(parent_node, vertex, requirement)

- raise CircularDependencyError.new([origin, destination])

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_vertex'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/delete_edge'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/detach_vertex_named'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/set_payload'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/tag'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

- def up(_graph)

- def down(_graph)

- incoming_edges.map(&:requirement) + explicit_requirements

- # @return [Array<Vertex>] the vertices of {#graph} where `self` is a

- vertices = predecessors

- vertices += vertices.map(&:recursive_predecessors).flatten(1)

- vertices.uniq!

- # @return [Array<Vertex>] the vertices of {#graph} where `self` is an

- vertices = successors

- vertices += vertices.map(&:recursive_successors).flatten(1)

- vertices.uniq!

- equal?(other) || successors.any? { |v| v.path_to?(other) }

- @required_by = required_by

- # @param [Array<DependencyGraph::Vertex>] nodes the nodes in the dependency

- def initialize(nodes)

- super "There is a circular dependency between #{nodes.map(&:name).join(' and ')}"

- @dependencies = nodes.map(&:payload).to_set

- def initialize(conflicts)

- conflicts.values.flatten.map(&:requirements).flatten.each do |conflicting|

- VERSION = '0.5.7'.freeze

- output.puts debug_info.split("\n").map { |s| ' ' * depth + s }

- # @attr [Object] possibility the spec that was unable to be activated due

- # to a conflict

- :possibility,

- :activated_by_name

- break unless state.requirements.any? || state.requirement

- activated.freeze

- handle_missing_or_push_dependency_state(initial_state)

- require 'rubygems/resolver/molinillo/lib/molinillo/state'

- require 'rubygems/resolver/molinillo/lib/molinillo/modules/specification_provider'

- require 'rubygems/resolver/molinillo/lib/molinillo/delegates/resolution_state'

- require 'rubygems/resolver/molinillo/lib/molinillo/delegates/specification_provider'

- create_conflict if state.is_a? PossibilityState

- unwind_for_conflict until possibility && state.is_a?(DependencyState)

- # Creates the initial state for the resolution, based upon the

- # @return [DependencyState] the initial state for the resolution

- def initial_state

- original_requested.each { |r| dg.add_vertex(name_for(r), nil, true).tap { |v| v.explicit_requirements << r } }

- requirements = sort_dependencies(original_requested, graph, {})

- initial_requirement = requirements.shift

- DependencyState.new(

- initial_requirement && name_for(initial_requirement),

- requirements,

- graph,

- initial_requirement,

- initial_requirement && search_for(initial_requirement),

- 0,

- {}

- )

- debug(depth) { "Unwinding for conflict: #{requirement} to #{state_index_for_unwind / 2}" }

- sliced_states = states.slice!((state_index_for_unwind + 1)..-1)

- raise VersionConflict.new(c) unless state

- # @return [Integer] The index to which the resolution should unwind in the

- # case of conflict.

- def state_index_for_unwind

- current_requirement = requirement

- existing_requirement = requirement_for_existing_name(name)

- index = -1

- [current_requirement, existing_requirement].each do |r|

- until r.nil?

- current_state = find_state_for(r)

- if state_any?(current_state)

- current_index = states.index(current_state)

- index = current_index if current_index > index

- break

- r = parent_of(r)

- index

- return nil unless activated.vertex_named(name).payload

- states.reverse_each.find { |i| requirement == i.requirement && i.is_a?(DependencyState) }

- end

-

- # @return [Boolean] whether or not the given state has any possibilities

- # left.

- def state_any?(state)

- state && state.possibilities.any?

- def create_conflict

- vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(edge.requirement) }

- activated.each { |v| activated_by_name[v.name] = v.payload if v.payload }

- vertex.payload,

- activated_by_name

- existing_node = activated.vertex_named(name)

- if existing_node.payload

- debug(depth) { "Found existing spec (#{existing_node.payload})" }

- attempt_to_activate_existing_spec(existing_node)

- attempt_to_activate_new_spec

- end

- end

-

- # Attempts to activate the current {#possibility} (given that it has

- # already been activated)

- # @return [void]

- def attempt_to_activate_existing_spec(existing_node)

- existing_spec = existing_node.payload

- if requirement_satisfied_by?(requirement, activated, existing_spec)

- new_requirements = requirements.dup

- push_state_for_requirements(new_requirements, false)

- else

- return if attempt_to_swap_possibility

- create_conflict

- debug(depth) { "Unsatisfied by existing spec (#{existing_node.payload})" }

- unwind_for_conflict

- end

- end

-

- # Attempts to swp the current {#possibility} with the already-activated

- # spec with the given name

- # @return [Boolean] Whether the possibility was swapped into {#activated}

- def attempt_to_swap_possibility

- activated.tag(:swap)

- vertex = activated.vertex_named(name)

- activated.set_payload(name, possibility)

- if !vertex.requirements.

- all? { |r| requirement_satisfied_by?(r, activated, possibility) } ||

- !new_spec_satisfied?

- activated.rewind_to(:swap)

- return

- end

- fixup_swapped_children(vertex)

- activate_spec

- end

-

- # Ensures there are no orphaned successors to the given {vertex}.

- # @param [DependencyGraph::Vertex] vertex the vertex to fix up.

- # @return [void]

- def fixup_swapped_children(vertex) # rubocop:disable Metrics/CyclomaticComplexity

- payload = vertex.payload

- deps = dependencies_for(payload).group_by(&method(:name_for))

- vertex.outgoing_edges.each do |outgoing_edge|

- requirement = outgoing_edge.requirement

- parent_index = @parents_of[requirement].last

- succ = outgoing_edge.destination

- matching_deps = Array(deps[succ.name])

- dep_matched = matching_deps.include?(requirement)

-

- # only push the current index when it was originally required by the

- # same named spec

- if parent_index && states[parent_index].name == name

- @parents_of[requirement].push(states.size - 1)

-

- if matching_deps.empty? && !succ.root? && succ.predecessors.to_a == [vertex]

- debug(depth) { "Removing orphaned spec #{succ.name} after swapping #{name}" }

- succ.requirements.each { |r| @parents_of.delete(r) }

-

- removed_names = activated.detach_vertex_named(succ.name).map(&:name)

- requirements.delete_if do |r|

- # the only removed vertices are those with no other requirements,

- # so it's safe to delete only based upon name here

- removed_names.include?(name_for(r))

- end

- elsif !dep_matched

- debug(depth) { "Removing orphaned dependency #{requirement} after swapping #{name}" }

- # also reset if we're removing the edge, but only if its parent has

- # already been fixed up

- @parents_of[requirement].push(states.size - 1) if @parents_of[requirement].empty?

-

- activated.delete_edge(outgoing_edge)

- requirements.delete(requirement)

- # Attempts to activate the current {#possibility} (given that it hasn't

- # already been activated)

- def attempt_to_activate_new_spec

- if new_spec_satisfied?

- activate_spec

- # @return [Boolean] whether the current spec is satisfied as a new

- # possibility.

- def new_spec_satisfied?

- unless requirement_satisfied_by?(requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by requested spec' }

- return false

- end

-

- locked_requirement = locked_requirement_named(name)

-

- locked_spec_satisfied = !locked_requirement ||

- requirement_satisfied_by?(locked_requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by locked spec' } unless locked_spec_satisfied

-

- locked_spec_satisfied

- def activate_spec

- # @param [Object] activated_spec the specification that has just been

- def require_nested_dependencies_for(activated_spec)

- nested_dependencies = dependencies_for(activated_spec)

- activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d)

- new_requirement = new_requirements.shift

- possibilities = new_requirement ? search_for(new_requirement) : []

- new_requirement, possibilities, depth, conflicts.dup

- # pushed, and the node in {#activated} is removed, and we continue

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph'

- require 'rubygems/resolver/molinillo/lib/molinillo/resolution'

- # @attr [Set<Object>] conflicts unresolved conflicts

- :conflicts

- new(nil, [], DependencyGraph.new, nil, nil, 0, Set.new)

- conflicts.dup

- Gem::Platform.match spec.platform

- Digest::SHA256.hexdigest(canonical_request)

-require 'fileutils'

-if defined?(OpenSSL::SSL)

- @only_signed, @only_trusted,

- expiration_length_days: 365

- :summary => ''

- bundler_api_uri = uri + './api/v1/dependencies'

- source_uri = uri + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"

- spec_path = uri + "#{file_name}.gz"

- levenshtein_distance(@uri.host, host) <= distance_threshold

- if matching_platform and !Gem::Platform.match(tup.platform)

- '"test_file=x" is a shortcut for "test_files=[x]"'

- 'Added Fixnum validation to the specification_version'

- 'Added sandboxed freeform metadata to the specification version.'

- ]

- @@stubs_by_name = stubs.select {|s| Gem::Platform.match s.platform }.group_by(&:name)

- stubs = installed_stubs(dirs, pattern).select {|s| Gem::Platform.match s.platform } + default_stubs(pattern)

- @metadata

- :metadata

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

-MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs

-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3

-d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j

-ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL

-MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3

-LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug

-RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm

-+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW

-PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM

-xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB

-Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3

-hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg

-EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF

-MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA

-FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec

-nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z

-eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF

-hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2

-Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe

-vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep

-+OkuE6N36B9K

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

- 'lib' => ['lib'].freeze

- output.inspect

- output.inspect

- FileUtils.mkdir_p @gemhome

- @default_dir = File.join @tempdir, 'default'

- @default_spec_dir = File.join @default_dir, "specifications", "default"

- RbConfig::CONFIG['default_gem_home'] = @default_dir

- Gem.instance_variable_set(:@default_dir, @default_dir)

- FileUtils.mkdir_p @default_spec_dir

- Gem::Security.reset

-

- Gem::Installer.for_spec(spec).install

- install_default_specs(*specs)

-

- specs.each do |spec|

- File.open spec.loaded_from, 'w' do |io|

- io.write spec.to_ruby_for_cache

- end

- end

- end

-

- ##

- # Install the provided default specs

-

- def install_default_specs(*specs)

- spec.loaded_from = File.join(@default_spec_dir, spec.spec_name)

- end if defined?(OpenSSL::SSL)

-require 'cgi'