addressable 2.3.5 → 2.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7469c2a80add393372ae8c44de978834410a65fc
-  data.tar.gz: ff31775eb9800b5aa84260a06c7fb6b6c93c855e
+  metadata.gz: c062f20a75939191f680842716b9ce79816e8952
+  data.tar.gz: 4ff3027264ee6f61fe887f1035c4fa7c472f7c90
 SHA512:
-  metadata.gz: d0542072bdbf9520eed193aa4b8fddb95bd8869662ec23566529bb6ecf9688ccaba3dd4b77bdcea889862d7947a71b9bf4770dbc6eb872cc84b976f781bfd5f2
-  data.tar.gz: 39ca65c92ecdc6d4891c794e56876e7a3923182c1de78691c9e0b794eea0d93ffe100766706825a5abefd911ac3f392687992eb04de9bbfd44d33b428fb2d6d4
+  metadata.gz: 26da95b6a6dd459054e700fa3ff906fbc5512dcc0ad2b3cb47e0b5a1a05d2722767605b8f62f044534425ffa4485a53e8132a816792136b37e80c3ff0c20bfbf
+  data.tar.gz: 9a0d4766e4faeb57353a6d14524e31610e77b84dd9dda33d51ba472db803197cc2989f3c6dc08623ebbc8e95850e331d8a065b9483483a8e78223c3887381283

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# Addressable 2.3.6
+- normalization drops empty query string
+- better handling in template extract for missing values
+- template modifier for `'?'` now treated as optional
+- fixed issue where character class parameters were modified
+- templates can now be tested for equality
+- added `:sorted` option to normalization of query strings
+- fixed issue with normalization of hosts given in `'example.com.'` form
+
 # Addressable 2.3.5
 - added Addressable::URI#empty? method
 - Addressable::URI#hostname methods now strip square brackets from IPv6 hosts
@@ -149,11 +158,11 @@
 - improved normalization
 - fixed bug in joining algorithm
 - updated specifications
-  
+
 # Addressable 0.1.1
 - updated documentation
 - added URI Template variable extraction
-  
+
 # Addressable 0.1.0
 - initial release
 - implementation based on RFC 3986, 3987

data/Gemfile

@@ -16,4 +16,13 @@ end
 gem 'idn', :platform => :mri_18
 gem 'idn-ruby', :platform => :mri_19
 
+platforms :mri_18 do
+  gem 'mime-types', '~> 1.25'
+end
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius-coverage'
+end
+
 gemspec

data/README.md

@@ -98,8 +98,5 @@ idn gem:
 ```console
 $ sudo apt-get install idn # Debian/Ubuntu
 $ sudo brew install libidn # OS X
-$ sudo gem install idn
+$ sudo gem install idn-ruby
 ```
-
-**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/template.rb

@@ -250,6 +250,26 @@ module Addressable
         self.class.to_s, self.object_id, self.pattern)
     end
 
+    ##
+    # Returns <code>true</code> if the Template objects are equal. This method
+    # does NOT normalize either Template before doing the comparison.
+    #
+    # @param [Object] template The Template to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the Templates are equivalent, <code>false</code>
+    #   otherwise.
+    def ==(template)
+      return false unless template.kind_of?(Template)
+      return self.pattern == template.pattern
+    end
+
+    ##
+    # Addressable::Template makes no distinction between `==` and `eql?`.
+    #
+    # @see #==
+    alias_method :eql?, :==
+
     ##
     # Extracts a mapping from the URI using a URI Template pattern.
     #
@@ -397,6 +417,7 @@ module Addressable
           _, operator, varlist = *expansion.match(EXPRESSION)
           varlist.split(',').each do |varspec|
             _, name, modifier = *varspec.match(VARSPEC)
+            mapping[name] ||= nil
             case operator
             when nil, '+', '#', '/', '.'
               unparsed_value = unparsed_values[index]
@@ -405,12 +426,14 @@ module Addressable
               value = value.split(JOINERS[operator]) if value && modifier == '*'
             when ';', '?', '&'
               if modifier == '*'
-                value = unparsed_values[index].split(JOINERS[operator])
-                value = value.inject({}) do |acc, v|
-                  key, val = v.split('=')
-                  val = "" if val.nil?
-                  acc[key] = val
-                  acc
+                if unparsed_values[index]
+                  value = unparsed_values[index].split(JOINERS[operator])
+                  value = value.inject({}) do |acc, v|
+                    key, val = v.split('=')
+                    val = "" if val.nil?
+                    acc[key] = val
+                    acc
+                  end
                 end
               else
                 if (unparsed_values[index])
@@ -435,10 +458,9 @@ module Addressable
                 value = Addressable::URI.unencode_component(value)
               end
             end
-            if mapping[name] == nil || mapping[name] == value
+            if !mapping.has_key?(name) || mapping[name].nil?
+              # Doesn't exist, set to value (even if value is nil)
               mapping[name] = value
-            else
-              return nil
             end
             index = index + 1
           end
@@ -872,10 +894,12 @@ module Addressable
         _, operator, varlist = *expansion.match(EXPRESSION)
         leader = Regexp.escape(LEADERS.fetch(operator, ''))
         joiner = Regexp.escape(JOINERS.fetch(operator, ','))
-        leader + varlist.split(',').map do |varspec|
+        combined = varlist.split(',').map do |varspec|
           _, name, modifier = *varspec.match(VARSPEC)
-          if processor != nil && processor.respond_to?(:match)
-            "(#{ processor.match(name) })"
+
+          result = processor && processor.respond_to?(:match) ? processor.match(name) : nil
+          if result
+            "(#{ result })"
           else
             group = case operator
             when '+'
@@ -902,6 +926,7 @@ module Addressable
             end
           end
         end.join("#{joiner}?")
+        "(?:|#{leader}#{combined})"
       end
 
       # Ensure that the regular expression matches the whole URI.

data/lib/addressable/uri.rb

@@ -162,6 +162,15 @@ module Addressable
       return nil unless uri
       # If a URI object is passed, just return itself.
       return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
       if !uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{uri.class} into String."
       end
@@ -415,8 +424,13 @@ module Addressable
           "Expected Class (String or Addressable::URI), " +
           "got #{return_type.inspect}"
       end
-      result = uri.gsub(/%[0-9a-f]{2}/i) do |sequence|
+      uri = uri.dup
+      # Seriously, only use UTF-8. I'm really not kidding!
+      uri.force_encoding("utf-8") if uri.respond_to?(:force_encoding)
+      leave_encoded.force_encoding("utf-8") if leave_encoded.respond_to?(:force_encoding)
+      result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
         c = sequence[1..3].to_i(16).chr
+        c.force_encoding("utf-8") if c.respond_to?(:force_encoding)
         leave_encoded.include?(c) ? sequence : c
       end
       result.force_encoding("utf-8") if result.respond_to?(:force_encoding)
@@ -496,7 +510,7 @@ module Addressable
       end
       if character_class.kind_of?(String)
         leave_re = if leave_encoded.length > 0
-          character_class << '%'
+          character_class = "#{character_class}%" unless character_class.include?('%')
 
           "|%(?!#{leave_encoded.chars.map do |char|
             seq = char.unpack('C*').map { |c| '%02x' % c }.join
@@ -522,6 +536,9 @@ module Addressable
       rescue ArgumentError
         encoded = self.encode_component(unencoded)
       end
+      if encoded.respond_to?(:force_encoding)
+        encoded.force_encoding(Encoding::UTF_8)
+      end
       return encoded
     end
 
@@ -1049,8 +1066,8 @@ module Addressable
           result = ::Addressable::IDNA.to_ascii(
             URI.unencode_component(self.host.strip.downcase)
           )
-          if result[-1..-1] == "."
-            # Trailing dots are unnecessary
+          if result =~ /[^\.]\.$/
+            # Single trailing dots are unnecessary.
             result = result[0...-1]
           end
           result
@@ -1449,20 +1466,16 @@ module Addressable
     # The query component for this URI, normalized.
     #
     # @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,
-            modified_query_class,
-            '+'
-          )
-        end).join("&")
-      end)
+    def normalized_query(*flags)
+      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.sort! if flags.include?(:sorted)
+      component = (pairs.map do |pair|
+        Addressable::URI.normalize_component(pair, modified_query_class, "+")
+      end).join("&")
+      component == "" ? nil : component
     end
 
     ##
@@ -1643,10 +1656,11 @@ module Addressable
     # @return [String] The fragment component, normalized.
     def normalized_fragment
       self.fragment && @normalized_fragment ||= (begin
-        Addressable::URI.normalize_component(
-          self.fragment.strip,
+        component = Addressable::URI.normalize_component(
+          self.fragment,
           Addressable::URI::CharacterClasses::FRAGMENT
         )
+        component == "" ? nil : component
       end)
     end
 

data/lib/addressable/version.rb

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

data/spec/addressable/template_spec.rb

@@ -32,20 +32,72 @@ shared_examples_for 'expands' do |tests|
   end
 end
 
+describe "eql?" do
+  let(:template) { Addressable::Template.new('https://www.example.com/{foo}') }
+  it 'is equal when the pattern matches' do
+    other_template = Addressable::Template.new('https://www.example.com/{foo}')
+    expect(template).to be_eql(other_template)
+    expect(other_template).to be_eql(template)
+  end
+  it 'is not equal when the pattern differs' do
+    other_template = Addressable::Template.new('https://www.example.com/{bar}')
+    expect(template).to_not be_eql(other_template)
+    expect(other_template).to_not be_eql(template)
+  end
+  it 'is not equal to non-templates' do
+    uri = 'https://www.example.com/foo/bar'
+    addressable_template = Addressable::Template.new uri
+    addressable_uri = Addressable::URI.parse uri
+    expect(addressable_template).to_not be_eql(addressable_uri)
+    expect(addressable_uri).to_not be_eql(addressable_template)
+  end
+end
+
+describe "==" do
+  let(:template) { Addressable::Template.new('https://www.example.com/{foo}') }
+  it 'is equal when the pattern matches' do
+    other_template = Addressable::Template.new('https://www.example.com/{foo}')
+    expect(template).should == other_template
+    expect(other_template).should == template
+  end
+  it 'is not equal when the pattern differs' do
+    other_template = Addressable::Template.new('https://www.example.com/{bar}')
+    expect(template).should_not == other_template
+    expect(other_template).should_not == template
+  end
+  it 'is not equal to non-templates' do
+    uri = 'https://www.example.com/foo/bar'
+    addressable_template = Addressable::Template.new uri
+    addressable_uri = Addressable::URI.parse uri
+    expect(addressable_template).should_not == addressable_uri
+    expect(addressable_uri).should_not == addressable_template
+  end
+end
+
 describe "Type conversion" do
-  subject{
-    {:var => true, :hello => 1234, :nothing => nil, :sym => :symbolic}
+  require "bigdecimal"
+
+  subject {
+    {
+      :var => true,
+      :hello => 1234,
+      :nothing => nil,
+      :sym => :symbolic,
+      :decimal => BigDecimal.new(1)
+    }
   }
+
   it_behaves_like 'expands', {
     '{var}' => 'true',
     '{hello}' => '1234',
     '{nothing}' => '',
-    '{sym}' => 'symbolic'
+    '{sym}' => 'symbolic',
+    '{decimal}' => '0.1E1'
   }
 end
 
 describe "Level 1:" do
-  subject{
+  subject {
     {:var => "value", :hello => "Hello World!"}
   }
   it_behaves_like 'expands', {
@@ -55,7 +107,7 @@ describe "Level 1:" do
 end
 
 describe "Level 2" do
-  subject{
+  subject {
     {
       :var => "value",
       :hello => "Hello World!",
@@ -79,7 +131,7 @@ describe "Level 2" do
 end
 
 describe "Level 3" do
-  subject{
+  subject {
     {
       :var => "value",
       :hello => "Hello World!",
@@ -140,7 +192,7 @@ describe "Level 3" do
 end
 
 describe "Level 4" do
-  subject{
+  subject {
     {
       :var => "value",
       :hello => "Hello World!",
@@ -338,7 +390,7 @@ describe "Level 4" do
   end
 end
 describe "Modifiers" do
-  subject{
+  subject {
     {
       :var => "value",
       :semi => ";",
@@ -363,7 +415,7 @@ describe "Modifiers" do
   end
 end
 describe "Expansion" do
-  subject{
+  subject {
     {
       :count => ["one", "two", "three"],
       :dom => ["example", "com"],
@@ -670,6 +722,11 @@ class ExampleTwoProcessor
   end
 end
 
+class DumbProcessor
+  def self.match(name)
+    return ".*?" if name == "first"
+  end
+end
 
 describe Addressable::Template do
   describe "Matching" do
@@ -687,54 +744,80 @@ describe Addressable::Template do
     let(:uri4){
       Addressable::URI.parse("http://example.com/?a=1&b=2&c=3&first=foo")
     }
+    let(:uri5){
+      "http://example.com/foo"
+    }
     context "first uri with ExampleTwoProcessor" do
-      subject{
+      subject {
         match = Addressable::Template.new(
           "http://example.com/search/{query}/"
         ).match(uri, ExampleTwoProcessor)
       }
-      its(:variables){ should == ["query"]}
-      its(:captures){ should == ["an example search query"]}
+      its(:variables){ should == ["query"] }
+      its(:captures){ should == ["an example search query"] }
     end
 
     context "second uri with ExampleTwoProcessor" do
-      subject{
+      subject {
         match = Addressable::Template.new(
           "http://example.com/{first}/{+second}/"
         ).match(uri2, ExampleTwoProcessor)
       }
-      its(:variables){ should == ["first", "second"]}
+      its(:variables){ should == ["first", "second"] }
+      its(:captures){ should == ["a", "b/c"] }
+    end
+
+    context "second uri with DumbProcessor" do
+      subject {
+        match = Addressable::Template.new(
+          "http://example.com/{first}/{+second}/"
+        ).match(uri2, DumbProcessor)
+      }
+      its(:variables){ should == ["first", "second"] }
       its(:captures){ should == ["a", "b/c"] }
     end
+
     context "second uri" do
-      subject{
+      subject {
         match = Addressable::Template.new(
           "http://example.com/{first}{/second*}/"
         ).match(uri2)
       }
-      its(:variables){ should == ["first", "second"]}
+      its(:variables){ should == ["first", "second"] }
       its(:captures){ should == ["a", ["b","c"]] }
     end
     context "third uri" do
-      subject{
+      subject {
         match = Addressable::Template.new(
           "http://example.com/{;hash*,first}"
         ).match(uri3)
       }
-      its(:variables){ should == ["hash", "first"]}
+      its(:variables){ should == ["hash", "first"] }
       its(:captures){ should == [
         {"a" => "1", "b" => "2", "c" => "3", "first" => "foo"}, nil] }
     end
+    # Note that this expansion is impossible to revert deterministically - the
+    # * operator means first could have been a key of hash or a separate key.
+    # Semantically, a separate key is more likely, but both are possible.
     context "fourth uri" do
-      subject{
+      subject {
         match = Addressable::Template.new(
           "http://example.com/{?hash*,first}"
         ).match(uri4)
       }
-      its(:variables){ should == ["hash", "first"]}
+      its(:variables){ should == ["hash", "first"] }
       its(:captures){ should == [
         {"a" => "1", "b" => "2", "c" => "3", "first"=> "foo"}, nil] }
     end
+    context "fifth uri" do
+      subject {
+        match = Addressable::Template.new(
+          "http://example.com/{path}{?hash*,first}"
+        ).match(uri5)
+      }
+      its(:variables){ should == ["path", "hash", "first"] }
+      its(:captures){ should == ["foo", nil, nil] }
+    end
   end
   describe "extract" do
     let(:template) {
@@ -743,7 +826,8 @@ describe Addressable::Template do
       )
     }
     let(:uri){ "http://example.com/a/b/c/?one=1&two=2#foo" }
-    it "should be able to extract" do
+    let(:uri2){ "http://example.com/a/b/c/#foo" }
+    it "should be able to extract with queries" do
       template.extract(uri).should == {
         "host" => "example.com",
         "segments" => %w(a b c),
@@ -753,10 +837,53 @@ describe Addressable::Template do
         "fragment" => "foo"
       }
     end
+    it "should be able to extract without queries" do
+      template.extract(uri2).should == {
+        "host" => "example.com",
+        "segments" => %w(a b c),
+        "one" => nil,
+        "bogus" => nil,
+        "two" => nil,
+        "fragment" => "foo"
+      }
+    end
+
+    context "issue #137" do
+      subject { Addressable::Template.new('/path{?page,per_page}') }
+
+      it "can match empty" do
+        data = subject.extract("/path")
+        data["page"].should == nil
+        data["per_page"].should == nil
+        data.keys.sort.should == ['page', 'per_page']
+      end
+
+      it "can match first var" do
+        data = subject.extract("/path?page=1")
+        data["page"].should == "1"
+        data["per_page"].should == nil
+        data.keys.sort.should == ['page', 'per_page']
+      end
+
+      it "can match second var" do
+        data = subject.extract("/path?per_page=1")
+        data["page"].should == nil
+        data["per_page"].should == "1"
+        data.keys.sort.should == ['page', 'per_page']
+      end
+
+      it "can match both vars" do
+        data = subject.extract("/path?page=2&per_page=1")
+        data["page"].should == "2"
+        data["per_page"].should == "1"
+        data.keys.sort.should == ['page', 'per_page']
+      end
+    end
   end
+
   describe "Partial expand with symbols" do
     context "partial_expand with two simple values" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{one}/{two}/")
       }
       it "builds a new pattern" do
@@ -765,7 +892,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand query with missing param in middle" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?one,two,three}/")
       }
       it "builds a new pattern" do
@@ -774,7 +901,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with query string" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
       }
       it "builds a new pattern" do
@@ -783,7 +910,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with path operator" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com{/one,two}/")
       }
       it "builds a new pattern" do
@@ -794,7 +921,7 @@ describe Addressable::Template do
   end
   describe "Partial expand with strings" do
     context "partial_expand with two simple values" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{one}/{two}/")
       }
       it "builds a new pattern" do
@@ -803,7 +930,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand query with missing param in middle" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?one,two,three}/")
       }
       it "builds a new pattern" do
@@ -812,7 +939,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with query string" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
       }
       it "builds a new pattern" do
@@ -821,7 +948,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with path operator" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com{/one,two}/")
       }
       it "builds a new pattern" do
@@ -832,7 +959,7 @@ describe Addressable::Template do
   end
   describe "Expand" do
     context "expand with a processor" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/search/{query}/")
       }
       it "processes spaces" do
@@ -848,7 +975,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand query with missing param in middle" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?one,two,three}/")
       }
       it "builds a new pattern" do
@@ -857,7 +984,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with query string" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
       }
       it "builds a new pattern" do
@@ -866,7 +993,7 @@ describe Addressable::Template do
       end
     end
     context "partial_expand with path operator" do
-      subject{
+      subject {
         Addressable::Template.new("http://example.com{/one,two}/")
       }
       it "builds a new pattern" do
@@ -889,8 +1016,8 @@ describe Addressable::Template do
       end
       it "can match empty" do
         data = subject.match("foo/baz")
-        data.mapping["foo"].should == ""
-        data.mapping["bar"].should == ""
+        data.mapping["foo"].should == nil
+        data.mapping["bar"].should == nil
       end
       it "lists vars" do
         subject.variables.should == ["foo", "bar"]
@@ -904,6 +1031,22 @@ describe Addressable::Template do
         data.mapping["foo"].should == "/test/banana"
         data.mapping["bar"].should == "baz"
       end
+      it "can match empty level 2 #" do
+        data = subject.match("foo/test/bananabaz")
+        data.mapping["foo"].should == "/test/banana"
+        data.mapping["bar"].should == nil
+        data = subject.match("foo/test/banana#baz")
+        data.mapping["foo"].should == "/test/banana"
+        data.mapping["bar"].should == ""
+      end
+      it "can match empty level 2 +" do
+        data = subject.match("foobaz")
+        data.mapping["foo"].should == nil
+        data.mapping["bar"].should == nil
+        data = subject.match("foo#barbaz")
+        data.mapping["foo"].should == nil
+        data.mapping["bar"].should == "bar"
+      end
       it "lists vars" do
         subject.variables.should == ["foo", "bar"]
       end
@@ -978,6 +1121,39 @@ describe Addressable::Template do
             subject.variables.should == %w(foo bar)
           end
         end
+
+        context "issue #137" do
+          subject { Addressable::Template.new('/path{?page,per_page}') }
+
+          it "can match empty" do
+            data = subject.match("/path")
+            data.mapping["page"].should == nil
+            data.mapping["per_page"].should == nil
+            data.mapping.keys.sort.should == ['page', 'per_page']
+          end
+
+          it "can match first var" do
+            data = subject.match("/path?page=1")
+            data.mapping["page"].should == "1"
+            data.mapping["per_page"].should == nil
+            data.mapping.keys.sort.should == ['page', 'per_page']
+          end
+
+          it "can match second var" do
+            data = subject.match("/path?per_page=1")
+            data.mapping["page"].should == nil
+            data.mapping["per_page"].should == "1"
+            data.mapping.keys.sort.should == ['page', 'per_page']
+          end
+
+          it "can match both vars" do
+            data = subject.match("/path?page=2&per_page=1")
+            data.mapping["page"].should == "2"
+            data.mapping["per_page"].should == "1"
+            data.mapping.keys.sort.should == ['page', 'per_page']
+          end
+        end
+
         context "issue #71" do
           subject { Addressable::Template.new("http://cyberscore.dev/api/users{?username}") }
           it "can match" do
@@ -1084,10 +1260,10 @@ describe Addressable::Template::MatchData do
   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(:keys) { should == ['foo', 'bar'] }
+  its(:names) { should == ['foo', 'bar'] }
   its(:values) { should == ['ab', 'cd'] }
-  its(:captures) { should == its.values }
+  its(:captures) { should == ['ab', 'cd'] }
   its(:to_a) { should == ['ab/cd', 'ab', 'cd'] }
   its(:to_s) { should == 'ab/cd' }
   its(:string) { should == its.to_s }

data/spec/addressable/uri_spec.rb

@@ -17,6 +17,7 @@
 require "spec_helper"
 
 require "addressable/uri"
+require "uri"
 
 if !"".respond_to?("force_encoding")
   class String
@@ -931,6 +932,17 @@ describe Addressable::URI, "when created with an authority and no port" do
   end
 end
 
+describe Addressable::URI, "when created with a host with trailing dots" do
+  before do
+    @uri = Addressable::URI.new(:authority => "example...")
+  end
+
+  it "should have a stable normalized form" do
+    @uri.normalize.normalize.normalize.host.should ==
+      @uri.normalize.host
+  end
+end
+
 describe Addressable::URI, "when created with both a userinfo and a user" do
   it "should raise an error" do
     (lambda do
@@ -2019,6 +2031,38 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com?#'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com?#")
+  end
+
+  it "should correctly convert to a hash" do
+    @uri.to_hash.should == {
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "",
+      :query => "",
+      :fragment => ""
+    }
+  end
+
+  it "should have a request URI of '/?'" do
+    @uri.request_uri.should == "/?"
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.to_s.should == "http://example.com/"
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == "http://example.com"
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://@example.com/'" do
   before do
@@ -2136,7 +2180,7 @@ describe Addressable::URI, "when parsed from " +
   it "should not raise an exception when normalized" do
     (lambda do
       @uri.normalize
-    end).should_not raise_error(ArgumentError)
+    end).should_not raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2188,7 +2232,7 @@ describe Addressable::URI, "when parsed from " +
   it "should not raise an exception when normalized" do
     (lambda do
       @uri.normalize
-    end).should_not raise_error(ArgumentError)
+    end).should_not raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2212,7 +2256,7 @@ describe Addressable::URI, "when parsed from " +
   it "should not raise an exception when normalized" do
     (lambda do
       @uri.normalize
-    end).should_not raise_error(ArgumentError)
+    end).should_not raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2589,7 +2633,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 
   it "should have an origin of 'http://example.com'" do
@@ -2597,6 +2641,31 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/%2E/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/%2E/")
+  end
+
+  it "should be considered to be in normal form" do
+    pending(
+      'path segment normalization should happen before ' +
+      'percent escaping normalization'
+    ) do
+      @uri.normalize.should be_eql(@uri)
+    end
+  end
+
+  it "should normalize to 'http://example.com/%2E/'" do
+    pending(
+      'path segment normalization should happen before ' +
+      'percent escaping normalization'
+    ) do
+      @uri.normalize.should == "http://example.com/%2E/"
+    end
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/..'" do
   before do
@@ -2612,7 +2681,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2631,7 +2700,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2650,7 +2719,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2669,7 +2738,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2688,7 +2757,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2707,7 +2776,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://example.com/'" do
-    @uri.normalize.should === "http://example.com/"
+    @uri.normalize.to_s.should == "http://example.com/"
   end
 end
 
@@ -2722,7 +2791,7 @@ describe Addressable::URI, "when parsed from '/a/b/c/./../../g'" do
 
   # Section 5.2.4 of RFC 3986
   it "should normalize to '/a/g'" do
-    @uri.normalize.should === "/a/g"
+    @uri.normalize.to_s.should == "/a/g"
   end
 end
 
@@ -2737,7 +2806,7 @@ describe Addressable::URI, "when parsed from 'mid/content=5/../6'" do
 
   # Section 5.2.4 of RFC 3986
   it "should normalize to 'mid/6'" do
-    @uri.normalize.should === "mid/6"
+    @uri.normalize.to_s.should == "mid/6"
   end
 end
 
@@ -2752,7 +2821,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should normalize to 'http://www.example.com//'" do
-    @uri.normalize.should === "http://www.example.com//"
+    @uri.normalize.to_s.should == "http://www.example.com//"
   end
 end
 
@@ -4346,6 +4415,10 @@ describe Addressable::URI, "when parsed from '?'" do
     @uri = Addressable::URI.parse("?")
   end
 
+  it "should normalize to ''" do
+    @uri.normalize.to_s.should == ""
+  end
+
   it "should have the correct return type" do
     @uri.query_values.should == {}
     @uri.query_values(Hash).should == {}
@@ -4490,6 +4563,11 @@ describe Addressable::URI, "when parsed from " +
         {'one' => ['two', 'three', 'four']}
     end
   end
+
+  it "should handle assignment with keys of mixed type" do
+    @uri.query_values = @uri.query_values(Hash).merge({:one => 'three'})
+    @uri.query_values(Hash).should == {'one' => 'three'}
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -5335,6 +5413,16 @@ describe Addressable::URI, "when normalizing a string but leaving some character
     Addressable::URI.normalize_component("%58X%59Y%5AZ", "0-9a-zXY", "Y").should ==
       "XX%59Y%5A%5A"
   end
+
+  it "should not modify the character class" do
+    character_class = "0-9a-zXY"
+
+    character_class_copy = character_class.dup
+
+    Addressable::URI.normalize_component("%58X%59Y%5AZ", character_class, "Y")
+
+    character_class.should == character_class_copy
+  end
 end
 
 describe Addressable::URI, "when encoding a string with existing encodings to upcase" do
@@ -5379,6 +5467,10 @@ describe Addressable::URI, "when unencoding a multibyte string" do
     Addressable::URI.unencode_component("g%C3%BCnther").should == "günther"
   end
 
+  it "should consistently use UTF-8 internally" do
+    Addressable::URI.unencode_component("ski=%BA%DAɫ").should == "ski=\xBA\xDAɫ"
+  end
+
   it "should result in correct percent encoded sequence as a URI" do
     Addressable::URI.unencode(
       "/path?g%C3%BCnther", ::Addressable::URI
@@ -5642,6 +5734,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "::URI.parse('http://example.com')" do
+  before do
+    @input = ::URI.parse('http://example.com')
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com"
+  end
+end
+
 describe Addressable::URI, "when assigning query values" do
   before do
     @uri = Addressable::URI.new
@@ -5753,7 +5857,7 @@ describe Addressable::URI, "when assigning query values" do
   describe 'when a hash with mixed types is assigned to query_values' do
     it 'should not raise an error' do
       pending 'Issue #94' do
-        expect { subject.query_values = { "page" => "1", :page => 2 } }.to_not raise_error ArgumentError
+        expect { subject.query_values = { "page" => "1", :page => 2 } }.to_not raise_error
       end
     end
   end
@@ -5805,7 +5909,7 @@ describe Addressable::URI, "when assigning path values" do
     (lambda do
       @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
       @uri.scheme = "urn"
-    end).should_not raise_error(Addressable::URI::InvalidURIError)
+    end).should_not raise_error
   end
 end
 

data/spec/spec_helper.rb

@@ -1,2 +1,6 @@
-require 'coveralls'
-Coveralls.wear!
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+  warn "warning: coveralls gem not found; skipping Coveralls"
+end

data/tasks/rubyforge.rake

@@ -24,22 +24,6 @@ namespace :gem do
   end
 end
 
-namespace :doc do
-  desc "Publish RDoc to RubyForge"
-  task :release => ["doc"] do
-    require "rake/contrib/sshpublisher"
-    require "yaml"
-
-    config = YAML.load(
-      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-    )
-    host = "#{config['username']}@rubyforge.org"
-    remote_dir = RUBY_FORGE_PATH + "/api"
-    local_dir = "doc"
-    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-  end
-end
-
 namespace :spec do
   desc "Publish specdoc to RubyForge"
   task :release => ["spec:specdoc"] do

data/website/index.html

@@ -78,11 +78,11 @@
           </a>
         </li>
         <li>
-          <a href="http://github.com/sporkmonger/addressable/tree/">
+          <a href="http://github.com/sporkmonger/addressable">
             GitHub Page
           </a>
         </li>
-        <li><a href="/api/">API</a></li>
+        <li><a href="http://rubydoc.info/gems/addressable">API</a></li>
         <li><a href="/specdoc/">Specifications</a></li>
         <li><a href="/coverage/">Code Coverage</a></li>
       </ul>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: addressable
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.3.6
 platform: ruby
 authors:
 - Bob Aman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-27 00:00:00.000000000 Z
+date: 2014-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake