addressable 2.2.5 → 2.2.6

data/CHANGELOG

@@ -1,3 +1,8 @@
+## 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
 - 'parsing' a pre-parsed URI object is now a dup operation
 - introduced conditional support for libidn

data/lib/addressable/uri.rb

@@ -55,6 +55,22 @@ module Addressable
 
     URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
 
+    PORT_MAPPING = {
+      "http" => 80,
+      "https" => 443,
+      "ftp" => 21,
+      "tftp" => 69,
+      "sftp" => 22,
+      "ssh" => 22,
+      "svn+ssh" => 22,
+      "telnet" => 23,
+      "nntp" => 119,
+      "gopher" => 70,
+      "wais" => 210,
+      "ldap" => 389,
+      "prospero" => 1525
+    }
+
     ##
     # Returns a URI object based on the parsed string.
     #
@@ -153,6 +169,8 @@ module Addressable
       case uri
       when /^http:\/+/
         uri.gsub!(/^http:\/+/, "http://")
+      when /^https:\/+/
+        uri.gsub!(/^https:\/+/, "https://")
       when /^feed:\/+http:\/+/
         uri.gsub!(/^feed:\/+http:\/+/, "feed:http://")
       when /^feed:\/+/
@@ -701,12 +719,32 @@ module Addressable
       end
     end
 
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.normalized_scheme
+      self.normalized_user
+      self.normalized_password
+      self.normalized_userinfo
+      self.normalized_host
+      self.normalized_port
+      self.normalized_authority
+      self.normalized_site
+      self.normalized_path
+      self.normalized_query
+      self.normalized_fragment
+      self.hash
+      super
+    end
+
     ##
     # The scheme component for this URI.
     #
     # @return [String] The scheme component.
     def scheme
-      return @scheme ||= nil
+      return instance_variable_defined?(:@scheme) ? @scheme : nil
     end
 
     ##
@@ -714,18 +752,14 @@ module Addressable
     #
     # @return [String] The scheme component, normalized.
     def normalized_scheme
-      @normalized_scheme ||= (begin
-        if self.scheme != nil
-          if self.scheme =~ /^\s*ssh\+svn\s*$/i
-            "svn+ssh"
-          else
-            Addressable::URI.normalize_component(
-              self.scheme.strip.downcase,
-              Addressable::URI::CharacterClasses::SCHEME
-            )
-          end
+      self.scheme && @normalized_scheme ||= (begin
+        if self.scheme =~ /^\s*ssh\+svn\s*$/i
+          "svn+ssh"
         else
-          nil
+          Addressable::URI.normalize_component(
+            self.scheme.strip.downcase,
+            Addressable::URI::CharacterClasses::SCHEME
+          )
         end
       end)
     end
@@ -760,7 +794,7 @@ module Addressable
     #
     # @return [String] The user component.
     def user
-      return @user ||= nil
+      return instance_variable_defined?(:@user) ? @user : nil
     end
 
     ##
@@ -768,19 +802,15 @@ module Addressable
     #
     # @return [String] The user component, normalized.
     def normalized_user
-      @normalized_user ||= (begin
-        if self.user
-          if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
-              (!self.password || self.password.strip.empty?)
-            nil
-          else
-            Addressable::URI.normalize_component(
-              self.user.strip,
-              Addressable::URI::CharacterClasses::UNRESERVED
-            )
-          end
-        else
+      self.user && @normalized_user ||= (begin
+        if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
+            (!self.password || self.password.strip.empty?)
           nil
+        else
+          Addressable::URI.normalize_component(
+            self.user.strip,
+            Addressable::URI::CharacterClasses::UNRESERVED
+          )
         end
       end)
     end
@@ -796,8 +826,7 @@ module Addressable
       @user = new_user ? new_user.to_str : nil
 
       # You can't have a nil user with a non-nil password
-      @password ||= nil
-      if @password != nil
+      if password != nil
         @user = EMPTYSTR if @user.nil?
       end
 
@@ -818,7 +847,7 @@ module Addressable
     #
     # @return [String] The password component.
     def password
-      return @password ||= nil
+      return instance_variable_defined?(:@password) ? @password : nil
     end
 
     ##
@@ -826,19 +855,15 @@ module Addressable
     #
     # @return [String] The password component, normalized.
     def normalized_password
-      @normalized_password ||= (begin
-        if self.password
-          if normalized_scheme =~ /https?/ && self.password.strip.empty? &&
-              (!self.user || self.user.strip.empty?)
-            nil
-          else
-            Addressable::URI.normalize_component(
-              self.password.strip,
-              Addressable::URI::CharacterClasses::UNRESERVED
-            )
-          end
-        else
+      self.password && @normalized_password ||= (begin
+        if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
+            (!self.user || self.user.strip.empty?)
           nil
+        else
+          Addressable::URI.normalize_component(
+            self.password.strip,
+            Addressable::URI::CharacterClasses::UNRESERVED
+          )
         end
       end)
     end
@@ -878,12 +903,10 @@ module Addressable
     #
     # @return [String] The userinfo component.
     def userinfo
-      @userinfo ||= (begin
-        current_user = self.user
-        current_password = self.password
-        if !current_user && !current_password
-          nil
-        elsif current_user && current_password
+      current_user = self.user
+      current_password = self.password
+      (current_user || current_password) && @userinfo ||= (begin
+        if current_user && current_password
           "#{current_user}:#{current_password}"
         elsif current_user && !current_password
           "#{current_user}"
@@ -896,7 +919,7 @@ module Addressable
     #
     # @return [String] The userinfo component, normalized.
     def normalized_userinfo
-      @normalized_userinfo ||= (begin
+      self.userinfo && @normalized_userinfo ||= (begin
         current_user = self.normalized_user
         current_password = self.normalized_password
         if !current_user && !current_password
@@ -944,7 +967,7 @@ module Addressable
     #
     # @return [String] The host component.
     def host
-      return @host ||= nil
+      return instance_variable_defined?(:@host) ? @host : nil
     end
 
     ##
@@ -952,7 +975,7 @@ module Addressable
     #
     # @return [String] The host component, normalized.
     def normalized_host
-      @normalized_host ||= (begin
+      self.host && @normalized_host ||= (begin
         if self.host != nil
           if !self.host.strip.empty?
             result = ::Addressable::IDNA.to_ascii(
@@ -998,20 +1021,16 @@ module Addressable
     #
     # @return [String] The authority component.
     def authority
-      @authority ||= (begin
-        if self.host.nil?
-          nil
-        else
-          authority = ""
-          if self.userinfo != nil
-            authority << "#{self.userinfo}@"
-          end
-          authority << self.host
-          if self.port != nil
-            authority << ":#{self.port}"
-          end
-          authority
+      self.host && @authority ||= (begin
+        authority = ""
+        if self.userinfo != nil
+          authority << "#{self.userinfo}@"
         end
+        authority << self.host
+        if self.port != nil
+          authority << ":#{self.port}"
+        end
+        authority
       end)
     end
 
@@ -1020,20 +1039,16 @@ module Addressable
     #
     # @return [String] The authority component, normalized.
     def normalized_authority
-      @normalized_authority ||= (begin
-        if self.normalized_host.nil?
-          nil
-        else
-          authority = ""
-          if self.normalized_userinfo != nil
-            authority << "#{self.normalized_userinfo}@"
-          end
-          authority << self.normalized_host
-          if self.normalized_port != nil
-            authority << ":#{self.normalized_port}"
-          end
-          authority
+      self.authority && @normalized_authority ||= (begin
+        authority = ""
+        if self.normalized_userinfo != nil
+          authority << "#{self.normalized_userinfo}@"
+        end
+        authority << self.normalized_host
+        if self.normalized_port != nil
+          authority << ":#{self.normalized_port}"
         end
+        authority
       end)
     end
 
@@ -1065,7 +1080,6 @@ module Addressable
       self.port = defined?(new_port) ? new_port : nil
 
       # Reset dependant values
-      @inferred_port = nil
       @userinfo = nil
       @normalized_userinfo = nil
       @uri_string = nil
@@ -1106,21 +1120,7 @@ module Addressable
     # numbers. Adding new schemes to this hash, as necessary, will allow
     # for better URI normalization.
     def self.port_mapping
-      @port_mapping ||= {
-        "http" => 80,
-        "https" => 443,
-        "ftp" => 21,
-        "tftp" => 69,
-        "sftp" => 22,
-        "ssh" => 22,
-        "svn+ssh" => 22,
-        "telnet" => 23,
-        "nntp" => 119,
-        "gopher" => 70,
-        "wais" => 210,
-        "ldap" => 389,
-        "prospero" => 1525
-      }
+      PORT_MAPPING
     end
 
     ##
@@ -1130,7 +1130,7 @@ module Addressable
     #
     # @return [Integer] The port component.
     def port
-      return @port ||= nil
+      return instance_variable_defined?(:@port) ? @port : nil
     end
 
     ##
@@ -1138,13 +1138,11 @@ module Addressable
     #
     # @return [Integer] The port component, normalized.
     def normalized_port
-      @normalized_port ||= (begin
-        if URI.port_mapping[normalized_scheme] == self.port
-          nil
-        else
-          self.port
-        end
-      end)
+      if URI.port_mapping[self.normalized_scheme] == self.port
+        nil
+      else
+        self.port
+      end
     end
 
     ##
@@ -1165,7 +1163,6 @@ module Addressable
 
       # Reset dependant values
       @authority = nil
-      @inferred_port = nil
       @normalized_port = nil
       @uri_string = nil
       @hash = nil
@@ -1181,17 +1178,15 @@ module Addressable
     #
     # @return [Integer] The inferred port component.
     def inferred_port
-      @inferred_port ||= (begin
-        if port.to_i == 0
-          if scheme
-            URI.port_mapping[scheme.strip.downcase]
-          else
-            nil
-          end
+      if self.port.to_i == 0
+        if self.scheme
+          URI.port_mapping[self.scheme.strip.downcase]
         else
-          port.to_i
+          nil
         end
-      end)
+      else
+        self.port.to_i
+      end
     end
 
     ##
@@ -1204,15 +1199,11 @@ module Addressable
     #
     # @return [String] The components that identify a site.
     def site
-      @site ||= (begin
-        if self.scheme || self.authority
-          site_string = ""
-          site_string << "#{self.scheme}:" if self.scheme != nil
-          site_string << "//#{self.authority}" if self.authority != nil
-          site_string
-        else
-          nil
-        end
+      (self.scheme || self.authority) && @site ||= (begin
+        site_string = ""
+        site_string << "#{self.scheme}:" if self.scheme != nil
+        site_string << "//#{self.authority}" if self.authority != nil
+        site_string
       end)
     end
 
@@ -1226,19 +1217,15 @@ module Addressable
     #
     # @return [String] The normalized components that identify a site.
     def normalized_site
-      @site ||= (begin
-        if self.normalized_scheme || self.normalized_authority
-          site_string = ""
-          if self.normalized_scheme != nil
-            site_string << "#{self.normalized_scheme}:"
-          end
-          if self.normalized_authority != nil
-            site_string << "//#{self.normalized_authority}"
-          end
-          site_string
-        else
-          nil
+      self.site && @normalized_site ||= (begin
+        site_string = ""
+        if self.normalized_scheme != nil
+          site_string << "#{self.normalized_scheme}:"
         end
+        if self.normalized_authority != nil
+          site_string << "//#{self.normalized_authority}"
+        end
+        site_string
       end)
     end
 
@@ -1269,8 +1256,7 @@ module Addressable
     #
     # @return [String] The path component.
     def path
-      @path ||= EMPTYSTR
-      return @path
+      return instance_variable_defined?(:@path) ? @path : EMPTYSTR
     end
 
     NORMPATH = /^(?!\/)[^\/:]*:.*$/
@@ -1280,14 +1266,14 @@ module Addressable
     # @return [String] The path component, normalized.
     def normalized_path
       @normalized_path ||= (begin
-        if self.scheme == nil && self.path != nil && !self.path.empty? &&
-            self.path =~ NORMPATH
+        path = self.path.to_s
+        if self.scheme == nil && path =~ NORMPATH
           # Relative paths with colons in the first segment are ambiguous.
-          self.path.sub!(":", "%2F")
+          path = path.sub(":", "%2F")
         end
         # String#split(delimeter, -1) uses the more strict splitting behavior
         # found by default in Python.
-        result = (self.path.strip.split(SLASH, -1).map do |segment|
+        result = (path.strip.split(SLASH, -1).map do |segment|
           Addressable::URI.normalize_component(
             segment,
             Addressable::URI::CharacterClasses::PCHAR
@@ -1346,7 +1332,7 @@ module Addressable
     #
     # @return [String] The query component.
     def query
-      return @query ||= nil
+      return instance_variable_defined?(:@query) ? @query : nil
     end
 
     ##
@@ -1354,17 +1340,13 @@ module Addressable
     #
     # @return [String] The query component, normalized.
     def normalized_query
-      @normalized_query ||= (begin
-        if self.query
-          (self.query.split("&", -1).map do |pair|
-            Addressable::URI.normalize_component(
-              pair,
-              Addressable::URI::CharacterClasses::QUERY.sub("\\&", "")
-            )
-          end).join("&")
-        else
-          nil
-        end
+      self.query && @normalized_query ||= (begin
+        (self.query.split("&", -1).map do |pair|
+          Addressable::URI.normalize_component(
+            pair,
+            Addressable::URI::CharacterClasses::QUERY.sub("\\&", "")
+          )
+        end).join("&")
       end)
     end
 
@@ -1595,7 +1577,7 @@ module Addressable
     #
     # @return [String] The fragment component.
     def fragment
-      return @fragment ||= nil
+      return instance_variable_defined?(:@fragment) ? @fragment : nil
     end
 
     ##
@@ -1603,15 +1585,11 @@ module Addressable
     #
     # @return [String] The fragment component, normalized.
     def normalized_fragment
-      @normalized_fragment ||= (begin
-        if self.fragment
-          Addressable::URI.normalize_component(
-            self.fragment.strip,
-            Addressable::URI::CharacterClasses::FRAGMENT
-          )
-        else
-          nil
-        end
+      self.fragment && @normalized_fragment ||= (begin
+        Addressable::URI.normalize_component(
+          self.fragment.strip,
+          Addressable::URI::CharacterClasses::FRAGMENT
+        )
       end)
     end
 
@@ -2111,6 +2089,11 @@ module Addressable
     #
     # @return [String] The URI's <code>String</code> representation.
     def to_s
+      if self.scheme == nil && self.path != nil && !self.path.empty? &&
+          self.path =~ NORMPATH
+        raise InvalidURIError,
+          "Cannot assemble URI string with ambiguous path: '#{self.path}'"
+      end
       @uri_string ||= (begin
         uri_string = ""
         uri_string << "#{self.scheme}:" if self.scheme != nil

data/lib/addressable/version.rb

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

data/spec/addressable/idna_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 # Copyright (C) 2006-2011 Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");

data/spec/addressable/template_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 # Copyright (C) 2006-2011 Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
@@ -1165,11 +1166,11 @@ describe Addressable::URI, "when given the mapping supplied in " +
 
   it "should result in ':%E1%B9%A1:%E1%B9%A1:' " +
       "when used to expand '{-neg|:|corge}{-suffix|:|plugh}'" do
+    # Note: We need to check the path, because technically, this is an
+    # invalid URI.
     Addressable::Template.new(
       "{-neg|:|corge}{-suffix|:|plugh}"
-    ).expand(
-      @mapping
-    ).to_s.should == ":%E1%B9%A1:%E1%B9%A1:"
+    ).expand(@mapping).path.should == ":%E1%B9%A1:%E1%B9%A1:"
   end
 
   it "should result in '../ben%20%26%20jerrys/' " +
@@ -1192,11 +1193,11 @@ describe Addressable::URI, "when given the mapping supplied in " +
 
   it "should result in ':200:' " +
       "when used to expand ':{1-a_b.c}:'" do
+    # Note: We need to check the path, because technically, this is an
+    # invalid URI.
     Addressable::Template.new(
       ":{1-a_b.c}:"
-    ).expand(
-      @mapping
-    ).to_s.should == ":200:"
+    ).expand(@mapping).path.should == ":200:"
   end
 end
 

data/spec/addressable/uri_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 # Copyright (C) 2006-2011 Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
@@ -205,6 +206,108 @@ describe Addressable::URI, "when created from nil components" do
   end
 end
 
+describe Addressable::URI, "when frozen" do
+  before do
+    @uri = Addressable::URI.new.freeze
+  end
+
+  it "returns nil for #scheme" do
+    @uri.scheme.should == nil
+  end
+
+  it "returns nil for #normalized_scheme" do
+    @uri.normalized_scheme.should == nil
+  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 nil for #host" do
+    @uri.host.should == nil
+  end
+
+  it "returns nil for #normalized_host" do
+    @uri.normalized_host.should == nil
+  end
+
+  it "returns nil for #authority" do
+    @uri.authority.should == nil
+  end
+
+  it "returns nil for #normalized_authority" do
+    @uri.normalized_authority.should == nil
+  end
+
+  it "returns nil for #port" do
+    @uri.port.should == nil
+  end
+
+  it "returns nil for #normalized_port" do
+    @uri.normalized_port.should == nil
+  end
+
+  it "returns nil for #site" do
+    @uri.site.should == nil
+  end
+
+  it "returns nil for #normalized_site" do
+    @uri.normalized_site.should == nil
+  end
+
+  it "returns '' for #path" do
+    @uri.path.should == ''
+  end
+
+  it "returns '' for #normalized_path" do
+    @uri.normalized_path.should == ''
+  end
+
+  it "returns nil for #query" do
+    @uri.query.should == nil
+  end
+
+  it "returns nil for #normalized_query" do
+    @uri.normalized_query.should == nil
+  end
+
+  it "returns nil for #fragment" do
+    @uri.fragment.should == nil
+  end
+
+  it "returns nil for #normalized_fragment" do
+    @uri.normalized_fragment.should == nil
+  end
+
+  it "returns #hash" do
+    @uri.hash.should_not be nil
+  end
+
+  it "returns #to_s" do
+    @uri.to_s.should == ''
+  end
+end
+
 describe Addressable::URI, "when created from string components" do
   before do
     @uri = Addressable::URI.new(
@@ -3953,15 +4056,15 @@ describe Addressable::URI, "when given a Windows root directory" do
   end
 end
 
-describe Addressable::URI, "when given the path '/home/user/'" do
+describe Addressable::URI, "when given the path '/one/two/'" do
   before do
-    @path = '/home/user/'
+    @path = '/one/two/'
   end
 
   it "should convert to " +
-      "\'file:///home/user/\'" do
+      "\'file:///one/two/\'" do
     @uri = Addressable::URI.convert_path(@path)
-    @uri.to_str.should == "file:///home/user/"
+    @uri.to_str.should == "file:///one/two/"
   end
 
   it "should have an origin of 'file://'" do
@@ -4352,8 +4455,23 @@ describe Addressable::URI, "when given the input " +
     @uri = Addressable::URI.heuristic_parse(@input)
     @uri.to_s.should == "http://example.com/"
   end
+
+  it "should not raise error when frozen" do
+    lambda {Addressable::URI.heuristic_parse(@input).freeze.to_s}.should_not raise_error
+  end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'https://example.com/'" do
+  before do
+    @input = "https://example.com/"
+  end
+
+  it "should heuristically parse to 'https://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "https://example.com/"
+  end
+end
 
 describe Addressable::URI, "when given the input " +
     "'http:example.com/'" do
@@ -4373,6 +4491,24 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'https:example.com/'" do
+  before do
+    @input = "https:example.com/"
+  end
+
+  it "should heuristically parse to 'https://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "https://example.com/"
+  end
+
+  it "should heuristically parse to 'https://example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    @uri.to_s.should == "https://example.com/"
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'http://example.com/example.com/'" do
   before do
@@ -4587,8 +4723,11 @@ describe Addressable::URI, "when assigning path values" do
 
   it "should correctly assign paths containing colons" do
     @uri.path = "acct:bob@sporkmonger.com"
-    Addressable::URI.parse(@uri.normalize.to_str).path.should == @uri.path
+    @uri.path.should == "acct:bob@sporkmonger.com"
     @uri.normalize.to_str.should == "acct%2Fbob@sporkmonger.com"
+    (lambda { @uri.to_s }).should raise_error(
+      Addressable::URI::InvalidURIError
+    )
   end
 
   it "should correctly assign paths containing colons" do

data/tasks/spec.rake

@@ -6,9 +6,13 @@ namespace :spec do
 
     t.rcov = RCOV_ENABLED
     t.rcov_opts = [
+      '--exclude', 'lib\\/compat',
       '--exclude', 'spec',
+      '--exclude', '\\.rvm\\/gems',
       '--exclude', '1\\.8\\/gems',
       '--exclude', '1\\.9\\/gems',
+      '--exclude', '\\.rvm',
+      '--exclude', '\\/Library\\/Ruby',
       '--exclude', 'addressable\\/idna' # environment dependant
     ]
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: addressable
 version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: false
+  hash: 11
+  prerelease: 
   segments: 
   - 2
   - 2
-  - 5
-  version: 2.2.5
+  - 6
+  version: 2.2.6
 platform: ruby
 authors: 
 - Bob Aman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-09 00:00:00 -07:00
+date: 2011-05-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: addressable
-rubygems_version: 1.3.7
+rubygems_version: 1.4.1
 signing_key: 
 specification_version: 3
 summary: URI Implementation