addressable 2.6.0 → 2.7.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: afa411655b3715e655e0cdca551d20df31b83491
4
- data.tar.gz: 0cd2871c45abb19f6b6238ad202856e7afb8619d
3
+ metadata.gz: 73a7a5a0dfea976017780e3b434e97aa58216019
4
+ data.tar.gz: a708925a0882de04f840e9e54d279eb954775921
5
5
  SHA512:
6
- metadata.gz: 16274bd51d38c58b3712dbbdad1368417051937dbe33d74fa73951a39b71d824092c0ecd50005d467db9c914cc074fd0344282df2e23e1182c764b1a1da9750a
7
- data.tar.gz: c53ff1d0e09a5e3d997a13a464d50c45fd7d548326f94d3ad40dc97753ce3a47aad4804a62faea48b89775394538982e70ac22d7488fab8ee6594b6816d8ff28
6
+ metadata.gz: c311a5594d7f1051df67287badef72551c52c6bc47598017099d5e8b5c2a9638144bcc6d635b418dfc1970e185cf31016ad54f681c7156d440223ef62f060bc5
7
+ data.tar.gz: 78527879654347fcf16be86684e1b37ca240c5a80d3baf2217cfdfb501cd6255de47a7cc8058c10e98e558b073981a27be06672f4dec8cf7d18e88a34609e6a1
@@ -1,3 +1,11 @@
1
+ # Addressable 2.7.0
2
+ - added `:compacted` flag to `normalized_query`
3
+ - `heuristic_parse` handles `mailto:` more intuitively
4
+ - refactored validation to use a prepended module
5
+ - dropped explicit support for JRuby 9.0.5.0
6
+ - compatibility w/ public_suffix 4.x
7
+ - performance improvements
8
+
1
9
  # Addressable 2.6.0
2
10
  - added `tld=` method to allow assignment to the public suffix
3
11
  - most `heuristic_parse` patterns are now case-insensitive
data/Gemfile CHANGED
@@ -3,8 +3,8 @@ source 'https://rubygems.org'
3
3
  gemspec
4
4
 
5
5
  group :test do
6
- gem 'rspec', '~> 3.5'
7
- gem 'rspec-its', '~> 1.1'
6
+ gem 'rspec', '~> 3.8'
7
+ gem 'rspec-its', '~> 1.3'
8
8
  end
9
9
 
10
10
  group :development do
data/README.md CHANGED
@@ -19,9 +19,11 @@
19
19
 
20
20
  # Description
21
21
 
22
- Addressable is a replacement for the URI implementation that is part of
23
- Ruby's standard library. It more closely conforms to RFC 3986, RFC 3987, and
24
- RFC 6570 (level 4), providing support for IRIs and URI templates.
22
+ Addressable is an alternative implementation to the URI implementation
23
+ that is part of Ruby's standard library. It is flexible, offers heuristic
24
+ parsing, and additionally provides extensive support for IRIs and URI templates.
25
+
26
+ Addressable closely conforms to RFC 3986, RFC 3987, and RFC 6570 (level 4).
25
27
 
26
28
  # Reference
27
29
 
data/Rakefile CHANGED
@@ -14,9 +14,9 @@ RELEASE_NAME = "REL #{PKG_VERSION}"
14
14
 
15
15
  PKG_SUMMARY = "URI Implementation"
16
16
  PKG_DESCRIPTION = <<-TEXT
17
- Addressable is a replacement for the URI implementation that is part of
18
- Ruby's standard library. It more closely conforms to the relevant RFCs and
19
- adds support for IRIs and URI templates.
17
+ Addressable is an alternative implementation to the URI implementation that is
18
+ part of Ruby's standard library. It is flexible, offers heuristic parsing, and
19
+ additionally provides extensive support for IRIs and URI templates.
20
20
  TEXT
21
21
 
22
22
  PKG_FILES = FileList[
@@ -135,7 +135,7 @@ module Addressable
135
135
  unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
136
136
  return unpacked.pack("U*")
137
137
  end
138
- (class <<self; private :unicode_downcase; end)
138
+ private_class_method :unicode_downcase
139
139
 
140
140
  def self.unicode_compose(unpacked)
141
141
  unpacked_result = []
@@ -160,7 +160,7 @@ module Addressable
160
160
  unpacked_result << starter
161
161
  return unpacked_result
162
162
  end
163
- (class <<self; private :unicode_compose; end)
163
+ private_class_method :unicode_compose
164
164
 
165
165
  def self.unicode_compose_pair(ch_one, ch_two)
166
166
  if ch_one >= HANGUL_LBASE && ch_one < HANGUL_LBASE + HANGUL_LCOUNT &&
@@ -214,7 +214,7 @@ module Addressable
214
214
 
215
215
  return lookup_unicode_composition(p)
216
216
  end
217
- (class <<self; private :unicode_compose_pair; end)
217
+ private_class_method :unicode_compose_pair
218
218
 
219
219
  def self.unicode_sort_canonical(unpacked)
220
220
  unpacked = unpacked.dup
@@ -238,7 +238,7 @@ module Addressable
238
238
  end
239
239
  return unpacked
240
240
  end
241
- (class <<self; private :unicode_sort_canonical; end)
241
+ private_class_method :unicode_sort_canonical
242
242
 
243
243
  def self.unicode_decompose(unpacked)
244
244
  unpacked_result = []
@@ -259,7 +259,7 @@ module Addressable
259
259
  end
260
260
  return unpacked_result
261
261
  end
262
- (class <<self; private :unicode_decompose; end)
262
+ private_class_method :unicode_decompose
263
263
 
264
264
  def self.unicode_decompose_hangul(codepoint)
265
265
  sindex = codepoint - HANGUL_SBASE;
@@ -276,7 +276,7 @@ module Addressable
276
276
  end
277
277
  return l, v, t
278
278
  end
279
- (class <<self; private :unicode_decompose_hangul; end)
279
+ private_class_method :unicode_decompose_hangul
280
280
 
281
281
  def self.lookup_unicode_combining_class(codepoint)
282
282
  codepoint_data = UNICODE_DATA[codepoint]
@@ -284,14 +284,14 @@ module Addressable
284
284
  (codepoint_data[UNICODE_DATA_COMBINING_CLASS] || 0) :
285
285
  0)
286
286
  end
287
- (class <<self; private :lookup_unicode_combining_class; end)
287
+ private_class_method :lookup_unicode_combining_class
288
288
 
289
289
  def self.lookup_unicode_compatibility(codepoint)
290
290
  codepoint_data = UNICODE_DATA[codepoint]
291
291
  (codepoint_data ?
292
292
  codepoint_data[UNICODE_DATA_COMPATIBILITY] : nil)
293
293
  end
294
- (class <<self; private :lookup_unicode_compatibility; end)
294
+ private_class_method :lookup_unicode_compatibility
295
295
 
296
296
  def self.lookup_unicode_lowercase(codepoint)
297
297
  codepoint_data = UNICODE_DATA[codepoint]
@@ -299,12 +299,12 @@ module Addressable
299
299
  (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
300
300
  codepoint)
301
301
  end
302
- (class <<self; private :lookup_unicode_lowercase; end)
302
+ private_class_method :lookup_unicode_lowercase
303
303
 
304
304
  def self.lookup_unicode_composition(unpacked)
305
305
  return COMPOSITION_TABLE[unpacked]
306
306
  end
307
- (class <<self; private :lookup_unicode_composition; end)
307
+ private_class_method :lookup_unicode_composition
308
308
 
309
309
  HANGUL_SBASE = 0xac00
310
310
  HANGUL_LBASE = 0x1100
@@ -341,7 +341,7 @@ module Addressable
341
341
  end
342
342
 
343
343
  COMPOSITION_TABLE = {}
344
- for codepoint, data in UNICODE_DATA
344
+ UNICODE_DATA.each do |codepoint, data|
345
345
  canonical = data[UNICODE_DATA_CANONICAL]
346
346
  exclusion = data[UNICODE_DATA_EXCLUSION]
347
347
 
@@ -500,7 +500,7 @@ module Addressable
500
500
 
501
501
  output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
502
502
  end
503
- (class <<self; private :punycode_encode; end)
503
+ private_class_method :punycode_encode
504
504
 
505
505
  def self.punycode_decode(punycode)
506
506
  input = []
@@ -622,22 +622,22 @@ module Addressable
622
622
 
623
623
  output.pack("U*")
624
624
  end
625
- (class <<self; private :punycode_decode; end)
625
+ private_class_method :punycode_decode
626
626
 
627
627
  def self.punycode_basic?(codepoint)
628
628
  codepoint < 0x80
629
629
  end
630
- (class <<self; private :punycode_basic?; end)
630
+ private_class_method :punycode_basic?
631
631
 
632
632
  def self.punycode_delimiter?(codepoint)
633
633
  codepoint == PUNYCODE_DELIMITER
634
634
  end
635
- (class <<self; private :punycode_delimiter?; end)
635
+ private_class_method :punycode_delimiter?
636
636
 
637
637
  def self.punycode_encode_digit(d)
638
638
  d + 22 + 75 * ((d < 26) ? 1 : 0)
639
639
  end
640
- (class <<self; private :punycode_encode_digit; end)
640
+ private_class_method :punycode_encode_digit
641
641
 
642
642
  # Returns the numeric value of a basic codepoint
643
643
  # (for use in representing integers) in the range 0 to
@@ -653,7 +653,7 @@ module Addressable
653
653
  PUNYCODE_BASE
654
654
  end
655
655
  end
656
- (class <<self; private :punycode_decode_digit; end)
656
+ private_class_method :punycode_decode_digit
657
657
 
658
658
  # Bias adaptation method
659
659
  def self.punycode_adapt(delta, numpoints, firsttime)
@@ -670,7 +670,7 @@ module Addressable
670
670
 
671
671
  k + (difference + 1) * delta / (delta + PUNYCODE_SKEW)
672
672
  end
673
- (class <<self; private :punycode_adapt; end)
673
+ private_class_method :punycode_adapt
674
674
  end
675
675
  # :startdoc:
676
676
  end
@@ -207,7 +207,7 @@ module Addressable
207
207
  fragments = match.captures
208
208
  authority = fragments[3]
209
209
  if authority && authority.length > 0
210
- new_authority = authority.gsub(/\\/, '/').gsub(/ /, '%20')
210
+ new_authority = authority.tr("\\", "/").gsub(" ", "%20")
211
211
  # NOTE: We want offset 4, not 3!
212
212
  offset = match.offset(4)
213
213
  uri = uri.dup
@@ -218,8 +218,9 @@ module Addressable
218
218
  parsed = self.parse(hints[:scheme] + "://" + uri)
219
219
  end
220
220
  if parsed.path.include?(".")
221
- new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
222
- if new_host
221
+ if parsed.path[/\b@\b/]
222
+ parsed.scheme = "mailto" unless parsed.scheme
223
+ elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
223
224
  parsed.defer_validation do
224
225
  new_path = parsed.path.sub(
225
226
  Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
@@ -281,15 +282,15 @@ module Addressable
281
282
  uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
282
283
  "/#{$1.downcase}:/"
283
284
  end
284
- uri.path.gsub!(/\\/, SLASH)
285
+ uri.path.tr!("\\", SLASH)
285
286
  if File.exist?(uri.path) &&
286
287
  File.stat(uri.path).directory?
287
- uri.path.sub!(/\/$/, EMPTY_STR)
288
+ uri.path.chomp!(SLASH)
288
289
  uri.path = uri.path + '/'
289
290
  end
290
291
 
291
292
  # If the path is absolute, set the scheme and host.
292
- if uri.path =~ /^\//
293
+ if uri.path.start_with?(SLASH)
293
294
  uri.scheme = "file"
294
295
  uri.host = EMPTY_STR
295
296
  end
@@ -326,6 +327,21 @@ module Addressable
326
327
  return result
327
328
  end
328
329
 
330
+ ##
331
+ # Tables used to optimize encoding operations in `self.encode_component`
332
+ # and `self.normalize_component`
333
+ SEQUENCE_ENCODING_TABLE = Hash.new do |hash, sequence|
334
+ hash[sequence] = sequence.unpack("C*").map do |c|
335
+ format("%02x", c)
336
+ end.join
337
+ end
338
+
339
+ SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = Hash.new do |hash, sequence|
340
+ hash[sequence] = sequence.unpack("C*").map do |c|
341
+ format("%%%02X", c)
342
+ end.join
343
+ end
344
+
329
345
  ##
330
346
  # Percent encodes a URI component.
331
347
  #
@@ -392,12 +408,14 @@ module Addressable
392
408
  component.force_encoding(Encoding::ASCII_8BIT)
393
409
  # Avoiding gsub! because there are edge cases with frozen strings
394
410
  component = component.gsub(character_class) do |sequence|
395
- (sequence.unpack('C*').map { |c| "%" + ("%02x" % c).upcase }).join
411
+ SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[sequence]
396
412
  end
397
413
  if upcase_encoded.length > 0
398
- component = component.gsub(/%(#{upcase_encoded.chars.map do |char|
399
- char.unpack('C*').map { |c| '%02x' % c }.join
400
- end.join('|')})/i) { |s| s.upcase }
414
+ upcase_encoded_chars = upcase_encoded.chars.map do |char|
415
+ SEQUENCE_ENCODING_TABLE[char]
416
+ end
417
+ component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
418
+ &:upcase)
401
419
  end
402
420
  return component
403
421
  end
@@ -531,7 +549,7 @@ module Addressable
531
549
  character_class = "#{character_class}%" unless character_class.include?('%')
532
550
 
533
551
  "|%(?!#{leave_encoded.chars.map do |char|
534
- seq = char.unpack('C*').map { |c| '%02x' % c }.join
552
+ seq = SEQUENCE_ENCODING_TABLE[char]
535
553
  [seq.upcase, seq.downcase]
536
554
  end.flatten.join('|')})"
537
555
  end
@@ -1172,7 +1190,7 @@ module Addressable
1172
1190
  # Returns the top-level domain for this host.
1173
1191
  #
1174
1192
  # @example
1175
- # Addressable::URI.parse("www.example.co.uk").tld # => "co.uk"
1193
+ # Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
1176
1194
  def tld
1177
1195
  PublicSuffix.parse(self.host, ignore_private: true).tld
1178
1196
  end
@@ -1182,7 +1200,7 @@ module Addressable
1182
1200
  #
1183
1201
  # @param [String, #to_str] new_tld The new top-level domain.
1184
1202
  def tld=(new_tld)
1185
- replaced_tld = domain.sub(/#{tld}\z/, new_tld)
1203
+ replaced_tld = host.sub(/#{tld}\z/, new_tld)
1186
1204
  self.host = PublicSuffix::Domain.new(replaced_tld).to_s
1187
1205
  end
1188
1206
 
@@ -1190,7 +1208,7 @@ module Addressable
1190
1208
  # Returns the public suffix domain for this host.
1191
1209
  #
1192
1210
  # @example
1193
- # Addressable::URI.parse("www.example.co.uk").domain # => "example.co.uk"
1211
+ # Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
1194
1212
  def domain
1195
1213
  PublicSuffix.domain(self.host, ignore_private: true)
1196
1214
  end
@@ -1595,6 +1613,7 @@ module Addressable
1595
1613
  # Make sure possible key-value pair delimiters are escaped.
1596
1614
  modified_query_class.sub!("\\&", "").sub!("\\;", "")
1597
1615
  pairs = (self.query || "").split("&", -1)
1616
+ pairs.delete_if(&:empty?) if flags.include?(:compacted)
1598
1617
  pairs.sort! if flags.include?(:sorted)
1599
1618
  component = pairs.map do |pair|
1600
1619
  Addressable::URI.normalize_component(pair, modified_query_class, "+")
@@ -1660,7 +1679,7 @@ module Addressable
1660
1679
  # Treating '+' as a space was just an unbelievably bad idea.
1661
1680
  # There was nothing wrong with '%20'!
1662
1681
  # If it ain't broke, don't fix it!
1663
- pair[1] = URI.unencode_component(pair[1].to_str.gsub(/\+/, " "))
1682
+ pair[1] = URI.unencode_component(pair[1].to_str.tr("+", " "))
1664
1683
  end
1665
1684
  if return_type == Hash
1666
1685
  accu[pair[0]] = pair[1]
@@ -1917,7 +1936,7 @@ module Addressable
1917
1936
  # Section 5.2.3 of RFC 3986
1918
1937
  #
1919
1938
  # Removes the right-most path segment from the base path.
1920
- if base_path =~ /\//
1939
+ if base_path.include?(SLASH)
1921
1940
  base_path.sub!(/\/[^\/]+$/, SLASH)
1922
1941
  else
1923
1942
  base_path = EMPTY_STR
@@ -2367,10 +2386,10 @@ module Addressable
2367
2386
  #
2368
2387
  # @param [Proc] block
2369
2388
  # A set of operations to perform on a given URI.
2370
- def defer_validation(&block)
2371
- raise LocalJumpError, "No block given." unless block
2389
+ def defer_validation
2390
+ raise LocalJumpError, "No block given." unless block_given?
2372
2391
  @validation_deferred = true
2373
- block.call()
2392
+ yield
2374
2393
  @validation_deferred = false
2375
2394
  validate
2376
2395
  return nil
@@ -23,7 +23,7 @@ if !defined?(Addressable::VERSION)
23
23
  module Addressable
24
24
  module VERSION
25
25
  MAJOR = 2
26
- MINOR = 6
26
+ MINOR = 7
27
27
  TINY = 0
28
28
 
29
29
  STRING = [MAJOR, MINOR, TINY].join('.')
@@ -3944,7 +3944,7 @@ describe Addressable::URI, "when parsed from " +
3944
3944
  it "should raise an error if assigning a bogus object to the hostname" do
3945
3945
  expect(lambda do
3946
3946
  @uri.hostname = Object.new
3947
- end).to raise_error
3947
+ end).to raise_error(TypeError)
3948
3948
  end
3949
3949
 
3950
3950
  it "should have the correct port after assignment" do
@@ -4303,6 +4303,26 @@ describe Addressable::URI, "when parsed from " +
4303
4303
  end
4304
4304
  end
4305
4305
 
4306
+ describe Addressable::URI, "when parsed from 'http://example/?b=1&a=2&c=3'" do
4307
+ before do
4308
+ @uri = Addressable::URI.parse("http://example/?b=1&a=2&c=3")
4309
+ end
4310
+
4311
+ it "should have a sorted normalized query of 'a=2&b=1&c=3'" do
4312
+ expect(@uri.normalized_query(:sorted)).to eq("a=2&b=1&c=3")
4313
+ end
4314
+ end
4315
+
4316
+ describe Addressable::URI, "when parsed from 'http://example/?&a&&c&'" do
4317
+ before do
4318
+ @uri = Addressable::URI.parse("http://example/?&a&&c&")
4319
+ end
4320
+
4321
+ it "should have a compacted normalized query of 'a&c'" do
4322
+ expect(@uri.normalized_query(:compacted)).to eq("a&c")
4323
+ end
4324
+ end
4325
+
4306
4326
  describe Addressable::URI, "when parsed from " +
4307
4327
  "'http://example.com/sound%2bvision'" do
4308
4328
  before do
@@ -4417,7 +4437,7 @@ describe Addressable::URI, "when parsed from " +
4417
4437
  expect(lambda do
4418
4438
  # This would create an invalid URI
4419
4439
  @uri.authority = nil
4420
- end).to raise_error
4440
+ end).to raise_error(Addressable::URI::InvalidURIError)
4421
4441
  end
