rubygems-update 3.0.3 → 3.4.12

data/util/ci

@@ -1,77 +0,0 @@
-#!/usr/bin/env ruby
-
-class Tool
-  def initialize(name)
-    @name = name
-  end
-
-  def bundler?
-    @name == 'bundler'
-  end
-
-  def rubygems?
-    @name == 'rubygems'
-  end
-
-  def dir
-    if rubygems?
-      File.expand_path('../..', __FILE__)
-    else
-      File.expand_path('../../bundler', __FILE__)
-    end
-  end
-end
-
-TOOL = Tool.new(ENV.fetch("TEST_TOOL") { abort "must specify a TEST_TOOL" })
-
-def run(command, args = [])
-  Dir.chdir(TOOL.dir) do
-    unless system(command, *args)
-      abort "running `#{command} #{args.join(" ")}` failed"
-    end
-  end
-end
-
-def with_retries(attempts = 3)
-  yield
-rescue StandardError, SystemExit => e
-  attempts -= 1
-  if attempts > 0
-    warn "Command failed (#{e}). Retrying #{attempts -= 1} more times."
-    retry
-  else
-    raise
-  end
-end
-
-case ARGV
-when %w(before_script)
-  if TOOL.rubygems?
-    run('gem', %W(uninstall executable-hooks gem-wrappers bundler-unload -x --force -i #{`gem env home`.strip}@global))
-
-    if RUBY_VERSION >= "2.6.0"
-      run('gem', %w(install minitest -v 5.4.3))
-    end
-
-    # 2.5 images of Travis was broken about bundler installation.
-    if RUBY_VERSION >= "2.5.0" && RUBY_VERSION < "2.6.0"
-      run('gem', %w(install bundler -v 1.16.2))
-    end
-
-    run('gem', %w(list --details))
-    run('gem', %w(env))
-  else
-    with_retries { run('rake', %w(spec:travis:deps)) }
-  end
-when %w(rubocop)
-  run('gem', %w(install rubocop -v ~>0.60.0))
-  run('util/rubocop')
-when %w(script)
-  if TOOL.rubygems?
-    run('rake test')
-  else
-    run('rake', %w(spec:travis -t))
-  end
-else
-  abort "unknown args #{ARGV.inspect}"
-end

data/util/create_certs.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-require 'openssl'
-require 'time'
-
-class CertificateBuilder
-
-  attr_reader :start
-
-  def initialize(key_size = 2048)
-    @start          = Time.utc 2012, 01, 01, 00, 00, 00
-    @end_of_time    = Time.utc 9999, 12, 31, 23, 59, 59
-    @end_of_time_32 = Time.utc 2038, 01, 19, 03, 14, 07
-
-    @key_size = key_size
-    @serial = 0
-  end
-
-  def create_certificates(key, subject, issuer_key = key, issuer_cert = nil,
-                          not_before: @start, not_after: :end_of_time,
-                          is_ca: false)
-    certificates = []
-
-    not_before, not_before_32 = validity_for not_before
-    not_after,  not_after_32  = validity_for not_after
-    issuer_cert, issuer_cert_32 = issuer_cert
-
-    certificates <<
-      create_certificate(key, subject, issuer_key, issuer_cert,
-                         not_before, not_after, is_ca)
-    certificates <<
-      create_certificate(key, subject, issuer_key, issuer_cert_32,
-                         not_before_32, not_after_32, is_ca)
-
-    certificates
-  end
-
-  def create_certificate(key, subject, issuer_key, issuer_cert,
-                         not_before, not_after, is_ca)
-    cert = OpenSSL::X509::Certificate.new
-    issuer_cert ||= cert # if not specified, create self signing cert
-
-    cert.version    = 2
-    cert.serial     = 0
-
-    cert.not_before = not_before
-    cert.not_after  = not_after
-
-    cert.serial = next_serial
-
-    cert.public_key = key.public_key
-
-    cert.subject = OpenSSL::X509::Name.new [%W[CN #{subject}], %w[DC example]]
-    cert.issuer  = issuer_cert.subject
-
-    ef = OpenSSL::X509::ExtensionFactory.new issuer_cert, cert
-
-    cert.extensions = [
-      ef.create_extension('subjectAltName', "email:#{subject}@example"),
-      ef.create_extension('subjectKeyIdentifier', 'hash')
-    ]
-
-    if cert != issuer_cert  # not self-signed cert
-      cert.add_extension ef.create_extension('authorityKeyIdentifier', 'keyid:always')
-    end
-
-    if is_ca
-      cert.add_extension ef.create_extension('basicConstraints', 'CA:TRUE', true)
-      cert.add_extension ef.create_extension('keyUsage', 'keyCertSign', true)
-    end
-
-    cert.sign issuer_key, OpenSSL::Digest::SHA1.new
-
-    puts "created cert - subject: #{cert.subject}, issuer: #{cert.issuer}"
-    cert
-  end
-
-  def create_key
-    puts "creating key"
-    OpenSSL::PKey::RSA.new @key_size
-  end
-
-  def create_keys(names)
-    keys = {}
-
-    names.each do |name|
-      keys[name] = create_key
-    end
-
-    keys
-  end
-
-  def next_serial
-    serial = @serial
-    @serial += 1
-    serial
-  end
-
-  def validity_for(time)
-    if time == :end_of_time
-      validity    = @end_of_time
-      validity_32 = @end_of_time_32
-    else
-      validity = validity_32 = time
-    end
-
-    [validity, validity_32]
-  end
-
-end
-
-cb = CertificateBuilder.new
-
-keys = cb.create_keys [
-  :alternate,
-  :child,
-  :grandchild,
-  :invalid,
-  :invalidchild,
-  :private,
-]
-
-keys[:public] = keys[:private].public_key
-
-certs = {}
-certs[:public] =
-  cb.create_certificates(keys[:private], 'nobody',
-                         is_ca: true)
-certs[:child] =
-  cb.create_certificates(keys[:child], 'child',
-                         keys[:private], certs[:public],
-                         is_ca: true)
-certs[:alternate] =
-  cb.create_certificates(keys[:alternate], 'alternate')
-certs[:expired] =
-  cb.create_certificates(keys[:private], 'nobody',
-                         not_before: Time.at(0),
-                         not_after: Time.at(0))
-certs[:future] =
-  cb.create_certificates(keys[:private], 'nobody',
-                         not_before: :end_of_time,
-                         not_after: :end_of_time)
-certs[:invalid_issuer] =
-  cb.create_certificates(keys[:invalid], 'invalid',
-                         keys[:invalid], certs[:public],
-                         is_ca: true)
-certs[:grandchild] =
-  cb.create_certificates(keys[:grandchild], 'grandchild',
-                         keys[:child], certs[:child])
-certs[:invalid_signer] =
-  cb.create_certificates(keys[:invalid], 'invalid',
-                         keys[:private], certs[:invalid])
-certs[:invalidchild] =
-  cb.create_certificates(keys[:invalidchild], 'invalidchild',
-                         keys[:invalid], certs[:child])
-certs[:wrong_key] =
-  cb.create_certificates(keys[:alternate], 'nobody')
-
-base_dir = 'test/rubygems'
-
-keys.each do |name, key|
-  dest = File.join base_dir, "#{name}_key.pem"
-  File.write dest, key.to_pem
-end
-
-certs.each do |name, (cert, cert_32)|
-  dest = File.join base_dir, "#{name}_cert.pem"
-  File.write dest, cert.to_pem
-
-  dest = File.join base_dir, "#{name}_cert_32.pem"
-  File.write dest, cert_32.to_pem
-end

data/util/create_encrypted_key.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require 'openssl'
-
-private_key_path = '../../test/rubygems/private_key.pem'
-private_key_path = File.expand_path private_key_path, __FILE__
-
-key = OpenSSL::PKey::RSA.new File.read private_key_path
-
-cipher = OpenSSL::Cipher.new 'DES-CBC'
-
-encrypted_key_path = '../../test/rubygems/encrypted_private_key.pem'
-encrypted_key_path = File.expand_path encrypted_key_path, __FILE__
-
-open encrypted_key_path, 'w' do |io|
-  io.write key.to_pem cipher, 'Foo bar'
-end

data/util/generate_spdx_license_list.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require 'json'
-require 'net/http'
-require 'uri'
-
-licenses_json = Net::HTTP.get(URI('https://spdx.org/licenses/licenses.json'))
-licenses = JSON.parse(licenses_json)['licenses'].map do |licenseObject|
-  licenseObject['licenseId']
-end
-exceptions_json = Net::HTTP.get(URI('https://spdx.org/licenses/exceptions.json'))
-exceptions = JSON.parse(exceptions_json)['exceptions'].map do |exceptionObject|
-  exceptionObject['licenseExceptionId']
-end
-
-open 'lib/rubygems/util/licenses.rb', 'w' do |io|
-  io.write <<-RUBY
-# frozen_string_literal: true
-require 'rubygems/text'
-
-class Gem::Licenses
-  extend Gem::Text
-
-  NONSTANDARD = 'Nonstandard'.freeze
-
-  # Software Package Data Exchange (SPDX) standard open-source software
-  # license identifiers
-  LICENSE_IDENTIFIERS = %w(
-      #{licenses.sort.join "\n      "}
-  ).freeze
-
-  # exception identifiers
-  EXCEPTION_IDENTIFIERS = %w(
-      #{exceptions.sort.join "\n      "}
-  ).freeze
-
-  REGEXP = %r{
-    \\A
-    (
-      \#{Regexp.union(LICENSE_IDENTIFIERS)}
-      \\+?
-      (\\s WITH \\s \#{Regexp.union(EXCEPTION_IDENTIFIERS)})?
-      | \#{NONSTANDARD}
-    )
-    \\Z
-  }ox.freeze
-
-  def self.match?(license)
-    !REGEXP.match(license).nil?
-  end
-
-  def self.suggestions(license)
-    by_distance = LICENSE_IDENTIFIERS.group_by do |identifier|
-      levenshtein_distance(identifier, license)
-    end
-    lowest = by_distance.keys.min
-    return unless lowest < license.size
-    by_distance[lowest]
-  end
-end
-  RUBY
-end

data/util/patch_with_prs.rb

@@ -1,77 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift File.expand_path("../../lib", __FILE__)
-require "rubygems"
-require "optparse"
-
-def confirm(prompt = "")
-  loop do
-    print(prompt)
-    print(": ") unless prompt.empty?
-    break if $stdin.gets.strip == "y"
-  end
-rescue Interrupt
-  abort
-end
-
-def sh(*cmd)
-  return if system(*cmd)
-  raise "#{cmd} failed"
-end
-
-version = nil
-prs = []
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{__FILE__} [options]"
-
-  opts.on("--version=VERSION", "The version to release") do |v|
-    version = v
-  end
-end.parse!
-
-prs = ARGV.dup
-
-version ||= begin
-  version = Gem::Version.new(Gem::VERSION)
-  segments = version.segments
-  if segments.last.is_a?(String)
-    segments << "1"
-  else
-    segments[-1] += 1
-  end
-  segments.join(".")
-end
-
-confirm "You are about to release #{version}, currently #{Gem::VERSION}"
-
-branch = version.split(".", 3)[0, 2].join(".")
-sh("git", "checkout", branch)
-sh("git", "submodule", "update", "--init", "--recursive")
-
-commits = `git log --oneline origin/master --`.split("\n").map {|l| l.split(/\s/, 2) }.reverse
-commits.select! {|_sha, message| message =~ /(Auto merge of|Merge pull request|Merge) ##{Regexp.union(*prs)}/ }
-
-unless system("git", "cherry-pick", "-x", "-m", "1", *commits.map(&:first))
-  abort unless system("zsh")
-end
-
-sh(Gem.ruby, File.expand_path("../update_changelog.rb", __FILE__))
-
-version_file = "lib/rubygems.rb"
-version_contents = File.read(version_file)
-unless version_contents.sub!(/^(\s*VERSION = )(["'])#{Gem::Version::VERSION_PATTERN}\2/, "\\1#{version.to_s.dump}")
-  abort "failed to update #{version_file}, is it in the expected format?"
-end
-File.open(version_file, "w") {|f| f.write(version_contents) }
-
-confirm "Update changelog"
-sh("git", "commit", "-am", "Version #{version} with changelog")
-sh("rake", "release", "VERSION=#{version}")
-sh("git", "push")
-sh("git", "checkout", "master")
-sh("git", "pull")
-unless system("git", "merge", "v#{version}", "--no-edit")
-  abort unless system("zsh")
-end
-sh("git", "push")

data/util/rubocop

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-begin
-  load Gem.bin_path("rubocop", "rubocop", "~> 0.60.0")
-rescue Gem::GemNotFoundException
-  abort "Install the rubocop gem (~> 0.60.0) to run a static analysis"
-end

data/util/update_bundled_ca_certificates.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-require 'net/http'
-require 'openssl'
-require 'fileutils'
-
-URIS = [
-  URI('https://rubygems.org'),
-  URI('https://index.rubygems.org'),
-  URI('https://staging.rubygems.org'),
-  URI('https://fastly.rubygems.org'),
-  URI('https://rubygems.global.ssl.fastly.net'),
-].freeze
-
-HOSTNAMES_TO_MAP = [
-  'rubygems.global.ssl.fastly.net',
-  'rubygems.org',
-  'index.rubygems.org'
-].freeze
-
-def connect_to(uri, store)
-  # None of the URIs are IPv6, so URI::Generic#hostname(ruby 1.9.3+) isn't needed
-  http = Net::HTTP.new uri.host, uri.port
-
-  http.use_ssl = uri.scheme.downcase == 'https'
-  http.ssl_version = :TLSv1_2
-  http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-  http.cert_store = store
-
-  http.get '/'
-
-  true
-rescue OpenSSL::SSL::SSLError
-  false
-end
-
-def load_certificates(io)
-  cert_texts =
-    io.read.scan(/^-{5}BEGIN CERTIFICATE-{5}.*?^-{5}END CERTIFICATE-{5}/m)
-
-  cert_texts.map do |cert_text|
-    OpenSSL::X509::Certificate.new cert_text
-  end
-end
-
-def show_certificates(certificates)
-  certificates.each do |certificate|
-    p certificate.subject.to_a
-  end
-end
-
-def store_for(certificates)
-  store = OpenSSL::X509::Store.new
-  certificates.each do |certificate|
-    store.add_cert certificate
-  end
-
-  store
-end
-
-def test_certificates(certificates, uri)
-  1.upto certificates.length do |n|
-    puts "combinations of #{n} certificates"
-    certificates.combination(n).each do |combination|
-      match = test_uri uri, combination
-
-      if match
-        $needed_combinations << match
-        puts
-        puts match.map { |certificate| certificate.subject }
-        return
-      else
-        print '.'
-      end
-    end
-    puts
-  end
-end
-
-def test_uri(uri, certificates)
-  store = store_for certificates
-
-  verified = connect_to uri, store
-
-  return certificates if verified
-
-  nil
-end
-
-def hostname_certificate_mapping(certificates)
-  mapping = {}
-  HOSTNAMES_TO_MAP.each do |hostname|
-    uri = URI("https://#{hostname}")
-    certificates.each do |cert|
-      match = test_uri uri, [cert]
-      mapping[hostname] = cert if match && !mapping.values.include?(cert)
-    end
-  end
-  mapping
-end
-
-def write_certificates(certificates)
-  mapping = hostname_certificate_mapping(certificates)
-  mapping.each do |hostname, certificate|
-    subject = certificate.subject.to_a
-    name = (subject.assoc('CN') || subject.assoc('OU'))[1]
-    name = name.delete ' .-'
-
-    FileUtils.mkdir_p("lib/rubygems/ssl_certs/#{hostname}")
-    destination = "lib/rubygems/ssl_certs/#{hostname}/#{name}.pem"
-
-    warn "overwriting certificate #{name}" if File.exist? destination
-
-    open destination, 'w' do |io|
-      io.write certificate.to_pem
-    end
-  end
-end
-
-io =
-  if ARGV.empty?
-    open OpenSSL::X509::DEFAULT_CERT_FILE
-  else
-    ARGF
-  end
-
-certificates = load_certificates io
-puts "loaded #{certificates.length} certificates"
-
-$needed_combinations = []
-
-URIS.each do |uri|
-  puts uri
-
-  test_certificates certificates, uri
-end
-
-needed = $needed_combinations.flatten.uniq
-
-write_certificates needed

data/util/update_changelog.rb

@@ -1,67 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'json'
-require 'net/http'
-
-def access_token_query_string
-  @access_token_query_string ||= begin
-    token = ENV['GITHUB_API_TOKEN']
-    token ? "?access_token=#{token.strip}" : ''
-  end
-end
-
-def github_api(path)
-  base = 'https://api.github.com'
-  url = path.start_with?(base) ? path : base + path
-  url += access_token_query_string
-  uri = URI.parse(url)
-  return unless response = Net::HTTP.get_response(uri)
-  JSON.load(response.body)
-end
-
-def wrap(text, length, indent)
-  result = []
-  work = text.dup
-
-  while work.length > length
-    if work =~ /^(.{0,#{length}})[ \n]/o
-      result << $1
-      work.slice!(0, $&.length)
-    else
-      result << work.slice!(0, length)
-    end
-  end
-
-  result << work unless work.empty?
-  result = result.reduce(String.new) do |acc, elem|
-    acc << "\n" << ' ' * indent unless acc.empty?
-    acc << elem
-  end
-  result += "\n" unless result.end_with?("\n")
-  result
-end
-
-def sentence(text)
-  text = text[0].upcase + text[1..-1]
-  text.end_with?('.') ? text : text << '.'
-end
-
-branch = ARGV.shift || "HEAD"
-
-history = File.read(File.expand_path('../../History.txt', __FILE__))
-
-File.open(File.expand_path('../../ChangeLog', __FILE__), 'w') do |changelog|
-  commits = `git log --oneline v#{Gem::VERSION}..#{branch}`.split("\n")
-  prs = commits.reverse_each.map { |c| c =~ /(Auto merge of|Merge pull request|Merge) #(\d+)/ && $2 }.compact.uniq.sort!
-  prs.each do |pr|
-    next if history =~ /Pull\srequest\s##{pr}/m
-    details = github_api "/repos/rubygems/rubygems/pulls/#{pr}"
-    title, user = details.values_at('title', 'user')
-    user = github_api(user['url'])
-    name = user['name'] || user['login']
-    changelog << wrap(
-      ['*', sentence(title), sentence("Pull request ##{pr} by #{name}")].join(' '),
-      74, 2
-    )
-  end
-end