addressable 2.6.0 → 2.8.0

data/lib/addressable/uri.rb

@@ -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.
@@ -207,7 +216,7 @@ module Addressable
       fragments = match.captures
       authority = fragments[3]
       if authority && authority.length > 0
-        new_authority = authority.gsub(/\\/, '/').gsub(/ /, '%20')
+        new_authority = authority.tr("\\", "/").gsub(" ", "%20")
         # NOTE: We want offset 4, not 3!
         offset = match.offset(4)
         uri = uri.dup
@@ -218,8 +227,9 @@ module Addressable
         parsed = self.parse(hints[:scheme] + "://" + uri)
       end
       if parsed.path.include?(".")
-        new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
-        if new_host
+        if parsed.path[/\b@\b/]
+          parsed.scheme = "mailto" unless parsed.scheme
+        elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
           parsed.defer_validation do
             new_path = parsed.path.sub(
               Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
@@ -281,15 +291,15 @@ module Addressable
         uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
           "/#{$1.downcase}:/"
         end
-        uri.path.gsub!(/\\/, SLASH)
+        uri.path.tr!("\\", SLASH)
         if File.exist?(uri.path) &&
             File.stat(uri.path).directory?
-          uri.path.sub!(/\/$/, EMPTY_STR)
+          uri.path.chomp!(SLASH)
           uri.path = uri.path + '/'
         end
 
         # If the path is absolute, set the scheme and host.
-        if uri.path =~ /^\//
+        if uri.path.start_with?(SLASH)
           uri.scheme = "file"
           uri.host = EMPTY_STR
         end
@@ -326,6 +336,21 @@ module Addressable
       return result
     end
 
+    ##
+    # Tables used to optimize encoding operations in `self.encode_component`
+    # and `self.normalize_component`
+    SEQUENCE_ENCODING_TABLE = Hash.new do |hash, sequence|
+      hash[sequence] = sequence.unpack("C*").map do |c|
+        format("%02x", c)
+      end.join
+    end
+
+    SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = Hash.new do |hash, sequence|
+      hash[sequence] = sequence.unpack("C*").map do |c|
+        format("%%%02X", c)
+      end.join
+    end
+
     ##
     # Percent encodes a URI component.
     #
@@ -392,18 +417,20 @@ module Addressable
       component.force_encoding(Encoding::ASCII_8BIT)
       # Avoiding gsub! because there are edge cases with frozen strings
       component = component.gsub(character_class) do |sequence|
-        (sequence.unpack('C*').map { |c| "%" + ("%02x" % c).upcase }).join
+        SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[sequence]
       end
       if upcase_encoded.length > 0
-        component = component.gsub(/%(#{upcase_encoded.chars.map do |char|
-          char.unpack('C*').map { |c| '%02x' % c }.join
-        end.join('|')})/i) { |s| s.upcase }
+        upcase_encoded_chars = upcase_encoded.chars.map do |char|
+          SEQUENCE_ENCODING_TABLE[char]
+        end
+        component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
+                                   &:upcase)
       end
       return component
     end
 
     class << self
-      alias_method :encode_component, :encode_component
+      alias_method :escape_component, :encode_component
     end
 
     ##
@@ -445,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")
@@ -531,12 +562,16 @@ module Addressable
           character_class = "#{character_class}%" unless character_class.include?('%')
 
           "|%(?!#{leave_encoded.chars.map do |char|
-            seq = char.unpack('C*').map { |c| '%02x' % c }.join
+            seq = SEQUENCE_ENCODING_TABLE[char]
             [seq.upcase, seq.downcase]
           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.
@@ -860,7 +895,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.scheme.strip.downcase,
-            Addressable::URI::CharacterClasses::SCHEME
+            Addressable::URI::NormalizeCharacterClasses::SCHEME
           )
         end
       end
@@ -880,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?
@@ -915,7 +950,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.user.strip,
-            Addressable::URI::CharacterClasses::UNRESERVED
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
           )
         end
       end
@@ -972,7 +1007,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.password.strip,
-            Addressable::URI::CharacterClasses::UNRESERVED
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
           )
         end
       end
@@ -1096,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(
@@ -1107,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
 
@@ -1172,7 +1211,7 @@ module Addressable
     # Returns the top-level domain for this host.
     #
     # @example
-    #   Addressable::URI.parse("www.example.co.uk").tld # => "co.uk"
+    #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
     def tld
       PublicSuffix.parse(self.host, ignore_private: true).tld
     end
@@ -1182,7 +1221,7 @@ module Addressable
     #
     # @param [String, #to_str] new_tld The new top-level domain.
     def tld=(new_tld)
-      replaced_tld = domain.sub(/#{tld}\z/, new_tld)
+      replaced_tld = host.sub(/#{tld}\z/, new_tld)
       self.host = PublicSuffix::Domain.new(replaced_tld).to_s
     end
 
@@ -1190,7 +1229,7 @@ module Addressable
     # Returns the public suffix domain for this host.
     #
     # @example
-    #   Addressable::URI.parse("www.example.co.uk").domain # => "example.co.uk"
+    #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
     def domain
       PublicSuffix.domain(self.host, ignore_private: true)
     end
@@ -1519,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)
 
@@ -1594,10 +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 = (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
@@ -1656,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.gsub(/\+/, " "))
+          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]
@@ -1791,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
@@ -1917,7 +1963,7 @@ module Addressable
               # Section 5.2.3 of RFC 3986
               #
               # Removes the right-most path segment from the base path.
-              if base_path =~ /\//
+              if base_path.include?(SLASH)
                 base_path.sub!(/\/[^\/]+$/, SLASH)
               else
                 base_path = EMPTY_STR
@@ -2367,10 +2413,10 @@ module Addressable
     #
     # @param [Proc] block
     #   A set of operations to perform on a given URI.
-    def defer_validation(&block)
-      raise LocalJumpError, "No block given." unless block
+    def defer_validation
+      raise LocalJumpError, "No block given." unless block_given?
       @validation_deferred = true
-      block.call()
+      yield
       @validation_deferred = false
       validate
       return nil

data/lib/addressable/version.rb

@@ -23,7 +23,7 @@ if !defined?(Addressable::VERSION)
   module Addressable
     module VERSION
       MAJOR = 2
-      MINOR = 6
+      MINOR = 8
       TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/addressable/idna_spec.rb

@@ -294,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/template_spec.rb

@@ -19,6 +19,7 @@
 require "spec_helper"
 
 require "bigdecimal"
+require "timeout"
 require "addressable/template"
 
 shared_examples_for 'expands' do |tests|
@@ -1340,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

@@ -65,116 +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.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
@@ -199,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
 
@@ -269,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
 
@@ -1015,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
 
@@ -1077,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
 
@@ -1195,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
 
@@ -1366,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
@@ -1390,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
@@ -1778,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
@@ -1810,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
@@ -1880,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
@@ -2015,15 +2015,15 @@ 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
@@ -2072,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
 
@@ -2100,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
 
@@ -2134,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
 
@@ -2480,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
@@ -2534,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
@@ -2559,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
@@ -2597,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
@@ -2615,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
@@ -2752,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
@@ -3100,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
@@ -3340,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 " +
@@ -3942,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
@@ -4023,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
@@ -4097,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
@@ -4262,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
@@ -4303,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
@@ -4414,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
 
@@ -4646,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
@@ -4745,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
 
@@ -4819,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
@@ -5422,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
 
@@ -5451,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
 
@@ -5515,18 +5585,18 @@ describe Addressable::URI, "when given the tld " do
   end
 
   context "which " do
-    let (:uri) { Addressable::URI.parse("http://comrade.net/path/to/source/") }
+    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://comrade.co.uk/path/to/source/")
+      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://comrade.com/path/to/source/")
+      expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
     end
   end
 end
@@ -5648,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
@@ -5658,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
 
@@ -5704,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
 
@@ -5772,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
 
@@ -5784,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
 
@@ -5864,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")
@@ -5936,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
 
@@ -5986,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
 
@@ -6352,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
@@ -6363,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
@@ -6421,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
@@ -6477,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
@@ -6495,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