- VERSION = "3.0.0.beta1"

- ]

- ]

- ]

- ]

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

- when "gems.rb" then "gems.locked"

- else "#{gemfile}.lock"

- end.dup.untaint

- HELP = <<-HELP

- ]

- }

- Gem::Package.build spec, options[:force], options[:strict]

- expiration_length_days = options[:expiration_length_days]

- age =

- if expiration_length_days.nil? || expiration_length_days == 0

- Gem::Security::ONE_YEAR

- else

- Gem::Security::ONE_DAY * expiration_length_days

- end

- cert = Gem::Security.create_cert_email email, key, age

- EXAMPLES = <<-EOF

- GEM_DEPENDENCIES = <<-EOF

- PLATFORMS = <<-'EOF'

- ]

- ENV_PATHS = %w[/usr/bin/env /bin/env]

- options[:regenerate_binstubs] = value

- end

- ) do |value, options|

- # Make sure old rubygems isn't loaded

- old = ENV["RUBYOPT"]

- ENV.delete("RUBYOPT") if old

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

- ENV["RUBYOPT"] = old if old

- ]

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

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

- @home = @hash[:gemhome] if @hash.key? :gemhome

- @path = @hash[:gempath] if @hash.key? :gempath

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

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

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

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

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

- DEFAULT_HOST = "https://rubygems.org"

- RbConfig::CONFIG['rubylibprefix'],

- 'gems',

- RbConfig::CONFIG['ruby_version']

- ]

- ]

- File.expand_path File.join @gem_dir, File.dirname(extension)

- cmd = [Gem.ruby, "-r", get_relative_path(siteconf.path), File.basename(extension), *args].join ' '

- # Deal with possible spaces in the path, e.g. C:/Program Files

- dest_path = '"' + dest_path.to_s + '"' if dest_path.to_s.include?(' ')

-

- cmd = "#{rake} RUBYARCHDIR=#{dest_path} RUBYLIBDIR=#{dest_path}" # ENV is frozen

-

- run cmd, results

- add_option(:Deprecated, '--[no-]rdoc',

- 'Generate RDoc for installed gems',

- 'Use --document instead') do |value, options|

- if value then

- options[:document] << 'rdoc'

- else

- options[:document].delete 'rdoc'

- end

-

- options[:document].uniq!

- end

-

- add_option(:Deprecated, '--[no-]ri',

- 'Generate ri data for installed gems.',

- 'Use --document instead') do |value, options|

- if value then

- options[:document] << 'ri'

- else

- options[:document].delete 'ri'

- end

-

- options[:document].uniq!

- end

-

- ENV_PATHS = %w[/usr/bin/env /bin/env]

- def self.build spec, skip_validation=false, strict_validation=false

- setup_signer

- def setup_signer

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

- ]

- RUBY = 'ruby'

- CURRENT = 'current'

- # +dns+: An object to use for DNS resolution of the API endpoint.

- # By default, use Resolv::DNS.

- #

- def initialize(proxy=nil, dns=Resolv::DNS.new, headers={})

- @dns = dns

- # Given a source at +uri+, calculate what hostname to actually

- # connect to query the data for it.

-

- def api_endpoint(uri)

- host = uri.host

-

- begin

- res = @dns.getresource "_rubygems._tcp.#{host}",

- Resolv::DNS::Resource::IN::SRV

- rescue Resolv::ResolvError => e

- verbose "Getting SRV record failed: #{e}"

- uri

- else

- target = res.target.to_s.strip

-

- if URI("http://" + target).host.end_with?(".#{host}")

- return URI.parse "#{uri.scheme}://#{target}#{uri.path}"

- end

-

- uri

- end

- end

-

- ##

- }

- }

- }

- }

- }

- PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{Gem::Version::VERSION_PATTERN})\\s*" # :nodoc:

- DefaultRequirement = [">=", Gem::Version.new(0)]

-private

- PATTERN = "%20s: %d\n"

- )

- )

- }

- }

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

- @only_signed, @only_trusted,

- ]

- re_signed_cert = Gem::Security.re_sign(expired_cert, private_key)

- def initialize key, cert_chain, passphrase = nil

- re_sign_key

- def re_sign_key # :nodoc:

- cert = Gem::Security.re_sign(old_cert, @key)

- }

