addressable 2.2.6 → 2.2.7

data/CHANGELOG

@@ -1,33 +1,37 @@
-## Addressable 2.2.6
+# Addressable 2.2.7
+- fixed issues related to Addressable::URI#query_values=
+- the Addressable::URI.parse method is now polymorphic
+
+# Addressable 2.2.6
 - changed the way ambiguous paths are handled
 - fixed bug with frozen URIs
 - https supported in heuristic parsing
 
-## Addressable 2.2.5
+# Addressable 2.2.5
 - 'parsing' a pre-parsed URI object is now a dup operation
 - introduced conditional support for libidn
 - fixed normalization issue on ampersands in query strings
 - added additional tests around handling of query strings
 
-## Addressable 2.2.4
+# Addressable 2.2.4
 - added origin support from draft-ietf-websec-origin-00
 - resolved issue with attempting to navigate below root
 - fixed bug with string splitting in query strings
 
-## Addressable 2.2.3
+# Addressable 2.2.3
 - added :flat_array notation for query strings
 
-## Addressable 2.2.2
+# Addressable 2.2.2
 - fixed issue with percent escaping of '+' character in query strings
 
-## Addressable 2.2.1
+# Addressable 2.2.1
 - added support for application/x-www-form-urlencoded.
 
-## Addressable 2.2.0
+# Addressable 2.2.0
 - added site methods
 - improved documentation
 
-## Addressable 2.1.2
+# Addressable 2.1.2
 - added HTTP request URI methods
 - better handling of Windows file paths
 - validation_deferred boolean replaced with defer_validation block
@@ -35,14 +39,14 @@
 - fixed issue with constructing URIs with relative paths
 - fixed warnings
 
-## Addressable 2.1.1
+# Addressable 2.1.1
 - more type checking changes
 - fixed issue with unicode normalization
 - added method to find template defaults
 - symbolic keys are now allowed in template mappings
 - numeric values and symbolic values are now allowed in template mappings
 
-## Addressable 2.1.0
+# Addressable 2.1.0
 - refactored URI template support out into its own class
 - removed extract method due to being useless and unreliable
 - removed Addressable::URI.expand_template
@@ -56,15 +60,15 @@
 - worked around issue with freezing URIs
 - improved specs
 
-## Addressable 2.0.2
+# Addressable 2.0.2
 - fixed issue with URI template expansion
 - fixed issue with percent escaping characters 0-15
 
-## Addressable 2.0.1
+# Addressable 2.0.1
 - fixed issue with query string assignment
 - fixed issue with improperly encoded components
 
-## Addressable 2.0.0
+# Addressable 2.0.0
 - the initialize method now takes an options hash as its only parameter
 - added query_values method to URI class
 - completely replaced IDNA implementation with pure Ruby
@@ -79,20 +83,20 @@
 - updated URI Template code to match v 03 of the draft spec
 - added a bunch of new specifications
 
-## Addressable 1.0.4
+# Addressable 1.0.4
 - switched to using RSpec's pending system for specs that rely on IDN
 - fixed issue with creating URIs with paths that are not prefixed with '/'
 
-## Addressable 1.0.3
+# Addressable 1.0.3
 - implemented a hash method
 
-## Addressable 1.0.2
+# Addressable 1.0.2
 - fixed minor bug with the extract_mapping method
 
-## Addressable 1.0.1
+# Addressable 1.0.1
 - fixed minor bug with the extract_mapping method
 
-## Addressable 1.0.0
+# Addressable 1.0.0
 - heuristic parse method added
 - parsing is slightly more strict
 - replaced to_h with to_hash
@@ -101,16 +105,16 @@
 - improved heckle rake task
 - no surviving heckle mutations
 
-## Addressable 0.1.2
+# Addressable 0.1.2
 - improved normalization
 - fixed bug in joining algorithm
 - updated specifications
   
-## Addressable 0.1.1
+# Addressable 0.1.1
 - updated documentation
 - added URI Template variable extraction
   
-## Addressable 0.1.0
+# Addressable 0.1.0
 - initial release
 - implementation based on RFC 3986, 3987
 - support for IRIs via libidn

data/lib/addressable/template.rb

@@ -931,7 +931,7 @@ module Addressable
       values.pop if values[-1] == ""
 
       if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
+        values.map! { |val| processor.restore(variables.first, val) }
       end
       values = values.first if values.size == 1
       if mapping[variables.first] == nil || mapping[variables.first] == values
@@ -965,7 +965,7 @@ module Addressable
       values = value.split(argument, -1)
       values.pop if values[-1] == ""
       if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
