say "#{source_uri} added to sources"

end

say "#{source_uri} is not a URI"

terminate_interaction 1

rescue Gem::RemoteFetcher::FetchError => e

end

def check_rubygems_https(source_uri) # :nodoc:

if uri.scheme && uri.scheme.casecmp("http").zero? &&

uri.host.casecmp("rubygems.org").zero?

end

if allowed_push_host

unless (host_uri.scheme == allowed_host_uri.scheme) && (host_uri.host == allowed_host_uri.host)

alert_error "#{self.host.inspect} is not allowed by the gemspec, which only allows #{allowed_push_host.inspect}"

end

end

response = request_with_otp(method, uri, &block)

if mfa_unauthorized?(response)

sign_in_host, scope: scope) do |request|

request.basic_auth email, password

request["OTP"] = otp if otp

end

with_response response do |_resp|

sign_in_host, credentials: credentials, scope: scope) do |request|

request.basic_auth email, password

request["OTP"] = otp if otp

end

with_response response do |resp|

request_line = socket.gets

method, req_uri, _protocol = request_line.split(" ")

responder = SocketResponder.new(socket)

# See LICENSE.txt for permissions.

#++

require_relative "../rubygems"

##

# Allows Gem::OptionParser to handle HTTP URIs.

def accept_uri_http

begin

raise Gem::OptionParser::InvalidArgument, value

end

def add_proxy_option

accept_uri_http

"Use HTTP proxy for remote operations") do |value, options|

options[:http_proxy] = value == false ? :no_proxy : value

Gem.configuration[:http_proxy] = options[:http_proxy]

def add_source_option

accept_uri_http

"Append URL to list of remote gem sources") do |source, options|

source << "/" unless source.end_with?("/")

#

require_relative '../../../net-protocol/lib/net/protocol'

require_relative '../../../resolv/lib/resolv'

autoload :OpenSSL, 'openssl'

# It consists of some or all of: scheme, hostname, path, query, and fragment;

# see {URI syntax}[https://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Syntax].

#

# represents an internet URI.

# It provides, among others, methods

# +scheme+, +hostname+, +path+, +query+, and +fragment+.

#

# === Schemes

#

# a {scheme}[https://en.wikipedia.org/wiki/List_of_URI_schemes].

#

# The two schemes supported in \Gem::Net::HTTP are <tt>'https'</tt> and <tt>'http'</tt>:

#

# uri.scheme # => "https"

#

# === Hostnames

#

#

# _uri = uri.dup

# params = {userId: 1, completed: false}

# Gem::Net::HTTP.get(_uri)

#

# === Fragments

# # You should choose a better exception.

# raise ArgumentError, 'Too many HTTP redirects' if limit == 0

#

# case res

# when Gem::Net::HTTPSuccess # Any success class.

# res

#

# Or if you simply want to make a GET request, you may pass in a URI

# object that has an \HTTPS URL. \Gem::Net::HTTP automatically turns on TLS

#

# Gem::Net::HTTP.get(uri)

#

# == Proxy Server

# === Proxy Using '<tt>ENV['http_proxy']</tt>'

#

# When environment variable <tt>'http_proxy'</tt>

# the returned +http+ will have the server at that URI as its proxy;

# such as <tt>'http'</tt> or <tt>'https'</tt>:

#

# ENV['http_proxy'] = 'http://example.com'

# http.proxy_user # => nil

# http.proxy_pass # => nil

#

#

# ENV['http_proxy'] = 'http://pname:[email protected]:8000'

# http = Gem::Net::HTTP.new(hostname)

#

# With URI object +uri+ and optional hash argument +headers+:

#

# headers = {'Content-type' => 'application/json; charset=UTF-8'}

# Gem::Net::HTTP.get(uri, headers)

#

elsif p_addr == :ENV then

http.proxy_from_env = true

else

p_addr = nil

p_port = nil

end

# The proxy URI determined from the environment for this connection.

def proxy_uri # :nodoc:

return if @proxy_uri == false

"http", nil, address, port, nil, nil, nil, nil, nil

).find_proxy || false

@proxy_uri || nil

@request_has_body = reqbody

@response_has_body = resbody

hostname = uri_or_path.hostname

@uri = uri_or_path.dup

host = @uri.hostname.dup

host << ":" << @uri.port.to_s if @uri.port != @uri.default_port

#

attr_reader :path

#

# Gem::Net::HTTP::Get.new(uri).uri

# Gem::Net::HTTP::Get.new('example.com').uri # => nil

#

attr_reader :uri

if ssl

scheme = 'https'

else

scheme = 'http'

end

if host = self['host']

else

host = addr

end

if @uri.is_a?(klass)

@uri.host = host

@uri.port = port

def send_request_with_body_data(sock, ver, path, params)

if /\Amultipart\/form-data\z/i !~ self.content_type

self.content_type = 'application/x-www-form-urlencoded'

end

opt = @form_option.dup

# The resulting request is suitable for HTTP request +POST+ or +PUT+.

#

# Argument +params+ must be suitable for use as argument +enum+ to

#

# With only argument +params+ given,

# sets the body to a URL-encoded string with the default separator <tt>'&'</tt>:

#

# Gem::Net::HTTPHeader#form_data= is an alias for Gem::Net::HTTPHeader#set_form_data.

def set_form_data(params, sep = '&')

query.gsub!(/&/, sep) if sep != '&'

self.body = query

self.content_type = 'application/x-www-form-urlencoded'

#

# == Creating a Request

#

#

# require 'rubygems/net-http/lib/net/http'

# req = Gem::Net::HTTP::Get.new(uri) # => #<Gem::Net::HTTP::Get GET>

# req = Gem::Net::HTTP::Get.new(uri.hostname) # => #<Gem::Net::HTTP::Get GET>

#

# {HTTP method GET}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#GET_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Get.new(uri) # => #<Gem::Net::HTTP::Get GET>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {HTTP method HEAD}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#HEAD_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Head.new(uri) # => #<Gem::Net::HTTP::Head HEAD>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {HTTP method POST}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#POST_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# uri.path = '/posts'

# req = Gem::Net::HTTP::Post.new(uri) # => #<Gem::Net::HTTP::Post POST>

# {HTTP method PUT}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#PUT_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# uri.path = '/posts'

# req = Gem::Net::HTTP::Put.new(uri) # => #<Gem::Net::HTTP::Put PUT>

# {HTTP method DELETE}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#DELETE_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# uri.path = '/posts/1'

# req = Gem::Net::HTTP::Delete.new(uri) # => #<Gem::Net::HTTP::Delete DELETE>

# {HTTP method OPTIONS}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#OPTIONS_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Options.new(uri) # => #<Gem::Net::HTTP::Options OPTIONS>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {HTTP method TRACE}[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#TRACE_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Trace.new(uri) # => #<Gem::Net::HTTP::Trace TRACE>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {HTTP method }[https://en.wikipedia.org/w/index.php?title=Hypertext_Transfer_Protocol#_method]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# uri.path = '/posts'

# req = Gem::Net::HTTP::.new(uri) # => #<Gem::Net::HTTP:: >

# {WebDAV method PROPFIND}[http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Propfind.new(uri) # => #<Gem::Net::HTTP::Propfind PROPFIND>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method PROP}[http://www.webdav.org/specs/rfc4918.html#METHOD_PROP]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Prop.new(uri) # => #<Gem::Net::HTTP::Prop PROP>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method MKCOL}[http://www.webdav.org/specs/rfc4918.html#METHOD_MKCOL]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Mkcol.new(uri) # => #<Gem::Net::HTTP::Mkcol MKCOL>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method COPY}[http://www.webdav.org/specs/rfc4918.html#METHOD_COPY]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Copy.new(uri) # => #<Gem::Net::HTTP::Copy COPY>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method MOVE}[http://www.webdav.org/specs/rfc4918.html#METHOD_MOVE]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Move.new(uri) # => #<Gem::Net::HTTP::Move MOVE>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method LOCK}[http://www.webdav.org/specs/rfc4918.html#METHOD_LOCK]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Lock.new(uri) # => #<Gem::Net::HTTP::Lock LOCK>

# res = Gem::Net::HTTP.start(hostname) do |http|

# {WebDAV method UNLOCK}[http://www.webdav.org/specs/rfc4918.html#METHOD_UNLOCK]:

#

# require 'rubygems/net-http/lib/net/http'

# hostname = uri.hostname # => "example.com"

# req = Gem::Net::HTTP::Unlock.new(uri) # => #<Gem::Net::HTTP::Unlock UNLOCK>

# res = Gem::Net::HTTP.start(hostname) do |http|

attr_reader :message

alias msg message # :nodoc: obsolete

attr_reader :uri

# Set to true automatically when the request did not contain an

# Response class for <tt>See Other</tt> responses (status code 303).

#

#

# :include: doc/net-http/included_getters.rdoc

#

# Response class for <tt>Temporary Redirect</tt> responses (status code 307).

#

#

# :include: doc/net-http/included_getters.rdoc

#

# Response class for <tt>Permanent Redirect</tt> responses (status code 308).

#

#

# :include: doc/net-http/included_getters.rdoc

#

end

HTTPRequestEntityTooLarge = HTTPPayloadTooLarge

#

#

# :include: doc/net-http/included_getters.rdoc

#

puts

puts "Gem::Net::HTTP::STATUS_CODES = {"

url = "https://www.iana.org/assignments/http-status-codes/http-status-codes-1.csv"

code, mes, = line.split(',')

next if ['(Unused)', 'Unassigned', 'Description'].include?(mes)

puts " #{code} => '#{mes}',"

# - Date -- Anything accepted by +Date.parse+ (need to require +optparse/date+)

# - DateTime -- Anything accepted by +DateTime.parse+ (need to require +optparse/date+)

# - Time -- Anything accepted by +Time.httpdate+ or +Time.parse+ (need to require +optparse/time+)

# - Shellwords -- Anything accepted by +Shellwords.shellwords+ (need to require +optparse/shellwords+)

# - String -- Any non-empty string

# - Integer -- Any integer. Will convert octal. (e.g. 124, -3, 040)

# -*- ruby -*-

require_relative '../optparse'

require_relative "core_ext/tcpsocket_init" if Gem.configuration.ipv4_fallback_enabled

require_relative "net/http"

require "stringio"

Socket.do_not_reverse_lookup = true

scheme = source_uri.scheme

scheme = nil if /^[a-z]$/i.match?(scheme)

# REFACTOR: split this up and dis on scheme (eg download_http)

end

def self.proxy_uri(proxy) # :nodoc:

case proxy

when :no_proxy then nil

end

end

end

require "uri"

if uri && uri.user.nil? && uri.password.nil?

user = ENV["#{downcase_scheme}_proxy_user"] || ENV["#{upcase_scheme}_PROXY_USER"]

def initialize(dep_uri = "https://index.rubygems.org/info/")

super()

@dep_uri = dep_uri

@uri = dep_uri + ".."

def replace_failed_api_set(error) # :nodoc:

uri = error.original_uri

uri += "."

raise error unless api_set = @sets.find do |set|

string_to_sign = generate_string_to_sign(date_time, credential_info, canonical_request)

signature = generate_signature(s3_config, date, string_to_sign)

end

private

end

def ec2_metadata_request(url)

@request_pool ||= create_request_pool(uri)

request = Gem::Request.new(uri, Gem::Net::HTTP::Get, nil, @request_pool)

response = request.fetch

end

##

def uri_hash # :nodoc:

require_relative "../openssl"

normalized =

if @repository.match?(%r{^\w+://(\w+@)?})

uri.sub(/\A(\w+)/) { $1.downcase }

else

@repository

end

##

# String.

def <<(obj)

# Make sure a homepage is valid HTTP/HTTPS URI

if homepage && !homepage.empty?

begin

error "\"#{homepage}\" is not a valid HTTP URI"

end

error "\"#{homepage}\" is not a valid HTTP URI"

end

end

# Parses uri, raising if it's invalid

def self.parse!(uri)

return uri unless uri.is_a?(String)

# as "%7BDESede%7D". If this is escaped again the percentage

# symbols will be escaped.

begin

end

end

def self.parse(uri)

parse!(uri)

uri

end

end

##

# comes with a leading slash.

def self.correct_for_windows_path(path)