addressable 2.5.0 → 2.8.0

data/lib/addressable/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -21,7 +23,7 @@ if !defined?(Addressable::VERSION)
   module Addressable
     module VERSION
       MAJOR = 2
-      MINOR = 5
+      MINOR = 8
       TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/addressable/idna_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -26,9 +28,9 @@ shared_examples_for "converting from unicode to ASCII" do
     expect(Addressable::IDNA.to_ascii("www.google.com")).to eq("www.google.com")
   end
 
-  LONG = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
-  it "should convert '#{LONG}' correctly" do
-    expect(Addressable::IDNA.to_ascii(LONG)).to eq(LONG)
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_ascii(long)).to eq(long)
   end
 
   it "should convert 'www.詹姆斯.com' correctly" do
@@ -134,6 +136,12 @@ shared_examples_for "converting from unicode to ASCII" do
     )).to eq("xn--4ud")
   end
 
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\360\237\214\271\360\237\214\271\360\237\214\271.ws"
+    )).to eq("xn--2h8haa.ws")
+  end
+
   it "should handle two adjacent '.'s correctly" do
     expect(Addressable::IDNA.to_ascii(
       "example..host"
@@ -142,9 +150,9 @@ shared_examples_for "converting from unicode to ASCII" do
 end
 
 shared_examples_for "converting from ASCII to unicode" do
-  LONG = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
-  it "should convert '#{LONG}' correctly" do
-    expect(Addressable::IDNA.to_unicode(LONG)).to eq(LONG)
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_unicode(long)).to eq(long)
   end
 
   it "should return the identity conversion when punycode decode fails" do
@@ -231,6 +239,12 @@ shared_examples_for "converting from ASCII to unicode" do
     )).to eq("\341\206\265")
   end
 
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--2h8haa.ws"
+    )).to eq("\360\237\214\271\360\237\214\271\360\237\214\271.ws")
+  end
+
   it "should handle two adjacent '.'s correctly" do
     expect(Addressable::IDNA.to_unicode(
       "example..host"
@@ -280,7 +294,9 @@ begin
     it_should_behave_like "converting from unicode to ASCII"
     it_should_behave_like "converting from ASCII to unicode"
   end
-rescue LoadError
+rescue LoadError => error
+  raise error if ENV["CI"] && TestHelper.native_supported?
+
   # Cannot test the native implementation without libidn support.
   warn('Could not load native IDN implementation.')
 end

data/spec/addressable/net_http_compat_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #

data/spec/addressable/security_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #

data/spec/addressable/template_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -17,6 +19,7 @@
 require "spec_helper"
 
 require "bigdecimal"
+require "timeout"
 require "addressable/template"
 
 shared_examples_for 'expands' do |tests|
@@ -82,7 +85,7 @@ describe "Type conversion" do
       :hello => 1234,
       :nothing => nil,
       :sym => :symbolic,
-      :decimal => BigDecimal.new('1')
+      :decimal => BigDecimal('1')
     }
   }
 
@@ -91,7 +94,7 @@ describe "Type conversion" do
     '{hello}' => '1234',
     '{nothing}' => '',
     '{sym}' => 'symbolic',
-    '{decimal}' => '0.1E1'
+    '{decimal}' => RUBY_VERSION < '2.4.0' ? '0.1E1' : '0.1e1'
   }
 end
 
@@ -949,6 +952,36 @@ describe Addressable::Template do
         )
       end
     end
+    context "issue #307 - partial_expand form query with nil params" do
+      subject do
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      end
+      it "builds a new pattern with two=nil" do
+        expect(subject.partial_expand(two: nil).pattern).to eq(
+          "http://example.com/{?one}{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=nil" do
+        expect(subject.partial_expand(one: nil, two: nil).pattern).to eq(
+          "http://example.com/{?three}/"
+        )
+      end
+      it "builds a new pattern with one=1 and two=nil" do
+        expect(subject.partial_expand(one: 1, two: nil).pattern).to eq(
+          "http://example.com/?one=1{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=2" do
+        expect(subject.partial_expand(one: nil, two: 2).pattern).to eq(
+          "http://example.com/?two=2{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil" do
+        expect(subject.partial_expand(one: nil).pattern).to eq(
+          "http://example.com/{?two}{&three}/"
+        )
+      end
+    end
     context "partial_expand with query string" do
       subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
@@ -969,6 +1002,24 @@ describe Addressable::Template do
         )
       end
     end
+    context "partial expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/{resource}/{query}/")
+      end
+      it "normalizes unicode by default" do
+        template = subject.partial_expand("query" => "Cafe\u0301")
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Caf%C3%A9/"
+        )
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        template = subject.partial_expand({"query" => "Cafe\u0301"}, nil, false)
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Cafe%CC%81/"
+        )
+      end
+    end
   end
   describe "Partial expand with strings" do
     context "partial_expand with two simple values" do
@@ -1013,6 +1064,20 @@ describe Addressable::Template do
     end
   end
   describe "Expand" do
+    context "expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/search/{query}/")
+      end
+      it "normalizes unicode by default" do
+        uri = subject.expand("query" => "Cafe\u0301").to_str
+        expect(uri).to eq("http://example.com/search/Caf%C3%A9/")
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        uri = subject.expand({ "query" => "Cafe\u0301" }, nil, false).to_str
+        expect(uri).to eq("http://example.com/search/Cafe%CC%81/")
+      end
+    end
     context "expand with a processor" do
       subject {
         Addressable::Template.new("http://example.com/search/{query}/")
@@ -1276,6 +1341,14 @@ describe Addressable::Template do
         expect(subject).not_to match("foo_bar*")
         expect(subject).not_to match("foo_bar:20")
       end
+
+      it 'should parse in a reasonable time' do
+        expect do
+          Timeout.timeout(0.1) do
+            expect(subject).not_to match("0"*25 + "!")
+          end
+        end.not_to raise_error
+      end
     end
     context "VARIABLE_LIST" do
       subject { Addressable::Template::VARIABLE_LIST }

data/spec/addressable/uri_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -63,124 +65,116 @@ end
 
 describe Addressable::URI, "when created with a non-numeric port number" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:port => "bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a invalid encoded port number" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:port => "%eb")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string scheme" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:scheme => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string user" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:user => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string password" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:password => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string userinfo" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:userinfo => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string host" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:host => :bogus)
-    end).to raise_error(TypeError)
-  end
-end
-
-describe Addressable::URI, "when created with a non-string authority" do
-  it "should raise an error" do
-    expect(lambda do
-      Addressable::URI.new(:authority => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string authority" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string path" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:path => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string query" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:query => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string fragment" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:fragment => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a scheme but no hierarchical " +
     "segment" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http:")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "quote handling" do
   describe 'in host name' do
     it "should raise an error for single quote" do
-      expect(lambda do
+      expect do
         Addressable::URI.parse("http://local\"host/")
-      end).to raise_error(Addressable::URI::InvalidURIError)
+      end.to raise_error(Addressable::URI::InvalidURIError)
     end
   end
 end
 
 describe Addressable::URI, "newline normalization" do
   it "should not accept newlines in scheme" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("ht%0atp://localhost/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not unescape newline in path" do
@@ -205,47 +199,47 @@ describe Addressable::URI, "newline normalization" do
 
   it "should not accept newline in hostname" do
     uri = Addressable::URI.parse("http://localhost/")
-    expect(lambda do
+    expect do
       uri.host = "local\nhost"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with ambiguous path" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("::http")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with an invalid host" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:host => "<invalid>")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a host consisting of " +
     "sub-delims characters" do
   it "should not raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(
         :host => Addressable::URI::CharacterClasses::SUB_DELIMS.gsub(/\\/, '')
       )
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
 describe Addressable::URI, "when created with a host consisting of " +
     "unreserved characters" do
   it "should not raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(
         :host => Addressable::URI::CharacterClasses::UNRESERVED.gsub(/\\/, '')
       )
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -275,83 +269,83 @@ describe Addressable::URI, "when created from nil components" do
   end
 
   it "should raise an error if the scheme is set to whitespace" do
-    expect(lambda do
+    expect do
       @uri.scheme = "\t \n"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\t \n'/)
   end
 
   it "should raise an error if the scheme is set to all digits" do
-    expect(lambda do
+    expect do
       @uri.scheme = "123"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'123'/)
   end
 
   it "should raise an error if the scheme begins with a digit" do
-    expect(lambda do
+    expect do
       @uri.scheme = "1scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'1scheme'/)
   end
 
   it "should raise an error if the scheme begins with a plus" do
-    expect(lambda do
+    expect do
       @uri.scheme = "+scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\+scheme'/)
   end
 
   it "should raise an error if the scheme begins with a dot" do
-    expect(lambda do
+    expect do
       @uri.scheme = ".scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\.scheme'/)
   end
 
   it "should raise an error if the scheme begins with a dash" do
-    expect(lambda do
+    expect do
       @uri.scheme = "-scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'-scheme'/)
   end
 
   it "should raise an error if the scheme contains an illegal character" do
-    expect(lambda do
+    expect do
       @uri.scheme = "scheme!"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'scheme!'/)
   end
 
   it "should raise an error if the scheme contains whitespace" do
-    expect(lambda do
+    expect do
       @uri.scheme = "sch eme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'sch eme'/)
   end
 
   it "should raise an error if the scheme contains a newline" do
-    expect(lambda do
+    expect do
       @uri.scheme = "sch\neme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.user = "user"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.password = "pass"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.scheme = "http"
       @uri.fragment = "fragment"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.fragment = "fragment"
       @uri.scheme = "http"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -963,6 +957,10 @@ describe Addressable::URI, "when frozen" do
     expect(@uri.normalize.query).to eq("a=1")
   end
 
+  it "returns '/%70a%74%68?a=%31' for #request_uri" do
+    expect(@uri.request_uri).to eq("/%70a%74%68?a=%31")
+  end
+
   it "returns '1%323' for #fragment" do
     expect(@uri.fragment).to eq("1%323")
   end
@@ -1017,31 +1015,31 @@ describe Addressable::URI, "when created from string components" do
   end
 
   it "should raise an error if invalid components omitted" do
-    expect(lambda do
+    expect do
       @uri.omit(:bogus)
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       @uri.omit(:scheme, :bogus, :path)
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
 describe Addressable::URI, "when created with a nil host but " +
     "non-nil authority components" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:user => "user", :password => "pass", :port => 80)
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with both an authority and a user" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(
         :user => "user", :authority => "user@example.com:80"
       )
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
@@ -1079,33 +1077,33 @@ end
 
 describe Addressable::URI, "when created with a host with a backslash" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => "example\\example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a host with a slash" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => "example/example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a host with a space" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => "example example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with both a userinfo and a user" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:user => "user", :userinfo => "user:pass")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
@@ -1197,18 +1195,18 @@ describe Addressable::URI, "when parsed from something that looks " +
     "like a URI object" do
   it "should parse without error" do
     uri = Addressable::URI.parse(Fake::URI::HTTP.new("http://example.com/"))
-    expect(lambda do
+    expect do
       Addressable::URI.parse(uri)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
 describe Addressable::URI, "when parsed from a standard library URI object" do
   it "should parse without error" do
     uri = Addressable::URI.parse(URI.parse("http://example.com/"))
-    expect(lambda do
+    expect do
       Addressable::URI.parse(uri)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -1368,9 +1366,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not allow request URI assignment" do
-    expect(lambda do
+    expect do
       @uri.request_uri = "/"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should have a query of 'objectClass?one'" do
@@ -1392,9 +1390,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if omission would create an invalid URI" do
-    expect(lambda do
+    expect do
       @uri.omit(:authority, :path)
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should have an origin of 'ldap://[2001:db8::7]'" do
@@ -1780,9 +1778,9 @@ describe Addressable::URI, "when parsed from " +
 
   it "should not be roughly equal to the string " +
       "'http://example.com:bogus/'" do
-    expect(lambda do
+    expect do
       expect(@uri === "http://example.com:bogus/").to eq(false)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should result in itself when joined with itself" do
@@ -1812,21 +1810,21 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not allow origin assignment without scheme" do
-    expect(lambda do
+    expect do
       @uri.origin = "example.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow origin assignment without host" do
-    expect(lambda do
+    expect do
       @uri.origin = "http://"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow origin assignment with bogus type" do
-    expect(lambda do
+    expect do
       @uri.origin = :bogus
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   # Section 6.2.3 of RFC 3986
@@ -1882,9 +1880,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "when joined with a bogus object a TypeError should be raised" do
-    expect(lambda do
+    expect do
       @uri.join(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct username after assignment" do
@@ -1979,15 +1977,29 @@ end
 
 # Section 5.1.2 of RFC 2616
 describe Addressable::URI, "when parsed from " +
-    "'http://www.w3.org/pub/WWW/TheProject.html'" do
+    "'HTTP://www.w3.org/pub/WWW/TheProject.html'" do
   before do
-    @uri = Addressable::URI.parse("http://www.w3.org/pub/WWW/TheProject.html")
+    @uri = Addressable::URI.parse("HTTP://www.w3.org/pub/WWW/TheProject.html")
   end
 
   it "should have the correct request URI" do
     expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html")
   end
 
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/pub/WWW/TheProject.html?"
+    expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html?")
+    expect(@uri.path).to eq("/pub/WWW/TheProject.html")
+    expect(@uri.query).to eq("")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html"
+    expect(@uri.request_uri).to eq("/some/where/else.html")
+    expect(@uri.path).to eq("/some/where/else.html")
+    expect(@uri.query).to eq(nil)
+  end
+
   it "should have the correct request URI after assignment" do
     @uri.request_uri = "/some/where/else.html?query?string"
     expect(@uri.request_uri).to eq("/some/where/else.html?query?string")
@@ -2003,20 +2015,20 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if the site value is set to something bogus" do
-    expect(lambda do
+    expect do
       @uri.site = 42
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error if the request URI is set to something bogus" do
-    expect(lambda do
+    expect do
       @uri.request_uri = 42
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly convert to a hash" do
     expect(@uri.to_hash).to eq({
-      :scheme => "http",
+      :scheme => "HTTP",
       :user => nil,
       :password => nil,
       :host => "www.w3.org",
@@ -2060,9 +2072,9 @@ describe Addressable::URI, "when parsing IPv6 addresses" do
 
   it "should raise an error for " +
       "'http://[<invalid>]/'" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://[<invalid>]/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2088,9 +2100,9 @@ describe Addressable::URI, "when assigning IPv6 address" do
   it "should not allow to set bare IPv6 address as host" do
     uri = Addressable::URI.parse("http://[::1]/")
     skip "not checked"
-    expect(lambda do
+    expect do
       uri.host = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2122,9 +2134,9 @@ describe Addressable::URI, "when parsing IPvFuture addresses" do
 
   it "should raise an error for " +
       "'http://[v0.<invalid>]/'" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://[v0.<invalid>]/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2468,9 +2480,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2522,9 +2534,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2547,9 +2559,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2585,9 +2597,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if encoding with an unexpected return type" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalized_encode(@uri, Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "if percent encoded should be 'http://example.com/C%25CC%25A7'" do
@@ -2603,9 +2615,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if encoding with an unexpected return type" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode(@uri, Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should be identical to its duplicate" do
@@ -2740,9 +2752,9 @@ describe Addressable::URI, "when parsed from " +
 
   it "should not be roughly equal to the string " +
       "'http://example.com:bogus/'" do
-    expect(lambda do
+    expect do
       expect(@uri === "http://example.com:bogus/").to eq(false)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should result in itself when joined with itself" do
@@ -3088,9 +3100,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should become invalid when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).to raise_error(Addressable::URI::InvalidURIError, /authority/)
+    end.to raise_error(Addressable::URI::InvalidURIError, /authority/)
   end
 
   it "should have a path of '/..//example.com'" do
@@ -3328,12 +3340,12 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if routing is attempted" do
-    expect(lambda do
+    expect do
       @uri.route_to("http://example.com/")
-    end).to raise_error(ArgumentError, /relative\/path\/to\/resource/)
-    expect(lambda do
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+    expect do
       @uri.route_from("http://example.com/")
-    end).to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
   end
 
   it "when joined with 'another/relative/path' should be " +
@@ -3930,9 +3942,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if assigning a bogus object to the hostname" do
-    expect(lambda do
+    expect do
       @uri.hostname = Object.new
-    end).to raise_error
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct port after assignment" do
@@ -4011,9 +4023,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if query values are set to a bogus type" do
-    expect(lambda do
+    expect do
       @uri.query_values = "bogus"
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct fragment after assignment" do
@@ -4085,39 +4097,39 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should fail to merge with bogus values" do
-    expect(lambda do
+    expect do
       @uri.merge(:port => "bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should fail to merge with bogus values" do
-    expect(lambda do
+    expect do
       @uri.merge(:authority => "bar@baz:bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should fail to merge with bogus parameters" do
-    expect(lambda do
+    expect do
       @uri.merge(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should fail to merge with bogus parameters" do
-    expect(lambda do
+    expect do
       @uri.merge("http://example.com/")
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should fail to merge with both authority and subcomponents" do
-    expect(lambda do
+    expect do
       @uri.merge(:authority => "foo:bar@baz:42", :port => "42")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should fail to merge with both userinfo and subcomponents" do
-    expect(lambda do
+    expect do
       @uri.merge(:userinfo => "foo:bar", :user => "foo")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should be identical to its duplicate" do
@@ -4250,6 +4262,36 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from 'https://example.com/?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("https://example.com/?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'example.com?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("example.com?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'mailto:?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("mailto:?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a+b'}" do
+    expect(@uri.query_values).to eq("q" => "a+b")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/?q=a%2bb'" do
   before do
@@ -4291,6 +4333,46 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from 'http://example/?b=1&a=2&c=3'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?b=1&a=2&c=3")
+  end
+
+  it "should have a sorted normalized query of 'a=2&b=1&c=3'" do
+    expect(@uri.normalized_query(:sorted)).to eq("a=2&b=1&c=3")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example/?&a&&c&'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?&a&&c&")
+  end
+
+  it "should have a compacted normalized query of 'a&c'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a&c")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example.com/?a=1&a=1'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=1")
+  end
+
+  it "should have a compacted normalized query of 'a=1'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example.com/?a=1&a=2'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=2")
+  end
+
+  it "should have a compacted normalized query of 'a=1&a=2'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1&a=2")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/sound%2bvision'" do
   before do
@@ -4402,10 +4484,10 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error after nil assignment of authority segment" do
-    expect(lambda do
+    expect do
       # This would create an invalid URI
       @uri.authority = nil
-    end).to raise_error
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -4634,12 +4716,12 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if routing is attempted" do
-    expect(lambda do
+    expect do
       @uri.route_to("http://example.com/")
-    end).to raise_error(ArgumentError, /\/\/example.com\//)
-    expect(lambda do
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
+    expect do
       @uri.route_from("http://example.com/")
-    end).to raise_error(ArgumentError, /\/\/example.com\//)
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
   end
 
   it "should have a 'null' origin" do
@@ -4733,9 +4815,9 @@ end
 describe Addressable::URI, "when parsed from " +
     "'http://under_score.example.com/'" do
   it "should not cause an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://under_score.example.com/")
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -4807,9 +4889,9 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
   end
 
   it "should raise an error for invalid return type values" do
-    expect(lambda do
-      @uri.query_values(Fixnum)
-    end).to raise_error(ArgumentError)
+    expect do
+      @uri.query_values(Integer)
+    end.to raise_error(ArgumentError)
   end
 
   it "should have the correct array query values" do
@@ -5410,9 +5492,9 @@ describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
   end
 
   it "when joined with a bogus object a TypeError should be raised" do
-    expect(lambda do
+    expect do
       Addressable::URI.join(@uri, 42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5439,9 +5521,9 @@ end
 
 describe Addressable::URI, "when converting a bogus path" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.convert_path(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5494,6 +5576,31 @@ describe Addressable::URI, "when given the path '/one/two/'" do
   end
 end
 
+describe Addressable::URI, "when given the tld " do
+  it "'uk' should have a tld of 'uk'" do
+    uri = Addressable::URI.parse("http://example.com")
+    uri.tld = "uk"
+
+    expect(uri.tld).to eq("uk")
+  end
+
+  context "which " do
+    let (:uri) { Addressable::URI.parse("http://www.comrade.net/path/to/source/") }
+
+    it "contains a subdomain" do
+      uri.tld = "co.uk"
+
+      expect(uri.to_s).to eq("http://www.comrade.co.uk/path/to/source/")
+    end
+
+    it "is part of the domain" do
+      uri.tld = "com"
+
+      expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
+    end
+  end
+end
+
 describe Addressable::URI, "when given the path " +
     "'c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
@@ -5611,9 +5718,9 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly parse heuristically anything with a 'to_str' method" do
@@ -5621,9 +5728,9 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.heuristic_parse(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5667,9 +5774,9 @@ end
 
 describe Addressable::URI, "when form encoding a non-Array object" do
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.form_encode(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5735,9 +5842,9 @@ describe Addressable::URI, "when form unencoding a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.form_unencode(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5747,15 +5854,15 @@ describe Addressable::URI, "when normalizing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalize_component(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalize_component("component", 42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5827,6 +5934,18 @@ describe Addressable::URI, "when normalizing a string but leaving some character
   end
 end
 
+describe Addressable::URI, "when encoding IP literals" do
+  it "should work for IPv4" do
+    input = "http://127.0.0.1/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+
+  it "should work for IPv6" do
+    input = "http://[fe80::200:f8ff:fe21:67cf]/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+end
+
 describe Addressable::URI, "when encoding a string with existing encodings to upcase" do
   it "should result in correct percent encoded sequence" do
     expect(Addressable::URI.encode_component("JK%4c", "0-9A-IKM-Za-z%", "L")).to eq("%4AK%4C")
@@ -5899,41 +6018,41 @@ end
 
 describe Addressable::URI, "when unencoding a bogus object" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.unencode_component(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.unencode("/path?g%C3%BCnther", Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when encoding a bogus object" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalized_encode(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode_component("günther", Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode_component(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5949,9 +6068,9 @@ describe Addressable::URI, "when given the input " +
   end
 
   it "should not raise error when frozen" do
-    expect(lambda do
+    expect do
       Addressable::URI.heuristic_parse(@input).freeze.to_s
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -6231,6 +6350,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input which "\
+  "start with digits and has specified port" do
+  before do
+    @input = "7777.example.org:8089"
+  end
+
+  it "should heuristically parse to 'http://7777.example.org:8089'" do
+    uri = Addressable::URI.heuristic_parse(@input)
+    expect(uri.to_s).to eq("http://7777.example.org:8089")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed:///example.com'" do
   before do
@@ -6243,6 +6374,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://localhost/path/to/resource/'" do
+  before do
+    @input = "file://localhost/path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:///path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'file://path/to/resource/'" do
   before do
@@ -6255,6 +6398,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://///path/to/resource/'" do
+  before do
+    @input = "file:///////path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:////path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:////path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed://http://example.com'" do
   before do
@@ -6279,6 +6434,44 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input: 'user@domain.com'" do
+  before do
+    @input = "user@domain.com"
+  end
+
+  context "for heuristic parse" do
+    it "should remain 'mailto:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("mailto:#{@input}")
+      expect(uri.to_s).to eq("mailto:user@domain.com")
+    end
+
+    it "should have a scheme of 'mailto'" do
+      uri = Addressable::URI.heuristic_parse(@input)
+      expect(uri.to_s).to   eq("mailto:user@domain.com")
+      expect(uri.scheme).to eq("mailto")
+    end
+
+    it "should remain 'acct:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("acct:#{@input}")
+      expect(uri.to_s).to eq("acct:user@domain.com")
+    end
+
+    context "HTTP" do
+      before do
+        @uri = Addressable::URI.heuristic_parse("http://#{@input}/")
+      end
+
+      it "should remain 'http://user@domain.com/'" do
+        expect(@uri.to_s).to eq("http://user@domain.com/")
+      end
+
+      it "should have the username 'user' for HTTP basic authentication" do
+        expect(@uri.user).to eq("user")
+      end
+    end
+  end
+end
+
 describe Addressable::URI, "when assigning query values" do
   before do
     @uri = Addressable::URI.new
@@ -6290,54 +6483,54 @@ describe Addressable::URI, "when assigning query values" do
   end
 
   it "should raise an error attempting to assign {'a' => {'b' => ['c']}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = { 'a' => {'b' => ['c'] } }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:b => '2', :a => {:c => '1'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {:b => '2', :a => {:c => '1'}}
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => true, :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => {:c => true, :d => 'd'}
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => {:c => true, :d => 'd'}
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly assign {:a => 1, :b => 1.5}" do
@@ -6348,13 +6541,13 @@ describe Addressable::URI, "when assigning query values" do
   it "should raise an error attempting to assign " +
       "{:z => 1, :f => [2, {999.1 => [3,'4']}, ['h', 'i']], " +
       ":a => {:b => ['c', 'd'], :e => true, :y => 0.5}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :z => 1,
         :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
         :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly assign {}" do
@@ -6404,7 +6597,7 @@ describe Addressable::URI, "when assigning path values" do
     @uri.path = "acct:bob@sporkmonger.com"
     expect(@uri.path).to eq("acct:bob@sporkmonger.com")
     expect(@uri.normalize.to_str).to eq("acct%2Fbob@sporkmonger.com")
-    expect(lambda { @uri.to_s }).to raise_error(
+    expect { @uri.to_s }.to raise_error(
       Addressable::URI::InvalidURIError
     )
   end
@@ -6422,26 +6615,26 @@ describe Addressable::URI, "when assigning path values" do
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.scheme = "http"
       @uri.host = "example.com"
       @uri.path = "acct:bob@sporkmonger.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.path = "acct:bob@sporkmonger.com"
       @uri.scheme = "http"
       @uri.host = "example.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
       @uri.scheme = "urn"
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end