addressable 2.1.1 → 2.1.2

data/CHANGELOG

@@ -1,6 +1,18 @@
+=== Addressable 2.1.2
+  * added HTTP request URI methods
+  * better handling of Windows file paths
+  * validation_deferred boolean replaced with defer_validation block
+  * normalization of percent-encoded paths should now be correct
+  * fixed issue with constructing URIs with relative paths
+  * fixed warnings
+
 === Addressable 2.1.1
-  * fixed some missing type checking
+  * 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
   * refactored URI template support out into its own class
   * removed extract method due to being useless and unreliable

data/lib/addressable/template.rb

@@ -495,13 +495,13 @@ module Addressable
     #
     # @return [Hash] Mapping of template variables to their defaults
     def variable_defaults
-      @variable_defaults ||= Hash[*ordered_variable_defaults.reject { |k,v| v.nil? }.flatten]
+      @variable_defaults ||=
+        Hash[*ordered_variable_defaults.reject { |k, v| v.nil? }.flatten]
     end
 
   private
-
     def ordered_variable_defaults
-      @ordered_variable_defaults ||= begin
+      @ordered_variable_defaults ||= (begin
         expansions, expansion_regexp = parse_template_pattern(pattern)
 
         expansions.inject([]) do |result, expansion|
@@ -514,7 +514,7 @@ module Addressable
           end
           result
         end
-      end
+      end)
     end
 
     ##
@@ -800,9 +800,9 @@ module Addressable
     # @return [Array]
     #   A tuple of the operator, argument, variables, and mapping.
     def parse_template_expansion(capture, mapping={})
-      operator, argument, variables = capture[1...-1].split("|")
+      operator, argument, variables = capture[1...-1].split("|", -1)
       operator.gsub!(/^\-/, "")
-      variables = variables.split(",")
+      variables = variables.split(",", -1)
       mapping = (variables.inject({}) do |accu, var|
         varname, _, vardefault = var.scan(/^(.+?)(=(.*))?$/)[0]
         accu[varname] = vardefault

data/lib/addressable/uri.rb

@@ -36,11 +36,6 @@ module Addressable
     class InvalidURIError < StandardError
     end
 
-    ##
-    # Raised if an invalid method option is supplied.
-    class InvalidOptionError < StandardError
-    end
-
     ##
     # Container for the character classes specified in
     # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
@@ -172,11 +167,13 @@ module Addressable
       if parsed.path.include?(".")
         new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
         if new_host
-          new_path = parsed.path.gsub(
-            Regexp.new("^" + Regexp.escape(new_host)), "")
-          parsed.host = new_host
-          parsed.path = new_path
-          parsed.scheme = hints[:scheme] unless parsed.scheme
+          parsed.defer_validation do
+            new_path = parsed.path.gsub(
+              Regexp.new("^" + Regexp.escape(new_host)), "")
+            parsed.host = new_host
+            parsed.path = new_path
+            parsed.scheme = hints[:scheme] unless parsed.scheme
+          end
         end
       end
       return parsed
@@ -223,12 +220,14 @@ module Addressable
       path = path.to_str.strip
 
       path.gsub!(/^file:\/?\/?/, "") if path =~ /^file:\/?\/?/
-      path = "/" + path if path =~ /^([a-zA-Z])(\||:)/
+      path = "/" + path if path =~ /^([a-zA-Z])[\|:]/
       uri = self.parse(path)
 
       if uri.scheme == nil
         # Adjust windows-style uris
-        uri.path.gsub!(/^\/?([a-zA-Z])\|(\\|\/)/, "/\\1:/")
+        uri.path.gsub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
+          "/#{$1.downcase}:/"
+        end
         uri.path.gsub!(/\\/, "/")
         if File.exists?(uri.path) &&
             File.stat(uri.path).directory?
@@ -377,6 +376,71 @@ module Addressable
       alias_method :unescape_component, :unencode
     end
 
+
+    ##
+    # Normalizes the encoding of a URI component.
+    #
+    # @param [String, #to_str] component The URI component to encode.
+    #
+    # @param [String, Regexp] character_class
+    #
+    # The characters which are not percent encoded. If a <tt>String</tt> is
+    # passed, the <tt>String</tt> must be formatted as a regular expression
+    # character class. (Do not include the surrounding square brackets.)  For
+    # example, <tt>"b-zB-Z0-9"</tt> would cause everything but the letters 'b'
+    # through 'z' and the numbers '0' through '9' to be percent encoded. If a
+    # <tt>Regexp</tt> is passed, the value <tt>/[^b-zB-Z0-9]/</tt> would have
+    # the same effect. A set of useful <tt>String</tt> values may be found in
+    # the <tt>Addressable::URI::CharacterClasses</tt> module. The default
+    # value is the reserved plus unreserved character classes specified in <a
+    # href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @return [String] The normalized component.
+    #
+    # @example
+    #   Addressable::URI.normalize_component("simpl%65/%65xampl%65", "b-zB-Z")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65", /[^b-zB-Z]/
+    #   )
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65",
+    #     Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    def self.normalize_component(component, character_class=
+        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED)
+      return nil if component.nil?
+      if !component.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{component.class} into String."
+      end
+      component = component.to_str
+      if ![String, Regexp].include?(character_class.class)
+        raise TypeError,
+          "Expected String or Regexp, got #{character_class.inspect}"
+      end
+      if character_class.kind_of?(String)
+        character_class = /[^#{character_class}]/
+      end
+      if component.respond_to?(:force_encoding)
+        # We can't perform regexps on invalid UTF sequences, but
+        # here we need to, so switch to ASCII.
+        component = component.dup
+        component.force_encoding(Encoding::ASCII_8BIT)
+      end
+      unencoded = self.unencode_component(component)
+      begin
+        encoded = self.encode_component(
+          Addressable::IDNA.unicode_normalize_kc(unencoded),
+          character_class
+        )
+      rescue ArgumentError
+        encoded = self.encode_component(unencoded)
+      end
+      return encoded
+    end
+
     ##
     # Percent encodes any special characters in the URI.
     #
@@ -530,18 +594,20 @@ module Addressable
         end
       end
 
-      self.validation_deferred = true
-      self.scheme = options[:scheme] if options[:scheme]
-      self.user = options[:user] if options[:user]
-      self.password = options[:password] if options[:password]
-      self.userinfo = options[:userinfo] if options[:userinfo]
-      self.host = options[:host] if options[:host]
-      self.port = options[:port] if options[:port]
-      self.authority = options[:authority] if options[:authority]
-      self.path = options[:path] if options[:path]
-      self.query = options[:query] if options[:query]
-      self.fragment = options[:fragment] if options[:fragment]
-      self.validation_deferred = false
+      self.defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        self.scheme = options[:scheme] if options[:scheme]
+        self.user = options[:user] if options[:user]
+        self.password = options[:password] if options[:password]
+        self.userinfo = options[:userinfo] if options[:userinfo]
+        self.host = options[:host] if options[:host]
+        self.port = options[:port] if options[:port]
+        self.authority = options[:authority] if options[:authority]
+        self.path = options[:path] if options[:path]
+        self.query = options[:query] if options[:query]
+        self.fragment = options[:fragment] if options[:fragment]
+      end
     end
 
     ##
@@ -549,7 +615,7 @@ module Addressable
     #
     # @return [String] The scheme component.
     def scheme
-      return @scheme
+      return @scheme ||= nil
     end
 
     ##
@@ -562,10 +628,8 @@ module Addressable
           if self.scheme =~ /^\s*ssh\+svn\s*$/i
             "svn+ssh"
           else
-            Addressable::URI.encode_component(
-              Addressable::IDNA.unicode_normalize_kc(
-                Addressable::URI.unencode_component(
-                  self.scheme.strip.downcase)),
+            Addressable::URI.normalize_component(
+              self.scheme.strip.downcase,
               Addressable::URI::CharacterClasses::SCHEME
             )
           end
@@ -602,7 +666,7 @@ module Addressable
     #
     # @return [String] The user component.
     def user
-      return @user
+      return @user ||= nil
     end
 
     ##
@@ -616,9 +680,8 @@ module Addressable
               (!self.password || self.password.strip == "")
             nil
           else
-            Addressable::URI.encode_component(
-              Addressable::IDNA.unicode_normalize_kc(
-                Addressable::URI.unencode_component(self.user.strip)),
+            Addressable::URI.normalize_component(
+              self.user.strip,
               Addressable::URI::CharacterClasses::UNRESERVED
             )
           end
@@ -663,7 +726,7 @@ module Addressable
     #
     # @return [String] The password component.
     def password
-      return @password
+      return @password ||= nil
     end
 
     ##
@@ -677,9 +740,8 @@ module Addressable
               (!self.user || self.user.strip == "")
             nil
           else
-            Addressable::URI.encode_component(
-              Addressable::IDNA.unicode_normalize_kc(
-                Addressable::URI.unencode_component(self.password.strip)),
+            Addressable::URI.normalize_component(
+              self.password.strip,
               Addressable::URI::CharacterClasses::UNRESERVED
             )
           end
@@ -794,7 +856,7 @@ module Addressable
     #
     # @return [String] The host component.
     def host
-      return @host
+      return @host ||= nil
     end
 
     ##
@@ -1035,7 +1097,8 @@ module Addressable
     #
     # @return [String] The path component.
     def path
-      return (@path || "")
+      @path ||= ""
+      return @path
     end
 
     ##
@@ -1044,19 +1107,19 @@ module Addressable
     # @return [String] The path component, normalized.
     def normalized_path
       @normalized_path ||= (begin
-        begin
-          result = Addressable::URI.encode_component(
-            Addressable::IDNA.unicode_normalize_kc(
-              Addressable::URI.unencode_component(self.path.strip)),
-            Addressable::URI::CharacterClasses::PATH
-          )
-        rescue ArgumentError
-          # Likely a malformed UTF-8 character, skip unicode normalization
-          result = Addressable::URI.encode_component(
-            Addressable::URI.unencode_component(self.path.strip),
-            Addressable::URI::CharacterClasses::PATH
-          )
+        if self.scheme == nil && self.path != nil && self.path != "" &&
+            self.path =~ /^(?!\/)[^\/:]*:.*$/
+          # Relative paths with colons in the first segment are ambiguous.
+          self.path.sub!(":", "%2F")
         end
+        # String#split(delimeter, -1) uses the more strict splitting behavior
+        # found by default in Python.
+        result = (self.path.strip.split("/", -1).map do |segment|
+          Addressable::URI.normalize_component(
+            segment,
+            Addressable::URI::CharacterClasses::PCHAR
+          )
+        end).join("/")
         result = self.class.normalize_path(result)
         if result == "" &&
             ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
@@ -1111,7 +1174,7 @@ module Addressable
     #
     # @return [String] The query component.
     def query
-      return @query
+      return @query ||= nil
     end
 
     ##
@@ -1121,19 +1184,10 @@ module Addressable
     def normalized_query
       @normalized_query ||= (begin
         if self.query
-          begin
-            Addressable::URI.encode_component(
-              Addressable::IDNA.unicode_normalize_kc(
-                Addressable::URI.unencode_component(self.query.strip)),
-              Addressable::URI::CharacterClasses::QUERY
-            )
-          rescue ArgumentError
-            # Likely a malformed UTF-8 character, skip unicode normalization
-            Addressable::URI.encode_component(
-              Addressable::URI.unencode_component(self.query.strip),
-              Addressable::URI::CharacterClasses::QUERY
-            )
-          end
+          Addressable::URI.normalize_component(
+            self.query.strip,
+            Addressable::URI::CharacterClasses::QUERY
+          )
         else
           nil
         end
@@ -1304,12 +1358,49 @@ module Addressable
       @uri_string = nil
     end
 
+    ##
+    # The HTTP request URI for this URI.  This is the path and the
+    # query string.
+    #
+    # @return [String] The request URI required for an HTTP request.
+    def request_uri
+      return nil if self.absolute? && self.scheme !~ /^https?$/
+      return (
+        (self.path != "" ? self.path : "/") +
+        (self.query ? "?#{self.query}" : "")
+      )
+    end
+
+    ##
+    # Sets the HTTP request URI for this URI.
+    #
+    # @param [String, #to_str] new_request_uri The new HTTP request URI.
+    def request_uri=(new_request_uri)
+      if !new_request_uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_request_uri.class} into String."
+      end
+      if self.absolute? && self.scheme !~ /^https?$/
+        raise InvalidURIError,
+          "Cannot set an HTTP request URI for a non-HTTP URI."
+      end
+      new_request_uri = new_request_uri.to_str
+      path_component = new_request_uri[/^([^\?]*)\?(?:.*)$/, 1]
+      query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
+      path_component = path_component.to_s
+      path_component = (path_component != "" ? path_component : "/")
+      self.path = path_component
+      self.query = query_component
+
+      # Reset dependant values
+      @uri_string = nil
+    end
+
     ##
     # The fragment component for this URI.
     #
     # @return [String] The fragment component.
     def fragment
-      return @fragment
+      return @fragment ||= nil
     end
 
     ##
@@ -1319,19 +1410,10 @@ module Addressable
     def normalized_fragment
       @normalized_fragment ||= (begin
         if self.fragment
-          begin
-            Addressable::URI.encode_component(
-              Addressable::IDNA.unicode_normalize_kc(
-                Addressable::URI.unencode_component(self.fragment.strip)),
-              Addressable::URI::CharacterClasses::FRAGMENT
-            )
-          rescue ArgumentError
-            # Likely a malformed UTF-8 character, skip unicode normalization
-            Addressable::URI.encode_component(
-              Addressable::URI.unencode_component(self.fragment.strip),
-              Addressable::URI::CharacterClasses::FRAGMENT
-            )
-          end
+          Addressable::URI.normalize_component(
+            self.fragment.strip,
+            Addressable::URI::CharacterClasses::FRAGMENT
+          )
         else
           nil
         end
@@ -1536,36 +1618,38 @@ module Addressable
       end
 
       uri = Addressable::URI.new
-      uri.validation_deferred = true
-      uri.scheme =
-        hash.has_key?(:scheme) ? hash[:scheme] : self.scheme
-      if hash.has_key?(:authority)
-        uri.authority =
-          hash.has_key?(:authority) ? hash[:authority] : self.authority
+      uri.defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        uri.scheme =
+          hash.has_key?(:scheme) ? hash[:scheme] : self.scheme
+        if hash.has_key?(:authority)
+          uri.authority =
+            hash.has_key?(:authority) ? hash[:authority] : self.authority
+        end
+        if hash.has_key?(:userinfo)
+          uri.userinfo =
+            hash.has_key?(:userinfo) ? hash[:userinfo] : self.userinfo
+        end
+        if !hash.has_key?(:userinfo) && !hash.has_key?(:authority)
+          uri.user =
+            hash.has_key?(:user) ? hash[:user] : self.user
+          uri.password =
+            hash.has_key?(:password) ? hash[:password] : self.password
+        end
+        if !hash.has_key?(:authority)
+          uri.host =
+            hash.has_key?(:host) ? hash[:host] : self.host
+          uri.port =
+            hash.has_key?(:port) ? hash[:port] : self.port
+        end
+        uri.path =
+          hash.has_key?(:path) ? hash[:path] : self.path
+        uri.query =
+          hash.has_key?(:query) ? hash[:query] : self.query
+        uri.fragment =
+          hash.has_key?(:fragment) ? hash[:fragment] : self.fragment
       end
-      if hash.has_key?(:userinfo)
-        uri.userinfo =
-          hash.has_key?(:userinfo) ? hash[:userinfo] : self.userinfo
-      end
-      if !hash.has_key?(:userinfo) && !hash.has_key?(:authority)
-        uri.user =
-          hash.has_key?(:user) ? hash[:user] : self.user
-        uri.password =
-          hash.has_key?(:password) ? hash[:password] : self.password
-      end
-      if !hash.has_key?(:authority)
-        uri.host =
-          hash.has_key?(:host) ? hash[:host] : self.host
-        uri.port =
-          hash.has_key?(:port) ? hash[:port] : self.port
-      end
-      uri.path =
-        hash.has_key?(:path) ? hash[:path] : self.path
-      uri.query =
-        hash.has_key?(:query) ? hash[:query] : self.query
-      uri.fragment =
-        hash.has_key?(:fragment) ? hash[:fragment] : self.fragment
-      uri.validation_deferred = false
 
       return uri
     end
@@ -1825,12 +1909,12 @@ module Addressable
           "Invalid component names: #{invalid_components.inspect}."
       end
       duplicated_uri = self.dup
-      duplicated_uri.validation_deferred = true
-      components.each do |component|
-        duplicated_uri.send((component.to_s + "=").to_sym, nil)
+      duplicated_uri.defer_validation do
+        components.each do |component|
+          duplicated_uri.send((component.to_s + "=").to_sym, nil)
+        end
+        duplicated_uri.user = duplicated_uri.normalized_user
       end
-      duplicated_uri.user = duplicated_uri.normalized_user
-      duplicated_uri.validation_deferred = false
       duplicated_uri
     end
 
@@ -1895,27 +1979,20 @@ module Addressable
     end
 
     ##
-    # If URI validation needs to be disabled, this can be set to true.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <tt>true</tt> if validation has been deferred,
-    #   <tt>false</tt> otherwise.
-    def validation_deferred
-      !!@validation_deferred
-    end
-
-    ##
-    # If URI validation needs to be disabled, this can be set to true.
+    # This method allows you to make several changes to a URI simultaneously,
+    # which separately would cause validation errors, but in conjunction,
+    # are valid.  The URI will be revalidated as soon as the entire block has
+    # been executed.
     #
-    # @param [TrueClass, FalseClass] new_validation_deferred
-    #   <tt>true</tt> if validation will be deferred,
-    #   <tt>false</tt> otherwise.
-    def validation_deferred=(new_validation_deferred)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
-      @validation_deferred = new_validation_deferred
-      validate unless @validation_deferred
+    # @param [Proc] block
+    #   A set of operations to perform on a given URI.
+    def defer_validation(&block)
+      raise LocalJumpError, "No block given." unless block
+      @validation_deferred = true
+      block.call()
+      @validation_deferred = false
+      validate
+      return nil
     end
 
   private
@@ -1952,7 +2029,7 @@ module Addressable
     ##
     # Ensures that the URI is valid.
     def validate
-      return if self.validation_deferred
+      return if !!@validation_deferred
       if self.scheme != nil &&
           (self.host == nil || self.host == "") &&
           (self.path == nil || self.path == "")
@@ -1966,6 +2043,11 @@ module Addressable
           raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
         end
       end
+      if self.path != nil && self.path != "" && self.path[0..0] != "/" &&
+          self.authority != nil
+        raise InvalidURIError,
+          "Cannot have a relative path with an authority set: '#{self.to_s}'"
+      end
       return nil
     end
 

data/lib/addressable/version.rb

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

data/spec/addressable/template_spec.rb

@@ -1475,6 +1475,15 @@ describe Addressable::Template, "with a partially expanded template" do
     @initial_template.expand({"one" => "1", "two" => "2"}).should ==
       @partial_template.expand({"two" => "2"})
   end
+
+  it "should raise an error if the template is expanded with bogus values" do
+    (lambda do
+      @initial_template.expand({"one" => Object.new, "two" => Object.new})
+    end).should raise_error(TypeError)
+    (lambda do
+      @partial_template.expand({"two" => Object.new})
+    end).should raise_error(TypeError)
+  end
 end
 
 describe Addressable::Template, "with a partially expanded template" do

data/spec/addressable/uri_spec.rb

@@ -323,6 +323,10 @@ describe Addressable::URI, "when parsed from ''" do
     @uri.path.should == ""
   end
 
+  it "should have a request URI of '/'" do
+    @uri.request_uri.should == "/"
+  end
+
   it "should be considered relative" do
     @uri.should be_relative
   end
@@ -355,6 +359,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "/rfc/rfc1808.txt"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -383,6 +391,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "/rfc/rfc2396.txt"
   end
 
+  it "should have a request URI of '/rfc/rfc2396.txt'" do
+    @uri.request_uri.should == "/rfc/rfc2396.txt"
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -421,6 +433,16 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "/c=GB"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
+  it "should not allow request URI assignment" do
+    (lambda do
+      @uri.request_uri = "/"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
   it "should have a query of 'objectClass?one'" do
     @uri.query.should == "objectClass?one"
   end
@@ -465,6 +487,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "John.Doe@example.com"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -489,6 +515,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "comp.infosystems.www.servers.unix"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -513,6 +543,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "+1-816-555-1212"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -545,6 +579,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "/"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -571,6 +609,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.path.should == "oasis:names:specification:docbook:dtd:xml:4.1.2"
   end
 
+  it "should not have a request URI" do
+    @uri.request_uri.should == nil
+  end
+
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
@@ -639,6 +681,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.query_values.should == nil
   end
 
+  it "should have a request URI of '/'" do
+    @uri.request_uri.should == "/"
+  end
+
   it "should have no fragment" do
     @uri.fragment.should == nil
   end
@@ -826,6 +872,51 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+# Section 5.1.2 of RFC 2616
+describe Addressable::URI, "when parsed from " +
+    "'http://www.w3.org/pub/WWW/TheProject.html'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.w3.org/pub/WWW/TheProject.html")
+  end
+
+  it "should have the correct request URI" do
+    @uri.request_uri.should == "/pub/WWW/TheProject.html"
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html?query?string"
+    @uri.request_uri.should == "/some/where/else.html?query?string"
+    @uri.path.should == "/some/where/else.html"
+    @uri.query.should == "query?string"
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "?x=y"
+    @uri.request_uri.should == "/?x=y"
+    @uri.path.should == "/"
+    @uri.query.should == "x=y"
+  end
+
+  it "should raise an error if the request URI is set to something bogus" do
+    (lambda do
+      @uri.request_uri = 42
+    end).should raise_error(TypeError)
+  end
+
+  it "should correctly convert to a hash" do
+    @uri.to_hash.should == {
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "www.w3.org",
+      :port => nil,
+      :path => "/pub/WWW/TheProject.html",
+      :query => nil,
+      :fragment => nil
+    }
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/'" do
   before do
@@ -871,6 +962,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.to_s.should == "http://example.com/"
   end
 
+  it "should have a request URI of '/'" do
+    @uri.request_uri.should == "/"
+  end
+
   it "should correctly convert to a hash" do
     @uri.to_hash.should == {
       :scheme => "http",
@@ -1021,6 +1116,34 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path%2Fsegment/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path%2Fsegment/")
+  end
+
+  it "should be considered to be in normal form" do
+    @uri.normalize.should be_eql(@uri)
+  end
+
+  it "should be equal to 'http://example.com/path%2Fsegment/'" do
+    @uri.normalize.should be_eql(
+      Addressable::URI.parse("http://example.com/path%2Fsegment/")
+    )
+  end
+
+  it "should not be equal to 'http://example.com/path/segment/'" do
+    @uri.should_not ==
+      Addressable::URI.parse("http://example.com/path/segment/")
+  end
+
+  it "should not be equal to 'http://example.com/path/segment/'" do
+    @uri.normalize.should_not be_eql(
+      Addressable::URI.parse("http://example.com/path/segment/")
+    )
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/?%F6'" do
   before do
@@ -2985,7 +3108,8 @@ describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
   # Section 5.4.1 of RFC 3986
   it "when joined with '#s' should resolve to http://a/b/c/d;p?q#s" do
     (@uri + "#s").to_s.should == "http://a/b/c/d;p?q#s"
-    Addressable::URI.join(@uri.to_s, "#s").to_s.should == "http://a/b/c/d;p?q#s"
+    Addressable::URI.join(@uri.to_s, "#s").to_s.should ==
+      "http://a/b/c/d;p?q#s"
   end
 
   # Section 5.4.1 of RFC 3986
@@ -3082,7 +3206,8 @@ describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
 
   it "when joined with '../.././../g' should resolve to http://a/g" do
     (@uri + "../.././../g").to_s.should == "http://a/g"
-    Addressable::URI.join(@uri.to_s, "../.././../g").to_s.should == "http://a/g"
+    Addressable::URI.join(@uri.to_s, "../.././../g").to_s.should ==
+      "http://a/g"
   end
 
   # Section 5.4.2 of RFC 3986
@@ -3248,25 +3373,25 @@ describe Addressable::URI, "when converting a bogus path" do
   end
 end
 
-describe Addressable::URI, "when given the root directory" do
+describe Addressable::URI, "when given a UNIX root directory" do
   before do
-    if RUBY_PLATFORM =~ /mswin/
-      @path = "C:\\"
-    else
-      @path = "/"
-    end
+    @path = "/"
   end
 
-  if RUBY_PLATFORM =~ /mswin/
-    it "should convert to \'file:///c:/\'" do
-      @uri = Addressable::URI.convert_path(@path)
-      @uri.to_str.should == "file:///c:/"
-    end
-  else
-    it "should convert to \'file:///\'" do
-      @uri = Addressable::URI.convert_path(@path)
-      @uri.to_str.should == "file:///"
-    end
+  it "should convert to \'file:///\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.to_str.should == "file:///"
+  end
+end
+
+describe Addressable::URI, "when given a Windows root directory" do
+  before do
+    @path = "C:\\"
+  end
+
+  it "should convert to \'file:///c:/\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.to_str.should == "file:///c:/"
   end
 end
 
@@ -3390,6 +3515,71 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 end
 
+describe Addressable::URI, "when normalizing a non-String object" do
+  it "should correctly parse anything with a 'to_str' method" do
+    Addressable::URI.normalize_component(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    (lambda do
+      Addressable::URI.normalize_component(42)
+    end).should raise_error(TypeError, "Can't convert Fixnum into String.")
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    (lambda do
+      Addressable::URI.normalize_component("component", 42)
+    end).should raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when normalizing a path with an encoded slash" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.parse("/path%2Fsegment/").normalize.path.should ==
+      "/path%2Fsegment/"
+  end
+end
+
+describe Addressable::URI, "when normalizing a partially encoded string" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component(
+      "partially % encoded%21"
+    ).should == "partially%20%25%20encoded!"
+  end
+
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component(
+      "partially %25 encoded!"
+    ).should == "partially%20%25%20encoded!"
+  end
+end
+
+describe Addressable::URI, "when normalizing a unicode sequence" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component(
+      "/C%CC%A7"
+    ).should == "/%C3%87"
+  end
+
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component(
+      "/%C3%87"
+    ).should == "/%C3%87"
+  end
+end
+
+describe Addressable::URI, "when normalizing a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component("günther").should ==
+      "g%C3%BCnther"
+  end
+
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.normalize_component("g%C3%BCnther").should ==
+      "g%C3%BCnther"
+  end
+end
+
 describe Addressable::URI, "when encoding a multibyte string" do
   it "should result in correct percent encoded sequence" do
     Addressable::URI.encode_component("günther").should == "g%C3%BCnther"
@@ -3675,3 +3865,50 @@ describe Addressable::URI, "when assigning query values" do
     @uri.query.should == "a=a&b[c]&b[d]=d"
   end
 end
+
+describe Addressable::URI, "when assigning path values" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  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.normalize.to_str.should == "acct%2Fbob@sporkmonger.com"
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "/acct:bob@sporkmonger.com"
+    @uri.authority = "example.com"
+    @uri.normalize.to_str.should == "//example.com/acct:bob@sporkmonger.com"
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "acct:bob@sporkmonger.com"
+    @uri.scheme = "something"
+    @uri.normalize.to_str.should == "something:acct:bob@sporkmonger.com"
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+      @uri.path = "acct:bob@sporkmonger.com"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.path = "acct:bob@sporkmonger.com"
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
+      @uri.scheme = "urn"
+    end).should_not raise_error(Addressable::URI::InvalidURIError)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: addressable
 version: !ruby/object:Gem::Version 
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors: 
 - Bob Aman
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-31 00:00:00 -07:00
+date: 2010-04-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency