Merge pull request #11654 from Homebrew/dependabot/bundler/Library/Homebrew/addressable-2.8.0
build(deps): bump addressable from 2.7.0 to 2.8.0 in /Library/Homebrew
This commit is contained in:
Rylan Polster
GitHub
commit
12cac64c9d
@ -7,7 +7,7 @@ GEM
|
||||
minitest (>= 5.1)
|
||||
tzinfo (~> 2.0)
|
||||
zeitwerk (~> 2.3)
|
||||
addressable (2.7.0)
|
||||
addressable (2.8.0)
|
||||
public_suffix (>= 2.0.2, < 5.0)
|
||||
ast (2.4.2)
|
||||
bindata (2.4.10)
|
||||
|
||||
@ -4,8 +4,7 @@
|
||||
|
||||
# typed: true
|
||||
|
||||
module Addressable
|
||||
end
|
||||
module Addressable; end
|
||||
|
||||
module Addressable::IDNA
|
||||
class << self
|
||||
@ -26,6 +25,7 @@ module Addressable::IDNA
|
||||
def punycode_delimiter?(codepoint); end
|
||||
def punycode_encode(unicode); end
|
||||
def punycode_encode_digit(d); end
|
||||
def ucs4_to_utf8(char, buffer); end
|
||||
def unicode_compose(unpacked); end
|
||||
def unicode_compose_pair(ch_one, ch_two); end
|
||||
def unicode_decompose(unpacked); end
|
||||
@ -36,80 +36,41 @@ module Addressable::IDNA
|
||||
end
|
||||
|
||||
Addressable::IDNA::ACE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::ACE_PREFIX = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::IDNA::COMPOSITION_TABLE = T.let(T.unsafe(nil), Hash)
|
||||
|
||||
Addressable::IDNA::HANGUL_LBASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_LCOUNT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_NCOUNT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_SBASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_SCOUNT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_TBASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_TCOUNT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_VBASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::HANGUL_VCOUNT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_BASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_DAMP = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_DELIMITER = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_INITIAL_N = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_MAXINT = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_PRINT_ASCII = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_SKEW = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_TMAX = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::PUNYCODE_TMIN = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
class Addressable::IDNA::PunycodeBadInput < ::StandardError
|
||||
end
|
||||
|
||||
class Addressable::IDNA::PunycodeBigOutput < ::StandardError
|
||||
end
|
||||
|
||||
class Addressable::IDNA::PunycodeOverflow < ::StandardError
|
||||
end
|
||||
|
||||
class Addressable::IDNA::PunycodeBadInput < ::StandardError; end
|
||||
class Addressable::IDNA::PunycodeBigOutput < ::StandardError; end
|
||||
class Addressable::IDNA::PunycodeOverflow < ::StandardError; end
|
||||
Addressable::IDNA::UNICODE_DATA = T.let(T.unsafe(nil), Hash)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_CANONICAL = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_COMBINING_CLASS = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_COMPATIBILITY = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_EXCLUSION = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_LOWERCASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_TITLECASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_DATA_UPPERCASE = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::IDNA::UNICODE_TABLE = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::IDNA::UTF8_REGEX = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
Addressable::IDNA::UTF8_REGEX_MULTIBYTE = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
class Addressable::URI
|
||||
@ -203,6 +164,7 @@ class Addressable::URI
|
||||
def encode(uri, return_type = T.unsafe(nil)); end
|
||||
def encode_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
|
||||
def escape(uri, return_type = T.unsafe(nil)); end
|
||||
def escape_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
|
||||
def form_encode(form_values, sort = T.unsafe(nil)); end
|
||||
def form_unencode(encoded_value); end
|
||||
def heuristic_parse(uri, hints = T.unsafe(nil)); end
|
||||
@ -220,71 +182,43 @@ class Addressable::URI
|
||||
end
|
||||
end
|
||||
|
||||
module Addressable::URI::CharacterClasses
|
||||
end
|
||||
|
||||
module Addressable::URI::CharacterClasses; end
|
||||
Addressable::URI::CharacterClasses::ALPHA = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::AUTHORITY = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::DIGIT = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::FRAGMENT = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::GEN_DELIMS = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::HOST = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::PATH = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::PCHAR = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::QUERY = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::RESERVED = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::SCHEME = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::SUB_DELIMS = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::CharacterClasses::UNRESERVED = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::EMPTY_STR = T.let(T.unsafe(nil), String)
|
||||
|
||||
class Addressable::URI::InvalidURIError < ::StandardError
|
||||
end
|
||||
|
||||
class Addressable::URI::InvalidURIError < ::StandardError; end
|
||||
Addressable::URI::NORMPATH = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
module Addressable::URI::NormalizeCharacterClasses; end
|
||||
Addressable::URI::NormalizeCharacterClasses::FRAGMENT = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::NormalizeCharacterClasses::HOST = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::NormalizeCharacterClasses::PCHAR = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::NormalizeCharacterClasses::QUERY = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::NormalizeCharacterClasses::SCHEME = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::NormalizeCharacterClasses::UNRESERVED = T.let(T.unsafe(nil), Regexp)
|
||||
Addressable::URI::PARENT = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::PORT_MAPPING = T.let(T.unsafe(nil), Hash)
|
||||
|
||||
Addressable::URI::RULE_2A = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
Addressable::URI::RULE_2B_2C = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
Addressable::URI::RULE_2D = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
Addressable::URI::RULE_PREFIXED_PARENT = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
Addressable::URI::SELF_REF = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::SEQUENCE_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
|
||||
|
||||
Addressable::URI::SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
|
||||
|
||||
Addressable::URI::SLASH = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::URI::URIREGEX = T.let(T.unsafe(nil), Regexp)
|
||||
|
||||
module Addressable::VERSION
|
||||
end
|
||||
|
||||
module Addressable::VERSION; end
|
||||
Addressable::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
|
||||
|
||||
Addressable::VERSION::STRING = T.let(T.unsafe(nil), String)
|
||||
|
||||
Addressable::VERSION::TINY = T.let(T.unsafe(nil), Integer)
|
||||
@ -2740,8 +2740,6 @@ class Addressable::Template
|
||||
|
||||
def extract(uri, processor=T.unsafe(nil)); end
|
||||
|
||||
def generate(params=T.unsafe(nil), recall=T.unsafe(nil), options=T.unsafe(nil)); end
|
||||
|
||||
def initialize(pattern); end
|
||||
|
||||
def keys(); end
|
||||
@ -12578,13 +12576,9 @@ Net::HTTPServerErrorCode = Net::HTTPServerError
|
||||
|
||||
Net::HTTPSession = Net::HTTP
|
||||
|
||||
class Net::HTTPSuccess
|
||||
end
|
||||
Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
|
||||
|
||||
Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError
|
||||
|
||||
class Net::HTTPSuccess
|
||||
end
|
||||
Net::HTTPSuccessCode = Net::HTTPSuccess
|
||||
|
||||
class Net::HTTPURITooLong
|
||||
HAS_BODY = ::T.let(nil, ::T.untyped)
|
||||
|
||||
@ -10,7 +10,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tzinfo-2.0.4/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/zeitwerk-2.4.2/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/activesupport-6.1.4/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/public_suffix-4.0.6/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.7.0/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.8.0/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ast-2.4.2/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bindata-2.4.10/lib"
|
||||
$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/msgpack-1.4.2"
|
||||
|
||||
@ -178,44 +178,46 @@ module Addressable
|
||||
end
|
||||
|
||||
p = []
|
||||
ucs4_to_utf8 = lambda do |ch|
|
||||
if ch < 128
|
||||
p << ch
|
||||
elsif ch < 2048
|
||||
p << (ch >> 6 | 192)
|
||||
p << (ch & 63 | 128)
|
||||
elsif ch < 0x10000
|
||||
p << (ch >> 12 | 224)
|
||||
p << (ch >> 6 & 63 | 128)
|
||||
p << (ch & 63 | 128)
|
||||
elsif ch < 0x200000
|
||||
p << (ch >> 18 | 240)
|
||||
p << (ch >> 12 & 63 | 128)
|
||||
p << (ch >> 6 & 63 | 128)
|
||||
p << (ch & 63 | 128)
|
||||
elsif ch < 0x4000000
|
||||
p << (ch >> 24 | 248)
|
||||
p << (ch >> 18 & 63 | 128)
|
||||
p << (ch >> 12 & 63 | 128)
|
||||
p << (ch >> 6 & 63 | 128)
|
||||
p << (ch & 63 | 128)
|
||||
elsif ch < 0x80000000
|
||||
p << (ch >> 30 | 252)
|
||||
p << (ch >> 24 & 63 | 128)
|
||||
p << (ch >> 18 & 63 | 128)
|
||||
p << (ch >> 12 & 63 | 128)
|
||||
p << (ch >> 6 & 63 | 128)
|
||||
p << (ch & 63 | 128)
|
||||
end
|
||||
end
|
||||
|
||||
ucs4_to_utf8.call(ch_one)
|
||||
ucs4_to_utf8.call(ch_two)
|
||||
ucs4_to_utf8(ch_one, p)
|
||||
ucs4_to_utf8(ch_two, p)
|
||||
|
||||
return lookup_unicode_composition(p)
|
||||
end
|
||||
private_class_method :unicode_compose_pair
|
||||
|
||||
def self.ucs4_to_utf8(char, buffer)
|
||||
if char < 128
|
||||
buffer << char
|
||||
elsif char < 2048
|
||||
buffer << (char >> 6 | 192)
|
||||
buffer << (char & 63 | 128)
|
||||
elsif char < 0x10000
|
||||
buffer << (char >> 12 | 224)
|
||||
buffer << (char >> 6 & 63 | 128)
|
||||
buffer << (char & 63 | 128)
|
||||
elsif char < 0x200000
|
||||
buffer << (char >> 18 | 240)
|
||||
buffer << (char >> 12 & 63 | 128)
|
||||
buffer << (char >> 6 & 63 | 128)
|
||||
buffer << (char & 63 | 128)
|
||||
elsif char < 0x4000000
|
||||
buffer << (char >> 24 | 248)
|
||||
buffer << (char >> 18 & 63 | 128)
|
||||
buffer << (char >> 12 & 63 | 128)
|
||||
buffer << (char >> 6 & 63 | 128)
|
||||
buffer << (char & 63 | 128)
|
||||
elsif char < 0x80000000
|
||||
buffer << (char >> 30 | 252)
|
||||
buffer << (char >> 24 & 63 | 128)
|
||||
buffer << (char >> 18 & 63 | 128)
|
||||
buffer << (char >> 12 & 63 | 128)
|
||||
buffer << (char >> 6 & 63 | 128)
|
||||
buffer << (char & 63 | 128)
|
||||
end
|
||||
end
|
||||
private_class_method :ucs4_to_utf8
|
||||
|
||||
def self.unicode_sort_canonical(unpacked)
|
||||
unpacked = unpacked.dup
|
||||
i = 1
|
||||
@ -37,7 +37,7 @@ module Addressable
|
||||
Addressable::URI::CharacterClasses::DIGIT + '_'
|
||||
|
||||
var_char =
|
||||
"(?:(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
|
||||
"(?>(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
|
||||
RESERVED =
|
||||
"(?:[#{anything}]|%[a-fA-F0-9][a-fA-F0-9])"
|
||||
UNRESERVED =
|
||||
@ -412,7 +412,7 @@ module Addressable
|
||||
# match.captures
|
||||
# #=> ["a", ["b", "c"]]
|
||||
def match(uri, processor=nil)
|
||||
uri = Addressable::URI.parse(uri)
|
||||
uri = Addressable::URI.parse(uri) unless uri.is_a?(Addressable::URI)
|
||||
mapping = {}
|
||||
|
||||
# First, we need to process the pattern, and extract the values.
|
||||
@ -653,40 +653,6 @@ module Addressable
|
||||
self.to_regexp.named_captures
|
||||
end
|
||||
|
||||
##
|
||||
# Generates a route result for a given set of parameters.
|
||||
# Should only be used by rack-mount.
|
||||
#
|
||||
# @param params [Hash] The set of parameters used to expand the template.
|
||||
# @param recall [Hash] Default parameters used to expand the template.
|
||||
# @param options [Hash] Either a `:processor` or a `:parameterize` block.
|
||||
#
|
||||
# @api private
|
||||
def generate(params={}, recall={}, options={})
|
||||
merged = recall.merge(params)
|
||||
if options[:processor]
|
||||
processor = options[:processor]
|
||||
elsif options[:parameterize]
|
||||
# TODO: This is sending me into fits trying to shoe-horn this into
|
||||
# the existing API. I think I've got this backwards and processors
|
||||
# should be a set of 4 optional blocks named :validate, :transform,
|
||||
# :match, and :restore. Having to use a singleton here is a huge
|
||||
# code smell.
|
||||
processor = Object.new
|
||||
class <<processor
|
||||
attr_accessor :block
|
||||
def transform(name, value)
|
||||
block.call(name, value)
|
||||
end
|
||||
end
|
||||
processor.block = options[:parameterize]
|
||||
else
|
||||
processor = nil
|
||||
end
|
||||
result = self.expand(merged, processor)
|
||||
result.to_s if result
|
||||
end
|
||||
|
||||
private
|
||||
def ordered_variable_defaults
|
||||
@ordered_variable_defaults ||= begin
|
||||
@ -973,15 +939,35 @@ module Addressable
|
||||
end
|
||||
end
|
||||
|
||||
##
|
||||
# Generates the <tt>Regexp</tt> that parses a template pattern. Memoizes the
|
||||
# value if template processor not set (processors may not be deterministic)
|
||||
#
|
||||
# @param [String] pattern The URI template pattern.
|
||||
# @param [#match] processor The template processor to use.
|
||||
#
|
||||
# @return [Array, Regexp]
|
||||
# An array of expansion variables nad a regular expression which may be
|
||||
# used to parse a template pattern
|
||||
def parse_template_pattern(pattern, processor = nil)
|
||||
if processor.nil? && pattern == @pattern
|
||||
@cached_template_parse ||=
|
||||
parse_new_template_pattern(pattern, processor)
|
||||
else
|
||||
parse_new_template_pattern(pattern, processor)
|
||||
end
|
||||
end
|
||||
|
||||
##
|
||||
# Generates the <tt>Regexp</tt> that parses a template pattern.
|
||||
#
|
||||
# @param [String] pattern The URI template pattern.
|
||||
# @param [#match] processor The template processor to use.
|
||||
#
|
||||
# @return [Regexp]
|
||||
# A regular expression which may be used to parse a template pattern.
|
||||
def parse_template_pattern(pattern, processor=nil)
|
||||
# @return [Array, Regexp]
|
||||
# An array of expansion variables nad a regular expression which may be
|
||||
# used to parse a template pattern
|
||||
def parse_new_template_pattern(pattern, processor = nil)
|
||||
# Escape the pattern. The two gsubs restore the escaped curly braces
|
||||
# back to their original form. Basically, escape everything that isn't
|
||||
# within an expansion.
|
||||
@ -48,12 +48,21 @@ module Addressable
|
||||
PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
|
||||
SCHEME = ALPHA + DIGIT + "\\-\\+\\."
|
||||
HOST = UNRESERVED + SUB_DELIMS + "\\[\\:\\]"
|
||||
AUTHORITY = PCHAR
|
||||
AUTHORITY = PCHAR + "\\[\\:\\]"
|
||||
PATH = PCHAR + "\\/"
|
||||
QUERY = PCHAR + "\\/\\?"
|
||||
FRAGMENT = PCHAR + "\\/\\?"
|
||||
end
|
||||
|
||||
module NormalizeCharacterClasses
|
||||
HOST = /[^#{CharacterClasses::HOST}]/
|
||||
UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
|
||||
PCHAR = /[^#{CharacterClasses::PCHAR}]/
|
||||
SCHEME = /[^#{CharacterClasses::SCHEME}]/
|
||||
FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
|
||||
QUERY = %r{[^a-zA-Z0-9\-\.\_\~\!\$\'\(\)\*\+\,\=\:\@\/\?%]|%(?!2B|2b)}
|
||||
end
|
||||
|
||||
SLASH = '/'
|
||||
EMPTY_STR = ''
|
||||
|
||||
@ -73,7 +82,7 @@ module Addressable
|
||||
"wais" => 210,
|
||||
"ldap" => 389,
|
||||
"prospero" => 1525
|
||||
}
|
||||
}.freeze
|
||||
|
||||
##
|
||||
# Returns a URI object based on the parsed string.
|
||||
@ -421,7 +430,7 @@ module Addressable
|
||||
end
|
||||
|
||||
class << self
|
||||
alias_method :encode_component, :encode_component
|
||||
alias_method :escape_component, :encode_component
|
||||
end
|
||||
|
||||
##
|
||||
@ -463,7 +472,11 @@ module Addressable
|
||||
uri = uri.dup
|
||||
# Seriously, only use UTF-8. I'm really not kidding!
|
||||
uri.force_encoding("utf-8")
|
||||
leave_encoded = leave_encoded.dup.force_encoding("utf-8")
|
||||
|
||||
unless leave_encoded.empty?
|
||||
leave_encoded = leave_encoded.dup.force_encoding("utf-8")
|
||||
end
|
||||
|
||||
result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
|
||||
c = sequence[1..3].to_i(16).chr
|
||||
c.force_encoding("utf-8")
|
||||
@ -554,7 +567,11 @@ module Addressable
|
||||
end.flatten.join('|')})"
|
||||
end
|
||||
|
||||
character_class = /[^#{character_class}]#{leave_re}/
|
||||
character_class = if leave_re
|
||||
/[^#{character_class}]#{leave_re}/
|
||||
else
|
||||
/[^#{character_class}]/
|
||||
end
|
||||
end
|
||||
# We can't perform regexps on invalid UTF sequences, but
|
||||
# here we need to, so switch to ASCII.
|
||||
@ -878,7 +895,7 @@ module Addressable
|
||||
else
|
||||
Addressable::URI.normalize_component(
|
||||
self.scheme.strip.downcase,
|
||||
Addressable::URI::CharacterClasses::SCHEME
|
||||
Addressable::URI::NormalizeCharacterClasses::SCHEME
|
||||
)
|
||||
end
|
||||
end
|
||||
@ -898,7 +915,7 @@ module Addressable
|
||||
new_scheme = new_scheme.to_str
|
||||
end
|
||||
if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
|
||||
raise InvalidURIError, "Invalid scheme format: #{new_scheme}"
|
||||
raise InvalidURIError, "Invalid scheme format: '#{new_scheme}'"
|
||||
end
|
||||
@scheme = new_scheme
|
||||
@scheme = nil if @scheme.to_s.strip.empty?
|
||||
@ -933,7 +950,7 @@ module Addressable
|
||||
else
|
||||
Addressable::URI.normalize_component(
|
||||
self.user.strip,
|
||||
Addressable::URI::CharacterClasses::UNRESERVED
|
||||
Addressable::URI::NormalizeCharacterClasses::UNRESERVED
|
||||
)
|
||||
end
|
||||
end
|
||||
@ -990,7 +1007,7 @@ module Addressable
|
||||
else
|
||||
Addressable::URI.normalize_component(
|
||||
self.password.strip,
|
||||
Addressable::URI::CharacterClasses::UNRESERVED
|
||||
Addressable::URI::NormalizeCharacterClasses::UNRESERVED
|
||||
)
|
||||
end
|
||||
end
|
||||
@ -1114,6 +1131,7 @@ module Addressable
|
||||
# @return [String] The host component, normalized.
|
||||
def normalized_host
|
||||
return nil unless self.host
|
||||
|
||||
@normalized_host ||= begin
|
||||
if !self.host.strip.empty?
|
||||
result = ::Addressable::IDNA.to_ascii(
|
||||
@ -1125,14 +1143,17 @@ module Addressable
|
||||
end
|
||||
result = Addressable::URI.normalize_component(
|
||||
result,
|
||||
CharacterClasses::HOST)
|
||||
NormalizeCharacterClasses::HOST
|
||||
)
|
||||
result
|
||||
else
|
||||
EMPTY_STR.dup
|
||||
end
|
||||
end
|
||||
# All normalized values should be UTF-8
|
||||
@normalized_host.force_encoding(Encoding::UTF_8) if @normalized_host
|
||||
if @normalized_host && !@normalized_host.empty?
|
||||
@normalized_host.force_encoding(Encoding::UTF_8)
|
||||
end
|
||||
@normalized_host
|
||||
end
|
||||
|
||||
@ -1537,7 +1558,7 @@ module Addressable
|
||||
result = path.strip.split(SLASH, -1).map do |segment|
|
||||
Addressable::URI.normalize_component(
|
||||
segment,
|
||||
Addressable::URI::CharacterClasses::PCHAR
|
||||
Addressable::URI::NormalizeCharacterClasses::PCHAR
|
||||
)
|
||||
end.join(SLASH)
|
||||
|
||||
@ -1612,11 +1633,15 @@ module Addressable
|
||||
modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
|
||||
# Make sure possible key-value pair delimiters are escaped.
|
||||
modified_query_class.sub!("\\&", "").sub!("\\;", "")
|
||||
pairs = (self.query || "").split("&", -1)
|
||||
pairs.delete_if(&:empty?) if flags.include?(:compacted)
|
||||
pairs = (query || "").split("&", -1)
|
||||
pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
|
||||
pairs.sort! if flags.include?(:sorted)
|
||||
component = pairs.map do |pair|
|
||||
Addressable::URI.normalize_component(pair, modified_query_class, "+")
|
||||
Addressable::URI.normalize_component(
|
||||
pair,
|
||||
Addressable::URI::NormalizeCharacterClasses::QUERY,
|
||||
"+"
|
||||
)
|
||||
end.join("&")
|
||||
component == "" ? nil : component
|
||||
end
|
||||
@ -1675,11 +1700,13 @@ module Addressable
|
||||
# so it's best to make all changes in-place.
|
||||
pair[0] = URI.unencode_component(pair[0])
|
||||
if pair[1].respond_to?(:to_str)
|
||||
value = pair[1].to_str
|
||||
# I loathe the fact that I have to do this. Stupid HTML 4.01.
|
||||
# Treating '+' as a space was just an unbelievably bad idea.
|
||||
# There was nothing wrong with '%20'!
|
||||
# If it ain't broke, don't fix it!
|
||||
pair[1] = URI.unencode_component(pair[1].to_str.tr("+", " "))
|
||||
value = value.tr("+", " ") if ["http", "https", nil].include?(scheme)
|
||||
pair[1] = URI.unencode_component(value)
|
||||
end
|
||||
if return_type == Hash
|
||||
accu[pair[0]] = pair[1]
|
||||
@ -1810,7 +1837,7 @@ module Addressable
|
||||
@normalized_fragment ||= begin
|
||||
component = Addressable::URI.normalize_component(
|
||||
self.fragment,
|
||||
Addressable::URI::CharacterClasses::FRAGMENT
|
||||
Addressable::URI::NormalizeCharacterClasses::FRAGMENT
|
||||
)
|
||||
component == "" ? nil : component
|
||||
end
|
||||
@ -23,7 +23,7 @@ if !defined?(Addressable::VERSION)
|
||||
module Addressable
|
||||
module VERSION
|
||||
MAJOR = 2
|
||||
MINOR = 7
|
||||
MINOR = 8
|
||||
TINY = 0
|
||||
|
||||
STRING = [MAJOR, MINOR, TINY].join('.')
|
||||
Loading…
x
Reference in New Issue
Block a user