4422
4442
  end
4423
4443
 
@@ -4820,7 +4840,7 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
4820
4840
 
4821
4841
  it "should raise an error for invalid return type values" do
4822
4842
  expect(lambda do
4823
- @uri.query_values(Fixnum)
4843
+ @uri.query_values(Integer)
4824
4844
  end).to raise_error(ArgumentError)
4825
4845
  end
4826
4846
 
@@ -5515,18 +5535,18 @@ describe Addressable::URI, "when given the tld " do
5515
5535
  end
5516
5536
 
5517
5537
  context "which " do
5518
- let (:uri) { Addressable::URI.parse("http://comrade.net/path/to/source/") }
5538
+ let (:uri) { Addressable::URI.parse("http://www.comrade.net/path/to/source/") }
5519
5539
 
5520
5540
  it "contains a subdomain" do
5521
5541
  uri.tld = "co.uk"
5522
5542
 
5523
- expect(uri.to_s).to eq("http://comrade.co.uk/path/to/source/")
5543
+ expect(uri.to_s).to eq("http://www.comrade.co.uk/path/to/source/")
5524
5544
  end
5525
5545
 
5526
5546
  it "is part of the domain" do
5527
5547
  uri.tld = "com"
5528
5548
 
5529
- expect(uri.to_s).to eq("http://comrade.com/path/to/source/")
5549
+ expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
5530
5550
  end
5531
5551
  end
5532
5552
  end
@@ -6352,6 +6372,44 @@ describe Addressable::URI, "when given the input " +
6352
6372
  end
6353
6373
  end
6354
6374
 
6375
+ describe Addressable::URI, "when given the input: 'user@domain.com'" do
6376
+ before do
6377
+ @input = "user@domain.com"
6378
+ end
6379
+
6380
+ context "for heuristic parse" do
6381
+ it "should remain 'mailto:user@domain.com'" do
6382
+ uri = Addressable::URI.heuristic_parse("mailto:#{@input}")
6383
+ expect(uri.to_s).to eq("mailto:user@domain.com")
6384
+ end
6385
+
6386
+ it "should have a scheme of 'mailto'" do
6387
+ uri = Addressable::URI.heuristic_parse(@input)
6388
+ expect(uri.to_s).to eq("mailto:user@domain.com")
6389
+ expect(uri.scheme).to eq("mailto")
6390
+ end
6391
+
6392
+ it "should remain 'acct:user@domain.com'" do
6393
+ uri = Addressable::URI.heuristic_parse("acct:#{@input}")
6394
+ expect(uri.to_s).to eq("acct:user@domain.com")
6395
+ end
6396
+
6397
+ context "HTTP" do
6398
+ before do
6399
+ @uri = Addressable::URI.heuristic_parse("http://#{@input}/")
6400
+ end
6401
+
6402
+ it "should remain 'http://user@domain.com/'" do
6403
+ expect(@uri.to_s).to eq("http://user@domain.com/")
6404
+ end
6405
+
6406
+ it "should have the username 'user' for HTTP basic authentication" do
6407
+ expect(@uri.user).to eq("user")
6408
+ end
6409
+ end
6410
+ end
6411
+ end
6412
+
6355
6413
  describe Addressable::URI, "when assigning query values" do
6356
6414
  before do
6357
6415
  @uri = Addressable::URI.new
@@ -20,10 +20,10 @@ namespace :gem do
20
20
  exit(1)
21
21
  end
22
22
 
23
- s.required_ruby_version = '>= 2.0'
23
+ s.required_ruby_version = ">= 2.0"
24
24
 
25
- s.add_runtime_dependency 'public_suffix', '>= 2.0.2', '< 4.0'
26
- s.add_development_dependency 'bundler', '>= 1.0', '< 3.0'
25
+ s.add_runtime_dependency "public_suffix", ">= 2.0.2", "< 5.0"
26
+ s.add_development_dependency "bundler", ">= 1.0", "< 3.0"
27
27
 
28
28
  s.require_path = "lib"
29
29
 
@@ -42,7 +42,7 @@ namespace :gem do
42
42
  desc "Generates .gemspec file"
43
43
  task :gemspec do
44
44
  spec_string = GEM_SPEC.to_ruby
45
- File.open("#{GEM_SPEC.name}.gemspec", 'w') do |file|
45
+ File.open("#{GEM_SPEC.name}.gemspec", "w") do |file|
46
46
  file.write spec_string
47
47
  end
48
48
  end
@@ -72,9 +72,9 @@ namespace :gem do
72
72
  desc "Reinstall the gem"
73
73
  task :reinstall => [:uninstall, :install]
74
74
 
75
- desc 'Package for release'
75
+ desc "Package for release"
76
76
  task :release => ["gem:package", "gem:gemspec"] do |t|
77
- v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
77
+ v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
78
78
  abort "Versions don't match #{v} vs #{PROJ.version}" if v != PKG_VERSION
79
79
  pkg = "pkg/#{GEM_SPEC.full_name}"
80
80
 
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: addressable
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.6.0
4
+ version: 2.7.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Bob Aman
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2019-01-18 00:00:00.000000000 Z
11
+ date: 2019-08-31 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: public_suffix
@@ -19,7 +19,7 @@ dependencies:
19
19
  version: 2.0.2
20
20
  - - "<"
21
21
  - !ruby/object:Gem::Version
22
- version: '4.0'
22
+ version: '5.0'
23
23
  type: :runtime
24
24
  prerelease: false
25
25
  version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
29
29
  version: 2.0.2
30
30
  - - "<"
31
31
  - !ruby/object:Gem::Version
32
- version: '4.0'
32
+ version: '5.0'
33
33
  - !ruby/object:Gem::Dependency
34
34
  name: bundler
35
35
  requirement: !ruby/object:Gem::Requirement
@@ -51,9 +51,9 @@ dependencies:
51
51
  - !ruby/object:Gem::Version
52
52
  version: '3.0'
53
53
  description: |
54
- Addressable is a replacement for the URI implementation that is part of
55
- Ruby's standard library. It more closely conforms to the relevant RFCs and
56
- adds support for IRIs and URI templates.
54
+ Addressable is an alternative implementation to the URI implementation that is
55
+ part of Ruby's standard library. It is flexible, offers heuristic parsing, and
56
+ additionally provides extensive support for IRIs and URI templates.
57
57
  email: bob@sporkmonger.com
58
58
  executables: []
59
59
  extensions: []
@@ -108,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
108
108
  version: '0'
109
109
  requirements: []
110
110
  rubyforge_project:
111
- rubygems_version: 2.5.1
111
+ rubygems_version: 2.5.2.3
112
112
  signing_key:
113
113
  specification_version: 4
114
114
  summary: URI Implementation