addressable 2.3.8 → 2.4.0

data/lib/addressable/version.rb

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

data/spec/addressable/idna_spec.rb

@@ -137,6 +137,10 @@ shared_examples_for "converting from unicode to ASCII" do
 end
 
 shared_examples_for "converting from ASCII to unicode" do
+  it "should return the identity conversion when the ACE prefix has no suffix" do
+    expect(Addressable::IDNA.to_unicode("xn--...-")).to eq("xn--...-")
+  end
+
   it "should convert 'www.google.com' correctly" do
     expect(Addressable::IDNA.to_unicode("www.google.com")).to eq("www.google.com")
   end
@@ -147,12 +151,24 @@ shared_examples_for "converting from ASCII to unicode" do
     )).to eq("www.詹姆斯.com")
   end
 
+  it "should convert '詹姆斯.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--8ws00zhy3a.com"
+    )).to eq("詹姆斯.com")
+  end
+
   it "should convert 'www.iñtërnâtiônàlizætiøn.com' correctly" do
     expect(Addressable::IDNA.to_unicode(
       "www.xn--itrntinliztin-vdb0a5exd8ewcye.com"
     )).to eq("www.iñtërnâtiônàlizætiøn.com")
   end
 
+  it "should convert 'iñtërnâtiônàlizætiøn.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--itrntinliztin-vdb0a5exd8ewcye.com"
+    )).to eq("iñtërnâtiônàlizætiøn.com")
+  end
+
   it "should convert " +
       "'www.ほんとうにながいわけのわからないどめいんめいのらべるまだながくしないとたりない.w3.mag.keio.ac.jp' " +
       "correctly" do

data/spec/addressable/rack_mount_compat_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+# Copyright (C) 2006-2015 Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+require "spec_helper"
+
+require "addressable/uri"
+require "addressable/template"
+require "rack/mount"
+
+describe Rack::Mount do
+  let(:app_one) do
+    proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 1'] }
+  end
+  let(:app_two) do
+    proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 2'] }
+  end
+  let(:app_three) do
+    proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 3'] }
+  end
+  let(:routes) do
+    s = Rack::Mount::RouteSet.new do |set|
+      set.add_route(app_one, {
+        :request_method => 'GET',
+        :path_info => Addressable::Template.new('/one/{id}/')
+      }, {:id => 'unidentified'}, :one)
+      set.add_route(app_two, {
+        :request_method => 'GET',
+        :path_info => Addressable::Template.new('/two/')
+      }, {:id => 'unidentified'}, :two)
+      set.add_route(app_three, {
+        :request_method => 'GET',
+        :path_info => Addressable::Template.new('/three/{id}/').to_regexp
+      }, {:id => 'unidentified'}, :three)
+    end
+    s.rehash
+    s
+  end
+
+  it "should generate from routes with Addressable::Template" do
+    path, _ = routes.generate(:path_info, :one, {:id => '123'})
+    expect(path).to eq '/one/123/'
+  end
+
+  it "should generate from routes with Addressable::Template using defaults" do
+    path, _ = routes.generate(:path_info, :one, {})
+    expect(path).to eq '/one/unidentified/'
+  end
+
+  it "should recognize routes with Addressable::Template" do
+    request = Rack::Request.new(
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/one/123/'
+    )
+    route, _, params = routes.recognize(request)
+    expect(route).not_to be_nil
+    expect(route.app).to eq app_one
+    expect(params).to eq({id: '123'})
+  end
+
+  it "should generate from routes with Addressable::Template" do
+    path, _ = routes.generate(:path_info, :two, {:id => '654'})
+    expect(path).to eq '/two/'
+  end
+
+  it "should generate from routes with Addressable::Template using defaults" do
+    path, _ = routes.generate(:path_info, :two, {})
+    expect(path).to eq '/two/'
+  end
+
+  it "should recognize routes with Addressable::Template" do
+    request = Rack::Request.new(
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/two/'
+    )
+    route, _, params = routes.recognize(request)
+    expect(route).not_to be_nil
+    expect(route.app).to eq app_two
+    expect(params).to eq({id: 'unidentified'})
+  end
+
+  it "should recognize routes with derived Regexp" do
+    request = Rack::Request.new(
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/three/789/'
+    )
+    route, _, params = routes.recognize(request)
+    expect(route).not_to be_nil
+    expect(route.app).to eq app_three
+    expect(params).to eq({id: '789'})
+  end
+end

data/spec/addressable/security_spec.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+# Copyright (C) 2006-2015 Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+require "spec_helper"
+
+require "addressable/uri"
+
+describe Addressable::URI, "when created with a URI known to cause crashes " +
+    "in certain browsers" do
+  it "should parse correctly" do
+    uri = Addressable::URI.parse('%%30%30')
+    expect(uri.path).to eq('%%30%30')
+    expect(uri.normalize.path).to eq('%2500')
+  end
+
+  it "should parse correctly as a full URI" do
+    uri = Addressable::URI.parse('http://www.example.com/%%30%30')
+    expect(uri.path).to eq('/%%30%30')
+    expect(uri.normalize.path).to eq('/%2500')
+  end
+end
+
+describe Addressable::URI, "when created with a URI known to cause crashes " +
+    "in certain browsers" do
+  it "should parse correctly" do
+    uri = Addressable::URI.parse('لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.path).to eq('لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.normalize.path).to eq(
+      '%D9%84%D9%8F%D8%B5%D9%91%D8%A8%D9%8F%D9%84%D9%8F%D9%84%D8%B5%D9%91' +
+      '%D8%A8%D9%8F%D8%B1%D8%B1%D9%8B%20%E0%A5%A3%20%E0%A5%A3h%20%E0%A5' +
+      '%A3%20%E0%A5%A3%20%E5%86%97'
+    )
+  end
+
+  it "should parse correctly as a full URI" do
+    uri = Addressable::URI.parse('http://www.example.com/لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.path).to eq('/لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.normalize.path).to eq(
+      '/%D9%84%D9%8F%D8%B5%D9%91%D8%A8%D9%8F%D9%84%D9%8F%D9%84%D8%B5%D9%91' +
+      '%D8%A8%D9%8F%D8%B1%D8%B1%D9%8B%20%E0%A5%A3%20%E0%A5%A3h%20%E0%A5' +
+      '%A3%20%E0%A5%A3%20%E5%86%97'
+    )
+  end
+end

data/spec/addressable/template_spec.rb

@@ -698,6 +698,13 @@ describe "Expansion" do
       ]
     }
   end
+  context "non-string key in match data" do
+    subject {Addressable::Template.new("http://example.com/{one}")}
+
+    it "raises TypeError" do
+      expect { subject.expand(Object.new => "1") }.to raise_error TypeError
+    end
+  end
 end
 
 class ExampleTwoProcessor
@@ -728,6 +735,21 @@ class DumbProcessor
 end
 
 describe Addressable::Template do