- SEARCH = <<-ERB

- DOC_TEMPLATE = <<-'ERB'

- RDOC_CSS = <<-CSS

- RDOC_NO_DOCUMENTATION = <<-'ERB'

- RDOC_SEARCH_TEMPLATE = <<-'ERB'

- }

- @api_uri = nil

- end

-

- ##

- # Use an SRV record on the host to look up the true endpoint for the index.

-

- def api_uri # :nodoc:

- require 'rubygems/remote_fetcher'

- @api_uri ||= Gem::RemoteFetcher.fetcher.api_endpoint uri

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

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

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

- cache_dir = cache_dir uri

- uri.path << '.rz'

- spec = fetcher.fetch_path uri

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

- fetcher.download spec, api_uri.to_s, dir

- if api = api_uri

- else

- matches.uniq.sort_by { |name, dist| dist }

- end

-# -*- coding: utf-8 -*-

- 3 => [

- 'Added Fixnum validation to the specification_version'

- 4 => [

- }

- }

- when [], {}, true, false, nil, Numeric, Symbol

- v.inspect

- when String

- v.dump

- when Numeric

- "default_value(:#{k})"

- else

- "default_value(:#{k}).dup"

- end

- ######################################################################

- # :section: Recommended gemspec attributes

-

- # Singular writer for #authors

- # Usage:

- #

- # spec.author = 'John Jones'

-

- def author= o

- self.authors = [o]

- end

-

- ##

- # Sets the list of authors, ensuring it is an array.

- ] # :nodoc:

- if !name.is_a?(String) then

- elsif name !~ /[a-zA-Z]/ then

- elsif name !~ VALID_NAME_PATTERN then

- when Gem::Platform, Gem::Platform::RUBY then # ok

- else

- error "invalid platform #{platform.inspect}, see Gem::Platform"

- when :dependencies then

- Gem::Dependency

- else

- String

- PREFIX = "# stub: "

- OPEN_MODE = 'r:UTF-8:-'

- }

- }

- PRIVATE_KEY_PASSPHRASE = 'Foo bar'

- attr_reader :api_endpoints

- @api_endpoints = {}

- end

-

- def api_endpoint(uri)

- @api_endpoints[uri] || uri

-

- unless @api_endpoints.empty? then

- q.breakable

- q.text 'API endpoints:'

-

- q.breakable

- q.pp @api_endpoints.keys

- end

- )

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

- end

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

-SIMPLE_GEM = <<-GEMDATA

- PLUGINS_LOADED = []

- BUNDLER_FULL_NAME = "bundler-#{Bundler::VERSION}"

- expected = if Gem::USE_BUNDLER_FOR_GEMDEPS

- <<-EXPECTED

- EXPECTED

- else

- <<-EXPECTED

- EXPECTED

- end

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

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

- CERT_FILE = cert_path 'public3072'

- SIGNING_KEY = key_path 'private3072'

-

- ]

- "--no-ri", "--no-rdoc"]

- assert_equal([

- "Restoring gems to pristine condition...",

- "Skipped default-2.0.0.0, it is a default gem",

- ],

- @ui.output.split("\n"))

- BUNDLER_VERS = "1.16.2"

- Gem::Dependency.new("a", ">= 1")

- ]

- assert_match %r%^#{Regexp.escape rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, output

- assert_match %r%^#{Regexp.escape rake} RUBYARCHDIR=#{Regexp.escape @dest_path} RUBYLIBDIR=#{Regexp.escape @dest_path}%, output

- --rdoc

- --ri

- def test_rdoc

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

-

- assert_equal %w[rdoc ri], @cmd.options[:document].sort

- end

-

- def test_rdoc_no

- @cmd.handle_options %w[--no-rdoc]

-

- assert_equal %w[ri], @cmd.options[:document]

- end

-

- def test_ri

- @cmd.handle_options %w[--no-ri]

-

- assert_equal %w[], @cmd.options[:document]

- end

-

- File.join(@tempdir, 'foo'),

- File.join(@tempdir, 'bar'),

- ENV["GEM_HOME"],

- ]

- File.join(@tempdir, 'foo'),

- File.join(@tempdir, 'bar'),

- ] + Gem.default_path << ENV["GEM_HOME"]

- File.join(@tempdir, 'foo'),

- File.join(@tempdir, 'bar'),

- ] + Gem.default_path << ENV["GEM_HOME"]

- SERVER_DATA = <<-EOY

- def test_api_endpoint

- uri = URI.parse "http://example.com/foo"

- target = MiniTest::Mock.new

- target.expect :target, "gems.example.com"

-

- dns = MiniTest::Mock.new

- dns.expect :getresource, target, [String, Object]

-

- fetch = Gem::RemoteFetcher.new nil, dns

- assert_equal URI.parse("http://gems.example.com/foo"), fetch.api_endpoint(uri)

-

- target.verify

- dns.verify

- end

-

- def test_api_endpoint_ignores_trans_domain_values

- uri = URI.parse "http://gems.example.com/foo"

- target = MiniTest::Mock.new

- target.expect :target, "blah.com"

-

- dns = MiniTest::Mock.new

- dns.expect :getresource, target, [String, Object]

-

- fetch = Gem::RemoteFetcher.new nil, dns

- assert_equal URI.parse("http://gems.example.com/foo"), fetch.api_endpoint(uri)

-

- target.verify

- dns.verify

- end

-

- def test_api_endpoint_ignores_trans_domain_values_that_starts_with_original

- uri = URI.parse "http://example.com/foo"

- target = MiniTest::Mock.new

- target.expect :target, "example.combadguy.com"

-

- dns = MiniTest::Mock.new

- dns.expect :getresource, target, [String, Object]

-

- fetch = Gem::RemoteFetcher.new nil, dns

- assert_equal URI.parse("http://example.com/foo"), fetch.api_endpoint(uri)

-

- target.verify

- dns.verify

- end

-

- def test_api_endpoint_ignores_trans_domain_values_that_end_with_original

- uri = URI.parse "http://example.com/foo"

- target = MiniTest::Mock.new

- target.expect :target, "badexample.com"

-

- dns = MiniTest::Mock.new

- dns.expect :getresource, target, [String, Object]

-

- fetch = Gem::RemoteFetcher.new nil, dns

- assert_equal URI.parse("http://example.com/foo"), fetch.api_endpoint(uri)

-

- target.verify

- dns.verify

- end

-

- def test_api_endpoint_ignores_trans_domain_values_that_end_with_original_in_path

- uri = URI.parse "http://example.com/foo"

- target = MiniTest::Mock.new

- target.expect :target, "evil.com/a.example.com"

-

- dns = MiniTest::Mock.new

- dns.expect :getresource, target, [String, Object]

-

- fetch = Gem::RemoteFetcher.new nil, dns

- assert_equal URI.parse("http://example.com/foo"), fetch.api_endpoint(uri)

-

- target.verify

- dns.verify

- end

-

- def test_api_endpoint_timeout_warning

- uri = URI.parse "http://gems.example.com/foo"

-

- dns = MiniTest::Mock.new

- def dns.getresource arg, *rest

- raise Resolv::ResolvError.new('timeout!')

- end

-

- fetch = Gem::RemoteFetcher.new nil, dns

- begin

- old_verbose, Gem.configuration.verbose = Gem.configuration.verbose, 1

- endpoint = use_ui @stub_ui do

- fetch.api_endpoint(uri)

- end

- ensure

- Gem.configuration.verbose = old_verbose

- end

-

- assert_equal uri, endpoint

-

- assert_equal "Getting SRV record failed: timeout!\n", @stub_ui.output

-

- dns.verify

- end

-

- )

- def test_api_uri

- assert_equal @source.api_uri, @source.uri

- end

-

- def test_api_uri_resolved_from_remote_fetcher

- uri = URI.parse "http://gem.example/foo"

- @fetcher.api_endpoints[uri] = URI.parse "http://api.blah"

-

- src = Gem::Source.new uri

- assert_equal URI.parse("http://api.blah"), src.api_uri

- end

-

- LEGACY_YAML_SPEC = <<-EOF

- LEGACY_RUBY_SPEC = <<-EOF

- a-2

- a-2-x86-my_platform-1

- a-3-x86-other_platform-1

- ]

- assert_equal "0\n", Gem::Util.popen(Gem.ruby, '-e', 'p 0')

- Gem::Util.silent_system Gem.ruby, '-e', 'puts "hello"; warn "hello"'