+        values.map! { |val| processor.restore(variables.first, val) }
       end
       values = values.first if values.size == 1
       if mapping[variables.first] == nil || mapping[variables.first] == values
@@ -1034,7 +1034,7 @@ module Addressable
       values = value.split(argument, -1)
       values.pop if values[-1] == ""
       if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
+        values.map! { |val| processor.restore(variables.first, val) }
       end
       if mapping[variables.first] == nil || mapping[variables.first] == values
         mapping[variables.first] = values

data/lib/addressable/uri.rb

@@ -127,7 +127,7 @@ module Addressable
         port = nil
       end
 
-      return Addressable::URI.new(
+      return new(
         :scheme => scheme,
         :user => user,
         :password => password,
@@ -325,7 +325,11 @@ module Addressable
       return nil if component.nil?
 
       begin
-        component = component.to_str
+        if component.kind_of?(Symbol) || component.kind_of?(Numeric)
+          component = component.to_s
+        else
+          component = component.to_str
+        end
       rescue TypeError, NoMethodError
         raise TypeError, "Can't convert #{component.class} into String."
       end if !component.is_a? String
@@ -715,6 +719,7 @@ module Addressable
         self.authority = options[:authority] if options[:authority]
         self.path = options[:path] if options[:path]
         self.query = options[:query] if options[:query]
+        self.query_values = options[:query_values] if options[:query_values]
         self.fragment = options[:fragment] if options[:fragment]
       end
     end
@@ -1015,6 +1020,14 @@ module Addressable
       validate()
     end
 
+    ##
+    # @see Addressable::URI#host
+    alias_method :hostname, :host
+
+    ##
+    # @see Addressable::URI#host=
+    alias_method :hostname=, :host=
+
     ##
     # The authority component for this URI.
     # Combines the user, password, host, and port components.
@@ -1415,7 +1428,7 @@ module Addressable
           end
         end
         if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
-          hash.sort.inject([]) do |accu, (key, value)|
+          hash.sort.inject([]) do |accu, (_, value)|
             accu << value; accu
           end
         else
@@ -1497,39 +1510,55 @@ module Addressable
         # Only to be used for non-Array inputs. Arrays should preserve order.
         new_query_values.sort!
       end
-      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
 
-      # Algorithm shamelessly stolen from Julien Genestoux, slightly modified
-      buffer = ""
-      stack = []
-      e = lambda do |component|
-        component = component.to_s if component.kind_of?(Symbol)
-        URI.encode_component(component, CharacterClasses::UNRESERVED)
-      end
-      new_query_values.each do |key, value|
-        if value.kind_of?(Hash)
-          stack << [key, value]
-        elsif value.kind_of?(Array)
-          stack << [
-            key,
-            value.inject({}) { |accu, x| accu[accu.size.to_s] = x; accu }
-          ]
+      ##
+      # Joins and converts parent and value into a properly encoded and
+      # ordered URL query.
+      #
+      # @private
+      # @param [String] parent an URI encoded component.
+      # @param [Array, Hash, Symbol, #to_str] value
+      #
+      # @return [String] a properly escaped and ordered URL query.
+      to_query = lambda do |parent, value|
+        if value.is_a?(Hash)
+          value = value.map do |key, val|
+            [
+              URI.encode_component(key, CharacterClasses::UNRESERVED),
+              val
+            ]
+          end
+          value.sort!
+          buffer = ""
+          value.each do |key, val|
+            new_parent = "#{parent}[#{key}]"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
+        elsif value.is_a?(Array)
+          buffer = ""
+          value.each_with_index do |val, i|
+            new_parent = "#{parent}[#{i}]"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
         elsif value == true
-          buffer << "#{e.call(key)}&"
+          return parent
         else
-          buffer << "#{e.call(key)}=#{e.call(value)}&"
+          encoded_value = URI.encode_component(
+            value, CharacterClasses::UNRESERVED
+          )
+          return "#{parent}=#{encoded_value}"
         end
       end
-      stack.each do |(parent, hash)|
-        (hash.sort_by { |key| key.to_s }).each do |(key, value)|
-          if value.kind_of?(Hash)
-            stack << ["#{parent}[#{key}]", value]
-          elsif value == true
-            buffer << "#{parent}[#{e.call(key)}]&"
-          else
-            buffer << "#{parent}[#{e.call(key)}]=#{e.call(value)}&"
-          end
-        end
+
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      buffer = ""
+      new_query_values.each do |parent, value|
+        encoded_parent = URI.encode_component(
+          parent, CharacterClasses::UNRESERVED
+        )
+        buffer << "#{to_query.call(encoded_parent, value)}&"
       end
       self.query = buffer.chop
     end
@@ -2182,7 +2211,7 @@ module Addressable
         parent = normalized_path.match(NPATH2)
         if parent && ((parent[1] != PARENT1 && parent[1] != PARENT2) \
                       || (parent[2] != PARENT1 && parent[2] != PARENT2))
-          mod ||= normalized_path.gsub!(/\/#{parent[1]}\/\.\.\/|(\/#{parent[2]}\/\.\.$)/, SLASH)
+          mod ||= normalized_path.gsub!(/\/#{Regexp.escape(parent[1].to_s)}\/\.\.\/|(\/#{Regexp.escape(parent[2].to_s)}\/\.\.$)/, SLASH)
         end
 
         mod ||= normalized_path.gsub!(NPATH3, EMPTYSTR)

data/lib/addressable/version.rb

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

data/spec/addressable/net_http_compat_spec.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# Copyright (C) 2006-2011 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 "addressable/uri"
+require "net/http"
+
+describe Net::HTTP do
+  it "should be compatible with Addressable" do
+    response_body =
+      Net::HTTP.get(Addressable::URI.parse('http://www.google.com/'))
+    response_body.should_not be_nil
+  end
+end

data/spec/addressable/uri_spec.rb

@@ -1013,11 +1013,11 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should have the correct password after assignment" do
-    @uri.password = "secret@123!"
-    @uri.password.should == "secret@123!"
-    @uri.normalized_password.should == "secret%40123%21"
+    @uri.password = "#secret@123!"
+    @uri.password.should == "#secret@123!"
+    @uri.normalized_password.should == "%23secret%40123%21"
     @uri.user.should == ""
-    @uri.normalize.to_s.should == "http://:secret%40123%21@example.com/"
+    @uri.normalize.to_s.should == "http://:%23secret%40123%21@example.com/"
     @uri.omit(:password).to_s.should == "http://example.com"
   end
 
@@ -1844,6 +1844,82 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path(/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path(/..")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/(path)/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/(path)/..")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path(/../'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path(/../")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/(path)/../'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/(path)/../")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/path/to/resource/'" do
   before do
@@ -2777,7 +2853,8 @@ describe Addressable::URI, "when parsed from " +
     @uri.query_values.should == { 'q' => 'Q&A' }
   end
 
-  it "should normalize to the original uri (with the ampersand properly percent-encoded)" do
+  it "should normalize to the original uri " +
+      "(with the ampersand properly percent-encoded)" do
     @uri.normalize.to_s.should == "http://example.com/search?q=Q%26A"
   end
 end
@@ -4422,25 +4499,25 @@ end
 describe Addressable::URI, "when encoding a bogus object" do
   it "should raise a TypeError" do
     (lambda do
-      Addressable::URI.encode(42)
+      Addressable::URI.encode(Object.new)
     end).should raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
     (lambda do
-      Addressable::URI.normalized_encode(42)
+      Addressable::URI.normalized_encode(Object.new)
     end).should raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
     (lambda do
-      Addressable::URI.encode_component("günther", 42)
+      Addressable::URI.encode_component("günther", Object.new)
     end).should raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
     (lambda do
-      Addressable::URI.encode_component(42)
+      Addressable::URI.encode_component(Object.new)
     end).should raise_error(TypeError)
   end
 end
@@ -4457,7 +4534,9 @@ describe Addressable::URI, "when given the input " +
   end
 
   it "should not raise error when frozen" do
-    lambda {Addressable::URI.heuristic_parse(@input).freeze.to_s}.should_not raise_error
+    (lambda do
+      Addressable::URI.heuristic_parse(@input).freeze.to_s
+    end).should_not raise_error
   end
 end
 
@@ -4653,8 +4732,19 @@ describe Addressable::URI, "when assigning query values" do
     @uri.query.should == "a=a&b[0]=c&b[1]=d&b[2]=e"
   end
 
+  it "should correctly assign {'a' => {'b' => [ 'c']}}" do
+    @uri.query_values = { 'a' => {'b' => [ 'c'] } }
+    @uri.query.should == "a[b][0]=c"
+  end
+
+  it "should correctly assign {:b => '2', :a => {:c => '1'}}" do
+    @uri.query_values = {:b => '2', :a => { :c => '1' }}
+    @uri.query.should == "a[c]=1&b=2"
+  end
+
   it "should correctly assign " +
-      "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, {:e => 'e', :f => 'f'}]}" do
+      "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, " +
+      "{:e => 'e', :f => 'f'}]}" do
     @uri.query_values = {
       :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
     }
@@ -4662,7 +4752,8 @@ describe Addressable::URI, "when assigning query values" do
   end
 
   it "should correctly assign " +
-      "{:a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]}" do
+      "{:a => 'a', :b => [{:c => true, :d => 'd'}, " +
+      "{:e => 'e', :f => 'f'}]}" do
     @uri.query_values = {
       :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
     }
@@ -4678,13 +4769,32 @@ describe Addressable::URI, "when assigning query values" do
   end
 
   it "should correctly assign " +
-      "{:a => 'a', :b => {:c => true, :d => 'd'}, :e => []}" do
+      "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
     @uri.query_values = {
       :a => 'a', :b => {:c => true, :d => 'd'}
     }
     @uri.query.should == "a=a&b[c]&b[d]=d"
   end
 
+  it "should correctly assign {:a => 1, :b => 1.5}" do
+    @uri.query_values = { :a => 1, :b => 1.5 }
+    @uri.query.should == "a=1&b=1.5"
+  end
+
+  it "should correctly assign " +
+      "{:z => 1, :f => [2, {999.1 => [3,'4']}, ['h', 'i']], " +
+      ":a => {:b => ['c', 'd'], :e => true, :y => 0.5}}" do
+    @uri.query_values = {
+      :z => 1,
+      :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
+      :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
+    }
+    @uri.query.should == (
+      "a[b][0]=c&a[b][1]=d&a[e]&a[y]=0.5&f[0]=2&" +
+      "f[1][999.1][0]=3&f[1][999.1][1]=4&f[2][0]=h&f[2][1]=i&z=1"
+    )
+  end
+
   it "should correctly assign {}" do
     @uri.query_values = {}
     @uri.query.should == ''

data/tasks/gem.rake

@@ -81,4 +81,6 @@ end
 desc "Alias to gem:package"
 task "gem" => "gem:package"
 
+task "gem:release" => "gem:gemspec"
+
 task "clobber" => ["gem:clobber_package"]

data/tasks/git.rake

@@ -19,10 +19,15 @@ namespace :git do
       v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
       abort "Versions don't match #{v} vs #{PKG_VERSION}" if v != PKG_VERSION
 
+      git_status = `git status`
+      if git_status !~ /nothing to commit \(working directory clean\)/
+        abort "Working directory isn't clean."
+      end
+
       tag = "#{PKG_NAME}-#{PKG_VERSION}"
       msg = "Release #{PKG_NAME}-#{PKG_VERSION}"
 
-      existing_tags = `git tag -l instrument-*`.split("\n")
+      existing_tags = `git tag -l #{PKG_NAME}-*`.split('\n')
       if existing_tags.include?(tag)
         warn("Tag already exists, deleting...")
         unless system "git tag -d #{tag}"

data/tasks/spec.rake

@@ -18,6 +18,13 @@ namespace :spec do
   end
 
   Spec::Rake::SpecTask.new(:normal) do |t|
+    t.libs = %w[lib spec]
+    t.spec_files = FileList['spec/**/*_spec.rb'].exclude(/compat/)
+    t.spec_opts = ['--color', '--format', 'specdoc']
+    t.rcov = false
+  end
+
+  Spec::Rake::SpecTask.new(:all) do |t|
     t.libs = %w[lib spec]
     t.spec_files = FileList['spec/**/*_spec.rb']
     t.spec_opts = ['--color', '--format', 'specdoc']

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: addressable
 version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: 
+  prerelease: false
   segments: 
   - 2
   - 2
-  - 6
-  version: 2.2.6
+  - 7
+  version: 2.2.7
 platform: ruby
 authors: 
 - Bob Aman
@@ -15,18 +14,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-12 00:00:00 -07:00
+date: 2012-02-16 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 5
         segments: 
         - 0
         - 7
@@ -38,11 +35,9 @@ dependencies:
   name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
         segments: 
         - 1
         - 0
@@ -54,11 +49,9 @@ dependencies:
   name: launchy
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 0
         - 3
@@ -70,11 +63,9 @@ dependencies:
   name: diff-lcs
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 1
         - 1
@@ -102,6 +93,7 @@ files:
 - lib/addressable/uri.rb
 - lib/addressable/version.rb
 - spec/addressable/idna_spec.rb
+- spec/addressable/net_http_compat_spec.rb
 - spec/addressable/template_spec.rb
 - spec/addressable/uri_spec.rb
 - tasks/clobber.rake
@@ -128,27 +120,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: addressable
-rubygems_version: 1.4.1
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: URI Implementation