+  describe 'initialize' do
+    context 'with a non-string' do
+      it 'raises a TypeError' do
+        expect { Addressable::Template.new(nil) }.to raise_error(TypeError)
+      end
+    end
+  end
+
+  describe 'freeze' do
+    subject { Addressable::Template.new("http://example.com/{first}/{+second}/") }
+    it 'freezes the template' do
+      expect(subject.freeze).to be_frozen
+    end
+  end
+
   describe "Matching" do
     let(:uri){
       Addressable::URI.parse(
@@ -818,6 +840,21 @@ describe Addressable::Template do
       its(:captures){ should == ["foo", nil, nil] }
     end
   end
+
+  describe 'match' do
+    subject { Addressable::Template.new('http://example.com/first/second/') }
+    context 'when the URI is the same as the template' do
+      it 'returns the match data itself with an empty mapping' do
+        uri = Addressable::URI.parse('http://example.com/first/second/')
+        match_data = subject.match(uri)
+        expect(match_data).to be_an Addressable::Template::MatchData
+        expect(match_data.uri).to eq(uri)
+        expect(match_data.template).to eq(subject)
+        expect(match_data.mapping).to be_empty
+      end
+    end
+  end
+
   describe "extract" do
     let(:template) {
       Addressable::Template.new(
@@ -901,13 +938,23 @@ describe Addressable::Template do
         )
       end
     end
+    context "partial_expand form style query with missing param at beginning" do
+      subject {
+        Addressable::Template.new("http://example.com/{?one,two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:two => "2").pattern).to eq(
+          "http://example.com/?two=2{&one}/"
+        )
+      end
+    end
     context "partial_expand with query string" do
       subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
       }
       it "builds a new pattern" do
         expect(subject.partial_expand(:one => "1").pattern).to eq(
-          "http://example.com/{?two}&one=1/"
+          "http://example.com/?one=1{&two}/"
         )
       end
     end
@@ -949,7 +996,7 @@ describe Addressable::Template do
       }
       it "builds a new pattern" do
         expect(subject.partial_expand("one" => "1").pattern).to eq(
-          "http://example.com/{?two}&one=1/"
+          "http://example.com/?one=1{&two}/"
         )
       end
     end
@@ -998,7 +1045,7 @@ describe Addressable::Template do
       }
       it "builds a new pattern" do
         expect(subject.partial_expand("one" => "1").pattern).to eq(
-          "http://example.com/{?two}&one=1/"
+          "http://example.com/?one=1{&two}/"
         )
       end
     end

data/spec/addressable/uri_spec.rb

@@ -18,6 +18,7 @@ require "spec_helper"
 
 require "addressable/uri"
 require "uri"
+require "ipaddr"
 
 if !"".respond_to?("force_encoding")
   class String
@@ -68,6 +69,14 @@ describe Addressable::URI, "when created with a non-numeric port number" do
   end
 end
 
+describe Addressable::URI, "when created with a invalid encoded port number" do
+  it "should raise an error" do
+    expect(lambda do
+      Addressable::URI.new(:port => "%eb")
+    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
@@ -157,6 +166,51 @@ describe Addressable::URI, "when created with a scheme but no hierarchical " +
   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
+        Addressable::URI.parse("http://local\"host/")
+      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
+      Addressable::URI.parse("ht%0atp://localhost/")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not unescape newline in path" do
+    uri = Addressable::URI.parse("http://localhost/%0a").normalize
+    expect(uri.to_s).to eq("http://localhost/%0A")
+  end
+
+  it "should not unescape newline in hostname" do
+    uri = Addressable::URI.parse("http://local%0ahost/").normalize
+    expect(uri.to_s).to eq("http://local%0Ahost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://foo%0abar@localhost/").normalize
+    expect(uri.to_s).to eq("http://foo%0Abar@localhost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://example:foo%0abar@example/").normalize
+    expect(uri.to_s).to eq("http://example:foo%0Abar@example/")
+  end
+
+  it "should not accept newline in hostname" do
+    uri = Addressable::URI.parse("http://localhost/")
+    expect(lambda do
+      uri.host = "local\nhost"
+    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
@@ -232,6 +286,48 @@ describe Addressable::URI, "when created from nil components" do
     end).to raise_error(Addressable::URI::InvalidURIError)
   end
 
+  it "should raise an error if the scheme begins with a digit" do
+    expect(lambda do
+      @uri.scheme = "1scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a plus" do
+    expect(lambda do
+      @uri.scheme = "+scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a dot" do
+    expect(lambda do
+      @uri.scheme = ".scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a dash" do
+    expect(lambda do
+      @uri.scheme = "-scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains an illegal character" do
+    expect(lambda do
+      @uri.scheme = "scheme!"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains whitespace" do
+    expect(lambda do
+      @uri.scheme = "sch eme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains a newline" do
+    expect(lambda do
+      @uri.scheme = "sch\neme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
   it "should raise an error if set into an invalid state" do
     expect(lambda do
       @uri.user = "user"
@@ -1047,6 +1143,26 @@ describe Addressable::URI, "when parsed from an Addressable::URI object" do
     expect(original_uri.host).to eq('example.com')
     expect(original_uri.to_s).to eq('http://example.com/')
   end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.heuristic_parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
 end
 
 describe Addressable::URI, "when parsed from something that looks " +
@@ -1059,6 +1175,15 @@ describe Addressable::URI, "when parsed from something that looks " +
   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
+      Addressable::URI.parse(uri)
+    end).not_to raise_error
+  end
+end
+
 describe Addressable::URI, "when parsed from ''" do
   before do
     @uri = Addressable::URI.parse("")
@@ -1908,6 +2033,12 @@ describe Addressable::URI, "when assigning IPv6 address" do
     expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
   end
 
+  it "should allow to set bare IPv6 address as hostname with IPAddr object" do
+    uri = Addressable::URI.parse("http://[::1]/")
+    uri.hostname = IPAddr.new('3ffe:1900:4545:3:200:f8ff:fe21:67cf')
+    expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
+  end
+
   it "should not allow to set bare IPv6 address as host" do
     uri = Addressable::URI.parse("http://[::1]/")
     skip "not checked"
@@ -3586,15 +3717,6 @@ describe Addressable::URI, "when parsed from " +
     expect(@uri.to_str).to eq(
       "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
     )
-    @uri.scheme = "bogus!"
-    expect(@uri.scheme).to eq("bogus!")
-    expect(@uri.normalized_scheme).to eq("bogus%21")
-    expect(@uri.normalize.to_s).to eq(
-      "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
-    )
-    expect(@uri.normalize.to_str).to eq(
-      "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
-    )
   end
 
   it "should have the correct site segment after assignment" do
@@ -3663,12 +3785,31 @@ describe Addressable::URI, "when parsed from " +
     expect(@uri.authority).to eq("user:pass@newexample.com")
   end
 
+  it "should have the correct host after assignment" do
+    @uri.hostname = "newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.hostname).to eq("newexample.com")
+    expect(@uri.authority).to eq("user:pass@newexample.com")
+  end
+
+  it "should raise an error if assigning a bogus object to the hostname" do
+    expect(lambda do
+      @uri.hostname = Object.new
+    end).to raise_error
+  end
+
   it "should have the correct port after assignment" do
     @uri.port = 8080
     expect(@uri.port).to eq(8080)
     expect(@uri.authority).to eq("user:pass@example.com:8080")
   end
 
+  it "should have the correct origin after assignment" do
+    @uri.origin = "http://newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.authority).to eq("newexample.com")
+  end
+
   it "should have the correct path after assignment" do
     @uri.path = "/newpath/to/resource"
     expect(@uri.path).to eq("/newpath/to/resource")
@@ -5395,6 +5536,24 @@ describe Addressable::URI, "when form encoding a non-Array object" do
   end
 end
 
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form encoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_encode(
+      {"value" => " %&+£€"}
+    )).to eq("value=+%25%26%2B%C2%A3%E2%82%AC")
+  end
+end
+
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form unencoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "value=+%25%26%2B%C2%A3%E2%82%AC"
+    )).to eq([["value", " %&+£€"]])
+  end
+end
+
 describe Addressable::URI, "when form unencoding a string" do
   it "should result in correct values" do
     expect(Addressable::URI.form_unencode(