addressable 2.3.3 → 2.3.4

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# Addressable 2.3.4
+- fixed issue with encoding altering its inputs
+- query string normalization now leaves ';' characters alone
+- FakeFS is detected before attempting to load unicode tables
+- additional testing to ensure frozen objects don't cause problems
+
 # Addressable 2.3.3
 - fixed issue with converting common primitives during template expansion
 - fixed port encoding issue

data/README.md

@@ -20,68 +20,79 @@ RFC 6570 (level 4), providing support for IRIs and URI templates.
 
 - {Addressable::URI}
 - {Addressable::Template}
-- {Addressable::UriTemplate}
 
 # Example usage
 
-    require "addressable/uri"
-
-    uri = Addressable::URI.parse("http://example.com/path/to/resource/")
-    uri.scheme
-    #=> "http"
-    uri.host
-    #=> "example.com"
-    uri.path
-    #=> "/path/to/resource/"
-
-    uri = Addressable::URI.parse("http://www.詹姆斯.com/")
-    uri.normalize
-    #=> #<Addressable::URI:0xc9a4c8 URI:http://www.xn--8ws00zhy3a.com/>
-
-    require "addressable/template"
-
-    template = Addressable::Template.new("http://example.com/{-list|+|query}/")
-    template.expand({
-      "query" => "an example query".split(" ")
-    })
-    #=> #<Addressable::URI:0xc9d95c URI:http://example.com/an+example+query/>
-
-    template = Addressable::Template.new(
-      "http://example.com/{-join|&|one,two,three}/"
-    )
-    template.partial_expand({"one" => "1", "three" => 3}).pattern
-    #=> "http://example.com/?one=1{-prefix|&two=|two}&three=3"
-
-    template = Addressable::Template.new(
-      "http://{host}/{-suffix|/|segments}?{-join|&|one,two,bogus}\#{fragment}"
-    )
-    template2 = Addressable::UriTemplate.new(
-      "http://{host}{/segments}/{?one,two,bogus}{#fragment}"
-    )
-    uri = Addressable::URI.parse(
-      "http://example.com/a/b/c/?one=1&two=2#foo"
-    )
-    template.extract(uri)
-    template2.extract(uri)
-    #=>
-    # {
-    #   "host" => "example.com",
-    #   "segments" => ["a", "b", "c"],
-    #   "one" => "1",
-    #   "two" => "2",
-    #   "fragment" => "foo"
-    # }
+```ruby
+require "addressable/uri"
+
+uri = Addressable::URI.parse("http://example.com/path/to/resource/")
+uri.scheme
+#=> "http"
+uri.host
+#=> "example.com"
+uri.path
+#=> "/path/to/resource/"
+
+uri = Addressable::URI.parse("http://www.詹姆斯.com/")
+uri.normalize
+#=> #<Addressable::URI:0xc9a4c8 URI:http://www.xn--8ws00zhy3a.com/>
+```
+
+
+# URI Templates
+
+For more details, see [RFC 6570](https://www.rfc-editor.org/rfc/rfc6570.txt).
+
+
+```ruby
+
+require "addressable/template"
+
+template = Addressable::Template.new("http://example.com/{?query*}/")
+template.expand({
+  "query" => {
+    'foo' => 'bar',
+    'color' => 'red'
+  }
+})
+#=> #<Addressable::URI:0xc9d95c URI:http://example.com/?foo=bar&color=red>
+
+template = Addressable::Template.new("http://example.com/{?one,two,three}/")
+template.partial_expand({"one" => "1", "three" => 3}).pattern
+#=> "http://example.com/?one=1{&two}&three=3"
+
+template = Addressable::Template.new(
+  "http://{host}{/segments}/{?one,two,bogus}{#fragment}"
+)
+uri = Addressable::URI.parse(
+  "http://example.com/a/b/c/?one=1&two=2#foo"
+)
+template.extract(uri)
+#=>
+# {
+#   "host" => "example.com",
+#   "segments" => ["a", "b", "c"],
+#   "one" => "1",
+#   "two" => "2",
+#   "fragment" => "foo"
+# }
+```
 
 # Install
 
-    $ sudo gem install addressable
+```console
+$ sudo gem install addressable
+```
 
 You may optionally turn on native IDN support by installing libidn and the
 idn gem:
 
-    $ sudo apt-get install idn # Debian/Ubuntu
-    $ sudo brew install libidn # OS X
-    $ sudo gem install idn
+```console
+$ sudo apt-get install idn # Debian/Ubuntu
+$ sudo brew install libidn # OS X
+$ sudo gem install idn
+```
 
 **NOTE:** Native IDN support appears to be broken in Ruby 1.9.x. The IDN gem
 hasn't been updated in years.

data/lib/addressable/idna/pure.rb

@@ -106,6 +106,7 @@ module Addressable
 
     # Unicode normalization form KC.
     def self.unicode_normalize_kc(input)
+      input = input.to_s unless input.is_a?(String)
       unpacked = input.unpack("U*")
       unpacked =
         unicode_compose(unicode_sort_canonical(unicode_decompose(unpacked)))
@@ -317,10 +318,20 @@ module Addressable
     UNICODE_DATA_LOWERCASE = 5
     UNICODE_DATA_TITLECASE = 6
 
-    # This is a sparse Unicode table.  Codepoints without entries are
-    # assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
-    UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
-      Marshal.load(file.read)
+    begin
+      if defined?(FakeFS)
+        fakefs_state = FakeFS.activated?
+        FakeFS.deactivate!
+      end
+      # This is a sparse Unicode table.  Codepoints without entries are
+      # assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
+      UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
+        Marshal.load(file.read)
+      end
+    ensure
+      if defined?(FakeFS)
+        FakeFS.activate! if fakefs_state
+      end
     end
 
     COMPOSITION_TABLE = {}

data/lib/addressable/template.rb

@@ -132,6 +132,7 @@ module Addressable
         self.template.variables
       end
       alias_method :keys, :variables
+      alias_method :names, :variables
 
       ##
       # @return [Array]
@@ -146,6 +147,64 @@ module Addressable
       end
       alias_method :captures, :values
 
+      ##
+      # Accesses captured values by name or by index.
+      #
+      # @param [String, Symbol, Fixnum] key
+      #   Capture index or name. Note that when accessing by with index
+      #   of 0, the full URI will be returned. The intention is to mimic
+      #   the ::MatchData#[] behavior.
+      #
+      # @param [#to_int, nil] len
+      #   If provided, an array of values will be returend with the given
+      #   parameter used as length.
+      #
+      # @return [Array, String, nil]
+      #   The captured value corresponding to the index or name. If the
+      #   value was not provided or the key is unknown, nil will be
+      #   returned.
+      #
+      #   If the second parameter is provided, an array of that length will
+      #   be returned instead.
+      def [](key, len = nil)
+        if len
+          to_a[key, len]
+        elsif String === key or Symbol === key
+          mapping[key.to_s]
+        else
+          to_a[key]
+        end
+      end
+
+      ##
+      # @return [Array]
+      #   Array with the matched URI as first element followed by the captured
+      #   values.
+      def to_a
+        [to_s, *values]
+      end
+
+      ##
+      # @return [String]
+      #   The matched URI as String.
+      def to_s
+        uri.to_s
+      end
+      alias_method :string, :to_s
+
+      # Returns multiple captured values at once.
+      #
+      # @param [String, Symbol, Fixnum] *indexes
+      #   Indices of the captures to be returned
+      #
+      # @return [Array]
+      #   Values corresponding to given indices.
+      #
+      # @see Addressable::Template::MatchData#[]
+      def values_at(*indexes)
+        indexes.map { |i| self[i] }
+      end
+
       ##
       # Returns a <tt>String</tt> representation of the MatchData's state.
       #
@@ -154,6 +213,15 @@ module Addressable
         sprintf("#<%s:%#0x RESULT:%s>",
           self.class.to_s, self.object_id, self.mapping.inspect)
       end
+
+      ##
+      # Dummy method for code expecting a ::MatchData instance
+      #
+      # @return [String] An empty string.
+      def pre_match
+        ""
+      end
+      alias_method :post_match, :pre_match
     end
 
     ##

data/lib/addressable/uri.rb

@@ -363,11 +363,12 @@ module Addressable
         component = component.dup
         component.force_encoding(Encoding::ASCII_8BIT)
       end
-      component.gsub!(character_class) do |sequence|
+      # 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
       end
       if upcase_encoded.length > 0
-        component.gsub!(/%(#{upcase_encoded.chars.map do |char|
+        component = component.gsub(/%(#{upcase_encoded.chars.map do |char|
           char.unpack('C*').map { |c| '%02x' % c }.join
         end.join('|')})/i) { |s| s.upcase }
       end
@@ -1430,10 +1431,14 @@ module Addressable
     # @return [String] The query component, normalized.
     def normalized_query
       self.query && @normalized_query ||= (begin
+        modified_query_class = Addressable::URI::CharacterClasses::QUERY
+        # Make sure possible key-value pair delimiters are escaped.
+        modified_query_class = modified_query_class.sub("\\&", "")
+        modified_query_class = modified_query_class.sub("\\;", "")
         (self.query.split("&", -1).map do |pair|
           Addressable::URI.normalize_component(
             pair,
-            Addressable::URI::CharacterClasses::QUERY.sub("\\&", ""),
+            modified_query_class,
             '+'
           )
         end).join("&")
@@ -1907,7 +1912,7 @@ module Addressable
             end
           else
             if uri.path != SLASH
-              components[:path].gsub!(
+              components[:path] = components[:path].gsub(
                 Regexp.new("^" + Regexp.escape(uri.path)), EMPTY_STR)
             end
           end

data/lib/addressable/version.rb

@@ -22,7 +22,7 @@ if !defined?(Addressable::VERSION)
     module VERSION
       MAJOR = 2
       MINOR = 3
-      TINY  = 3
+      TINY  = 4
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/spec/addressable/idna_spec.rb

@@ -186,6 +186,11 @@ shared_examples_for "converting from ASCII to unicode" do
       "xn--4ud"
     ).should == "\341\206\265"
   end
+
+  it "should normalize 'string' correctly" do
+    Addressable::IDNA.unicode_normalize_kc(:'string').should == "string"
+    Addressable::IDNA.unicode_normalize_kc("string").should == "string"
+  end
 end
 
 describe Addressable::IDNA, "when using the pure-Ruby implementation" do

data/spec/addressable/template_spec.rb

@@ -1020,3 +1020,77 @@ describe Addressable::Template do
     end
   end
 end
+
+describe Addressable::Template::MatchData do
+  let(:template) { Addressable::Template.new('{foo}/{bar}') }
+  subject(:its) { template.match('ab/cd') }
+  its(:uri) { should == Addressable::URI.parse('ab/cd') }
+  its(:template) { should == template }
+  its(:mapping) { should == { 'foo' => 'ab', 'bar' => 'cd' } }
+  its(:variables) { should == ['foo', 'bar'] }
+  its(:keys) { should == its.variables }
+  its(:names) { should == its.variables }
+  its(:values) { should == ['ab', 'cd'] }
+  its(:captures) { should == its.values }
+  its(:to_a) { should == ['ab/cd', 'ab', 'cd'] }
+  its(:to_s) { should == 'ab/cd' }
+  its(:string) { should == its.to_s }
+  its(:pre_match) { should == "" }
+  its(:post_match) { should == "" }
+
+  describe 'values_at' do
+    it 'returns an array with the values' do
+      its.values_at(0, 2).should == ['ab/cd', 'cd']
+    end
+    it 'allows mixing integer an string keys' do
+      its.values_at('foo', 1).should == ['ab', 'ab']
+    end
+    it 'accepts unknown keys' do
+      its.values_at('baz', 'foo').should == [nil, 'ab']
+    end
+  end
+
+  describe '[]' do
+    context 'string key' do
+      it 'returns the corresponding capture' do
+        its['foo'].should == 'ab'
+        its['bar'].should == 'cd'
+      end
+      it 'returns nil for unknown keys' do
+        its['baz'].should be_nil
+      end
+    end
+    context 'symbol key' do
+      it 'returns the corresponding capture' do
+        its[:foo].should == 'ab'
+        its[:bar].should == 'cd'
+      end
+      it 'returns nil for unknown keys' do
+        its[:baz].should be_nil
+      end
+    end
+    context 'integer key' do
+      it 'returns the full URI for index 0' do
+        its[0].should == 'ab/cd'
+      end
+      it 'returns the corresponding capture' do
+        its[1].should == 'ab'
+        its[2].should == 'cd'
+      end
+      it 'returns nil for unknown keys' do
+        its[3].should be_nil
+      end
+    end
+    context 'other key' do
+      it 'raises an exception' do
+        expect { its[Object.new] }.to raise_error(TypeError)
+      end
+    end
+    context 'with length' do
+      it 'returns an array starting at index with given length' do
+        its[0, 2].should == ['ab/cd', 'ab']
+        its[2, 1].should == ['cd']
+      end
+    end
+  end
+end

data/spec/addressable/uri_spec.rb

@@ -218,6 +218,373 @@ describe Addressable::URI, "when created from nil components" do
   end
 end
 
+describe Addressable::URI, "when initialized from individual components" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http",
+      :user => "user",
+      :password => "password",
+      :host => "example.com",
+      :port => 8080,
+      :path => "/path",
+      :query => "query=value",
+      :fragment => "fragment"
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    @uri.normalized_scheme.should == "http"
+  end
+
+  it "returns 'user' for #user" do
+    @uri.user.should == "user"
+  end
+
+  it "returns 'user' for #normalized_user" do
+    @uri.normalized_user.should == "user"
+  end
+
+  it "returns 'password' for #password" do
+    @uri.password.should == "password"
+  end
+
+  it "returns 'password' for #normalized_password" do
+    @uri.normalized_password.should == "password"
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    @uri.userinfo.should == "user:password"
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    @uri.normalized_userinfo.should == "user:password"
+  end
+
+  it "returns 'example.com' for #host" do
+    @uri.host.should == "example.com"
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    @uri.normalized_host.should == "example.com"
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    @uri.authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    @uri.normalized_authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 8080 for #port" do
+    @uri.port.should == 8080
+  end
+
+  it "returns 8080 for #normalized_port" do
+    @uri.normalized_port.should == 8080
+  end
+
+  it "returns 80 for #default_port" do
+    @uri.default_port.should == 80
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    @uri.site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    @uri.normalized_site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns '/path' for #path" do
+    @uri.path.should == "/path"
+  end
+
+  it "returns '/path' for #normalized_path" do
+    @uri.normalized_path.should == "/path"
+  end
+
+  it "returns 'query=value' for #query" do
+    @uri.query.should == "query=value"
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    @uri.normalized_query.should == "query=value"
+  end
+
+  it "returns 'fragment' for #fragment" do
+    @uri.fragment.should == "fragment"
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    @uri.normalized_fragment.should == "fragment"
+  end
+
+  it "returns #hash" do
+    @uri.hash.should_not be nil
+  end
+
+  it "returns #to_s" do
+    @uri.to_s.should ==
+      "http://user:password@example.com:8080/path?query=value#fragment"
+  end
+
+  it "should not be frozen" do
+    @uri.should_not be_frozen
+  end
+
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when initialized from " +
+    "frozen individual components" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http".freeze,
+      :user => "user".freeze,
+      :password => "password".freeze,
+      :host => "example.com".freeze,
+      :port => "8080".freeze,
+      :path => "/path".freeze,
+      :query => "query=value".freeze,
+      :fragment => "fragment".freeze
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    @uri.normalized_scheme.should == "http"
+  end
+
+  it "returns 'user' for #user" do
+    @uri.user.should == "user"
+  end
+
+  it "returns 'user' for #normalized_user" do
+    @uri.normalized_user.should == "user"
+  end
+
+  it "returns 'password' for #password" do
+    @uri.password.should == "password"
+  end
+
+  it "returns 'password' for #normalized_password" do
+    @uri.normalized_password.should == "password"
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    @uri.userinfo.should == "user:password"
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    @uri.normalized_userinfo.should == "user:password"
+  end
+
+  it "returns 'example.com' for #host" do
+    @uri.host.should == "example.com"
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    @uri.normalized_host.should == "example.com"
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    @uri.authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    @uri.normalized_authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 8080 for #port" do
+    @uri.port.should == 8080
+  end
+
+  it "returns 8080 for #normalized_port" do
+    @uri.normalized_port.should == 8080
+  end
+
+  it "returns 80 for #default_port" do
+    @uri.default_port.should == 80
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    @uri.site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    @uri.normalized_site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns '/path' for #path" do
+    @uri.path.should == "/path"
+  end
+
+  it "returns '/path' for #normalized_path" do
+    @uri.normalized_path.should == "/path"
+  end
+
+  it "returns 'query=value' for #query" do
+    @uri.query.should == "query=value"
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    @uri.normalized_query.should == "query=value"
+  end
+
+  it "returns 'fragment' for #fragment" do
+    @uri.fragment.should == "fragment"
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    @uri.normalized_fragment.should == "fragment"
+  end
+
+  it "returns #hash" do
+    @uri.hash.should_not be nil
+  end
+
+  it "returns #to_s" do
+    @uri.to_s.should ==
+      "http://user:password@example.com:8080/path?query=value#fragment"
+  end
+
+  it "should not be frozen" do
+    @uri.should_not be_frozen
+  end
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from a frozen string" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://user:password@example.com:8080/path?query=value#fragment".freeze
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    @uri.normalized_scheme.should == "http"
+  end
+
+  it "returns 'user' for #user" do
+    @uri.user.should == "user"
+  end
+
+  it "returns 'user' for #normalized_user" do
+    @uri.normalized_user.should == "user"
+  end
+
+  it "returns 'password' for #password" do
+    @uri.password.should == "password"
+  end
+
+  it "returns 'password' for #normalized_password" do
+    @uri.normalized_password.should == "password"
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    @uri.userinfo.should == "user:password"
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    @uri.normalized_userinfo.should == "user:password"
+  end
+
+  it "returns 'example.com' for #host" do
+    @uri.host.should == "example.com"
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    @uri.normalized_host.should == "example.com"
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    @uri.authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    @uri.normalized_authority.should == "user:password@example.com:8080"
+  end
+
+  it "returns 8080 for #port" do
+    @uri.port.should == 8080
+  end
+
+  it "returns 8080 for #normalized_port" do
+    @uri.normalized_port.should == 8080
+  end
+
+  it "returns 80 for #default_port" do
+    @uri.default_port.should == 80
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    @uri.site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    @uri.normalized_site.should == "http://user:password@example.com:8080"
+  end
+
+  it "returns '/path' for #path" do
+    @uri.path.should == "/path"
+  end
+
+  it "returns '/path' for #normalized_path" do
+    @uri.normalized_path.should == "/path"
+  end
+
+  it "returns 'query=value' for #query" do
+    @uri.query.should == "query=value"
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    @uri.normalized_query.should == "query=value"
+  end
+
+  it "returns 'fragment' for #fragment" do
+    @uri.fragment.should == "fragment"
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    @uri.normalized_fragment.should == "fragment"
+  end
+
+  it "returns #hash" do
+    @uri.hash.should_not be nil
+  end
+
+  it "returns #to_s" do
+    @uri.to_s.should ==
+      "http://user:password@example.com:8080/path?query=value#fragment"
+  end
+
+  it "should not be frozen" do
+    @uri.should_not be_frozen
+  end
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
 describe Addressable::URI, "when frozen" do
   before do
     @uri = Addressable::URI.new.freeze
@@ -232,7 +599,7 @@ describe Addressable::URI, "when frozen" do
   end
 
   it "returns nil for #user" do
-    @uri.user .should == nil
+    @uri.user.should == nil
   end
 
   it "returns nil for #normalized_user" do
@@ -322,6 +689,153 @@ describe Addressable::URI, "when frozen" do
   it "returns #to_s" do
     @uri.to_s.should == ''
   end
+
+  it "should be frozen" do
+    @uri.should be_frozen
+  end
+
+  it "should not be frozen after duping" do
+    @uri.dup.should_not be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error { |error|
+      error.message.should match(/can't modify frozen/)
+      error.should satisfy { |e| RuntimeError === e || TypeError === e }
+    }
+  end
+end
+
+describe Addressable::URI, "when frozen" do
+  before do
+    @uri = Addressable::URI.parse(
+      "HTTP://example.com.:%38%30/%70a%74%68?a=%31#1%323"
+    ).freeze
+  end
+
+  it "returns 'HTTP' for #scheme" do
+    @uri.scheme.should == "HTTP"
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    @uri.normalized_scheme.should == "http"
+    @uri.normalize.scheme.should == "http"
+  end
+
+  it "returns nil for #user" do
+    @uri.user.should == nil
+  end
+
+  it "returns nil for #normalized_user" do
+    @uri.normalized_user.should == nil
+  end
+
+  it "returns nil for #password" do
+    @uri.password.should == nil
+  end
+
+  it "returns nil for #normalized_password" do
+    @uri.normalized_password.should == nil
+  end
+
+  it "returns nil for #userinfo" do
+    @uri.userinfo.should == nil
+  end
+
+  it "returns nil for #normalized_userinfo" do
+    @uri.normalized_userinfo.should == nil
+  end
+
+  it "returns 'example.com.' for #host" do
+    @uri.host.should == "example.com."
+  end
+
+  it "returns nil for #normalized_host" do
+    @uri.normalized_host.should == "example.com"
+    @uri.normalize.host.should == "example.com"
+  end
+
+  it "returns 'example.com.:80' for #authority" do
+    @uri.authority.should == "example.com.:80"
+  end
+
+  it "returns 'example.com:80' for #normalized_authority" do
+    @uri.normalized_authority.should == "example.com"
+    @uri.normalize.authority.should == "example.com"
+  end
+
+  it "returns 80 for #port" do
+    @uri.port.should == 80
+  end
+
+  it "returns nil for #normalized_port" do
+    @uri.normalized_port.should == nil
+    @uri.normalize.port.should == nil
+  end
+
+  it "returns 80 for #default_port" do
+    @uri.default_port.should == 80
+  end
+
+  it "returns 'HTTP://example.com.:80' for #site" do
+    @uri.site.should == "HTTP://example.com.:80"
+  end
+
+  it "returns 'http://example.com' for #normalized_site" do
+    @uri.normalized_site.should == "http://example.com"
+    @uri.normalize.site.should == "http://example.com"
+  end
+
+  it "returns '/%70a%74%68' for #path" do
+    @uri.path.should == "/%70a%74%68"
+  end
+
+  it "returns '/path' for #normalized_path" do
+    @uri.normalized_path.should == "/path"
+    @uri.normalize.path.should == "/path"
+  end
+
+  it "returns 'a=%31' for #query" do
+    @uri.query.should == "a=%31"
+  end
+
+  it "returns 'a=1' for #normalized_query" do
+    @uri.normalized_query.should == "a=1"
+    @uri.normalize.query.should == "a=1"
+  end
+
+  it "returns '1%323' for #fragment" do
+    @uri.fragment.should == "1%323"
+  end
+
+  it "returns '123' for #normalized_fragment" do
+    @uri.normalized_fragment.should == "123"
+    @uri.normalize.fragment.should == "123"
+  end
+
+  it "returns #hash" do
+    @uri.hash.should_not be nil
+  end
+
+  it "returns #to_s" do
+    @uri.to_s.should == 'HTTP://example.com.:80/%70a%74%68?a=%31#1%323'
+    @uri.normalize.to_s.should == 'http://example.com/path?a=1#123'
+  end
+
+  it "should be frozen" do
+    @uri.should be_frozen
+  end
+
+  it "should not be frozen after duping" do
+    @uri.dup.should_not be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error { |error|
+      error.message.should match(/can't modify frozen/)
+      error.should satisfy { |e| RuntimeError === e || TypeError === e }
+    }
+  end
 end
 
 describe Addressable::URI, "when created from string components" do
@@ -3102,6 +3616,27 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q='one;two'&x=1'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q='one;two'&x=1")
+  end
+
+  it "should have a query of 'q='one;two'&x=1'" do
+    @uri.query.should == "q='one;two'&x=1"
+  end
+
+  it "should have query_values of {\"q\" => \"'one;two'\", \"x\" => \"1\"}" do
+    @uri.query_values.should == {"q" => "'one;two'", "x" => "1"}
+  end
+
+  it "should escape the ';' character when normalizing to avoid ambiguity " +
+      "with the W3C HTML 4.01 specification" do
+    # HTML 4.01 Section B.2.2
+    @uri.normalize.query.should == "q='one%3Btwo'&x=1"
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/?&&x=b'" do
   before do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: addressable
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-19 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake