RubyGems - addressable - Versions diffs - 0.1.0 - Mend

addressable 0.1.0

Files changed (30) hide show

data/CHANGELOG +5 -0
data/LICENSE +20 -0
data/README +3 -0
data/coverage/index.html +261 -0
data/coverage/lib-addressable-uri_rb.html +1723 -0
data/doc/classes/Addressable.html +115 -0
data/doc/classes/Addressable/URI.html +2294 -0
data/doc/classes/Addressable/URI/CharacterClasses.html +173 -0
data/doc/classes/Addressable/URI/IDNA.html +193 -0
data/doc/classes/Addressable/URI/InvalidOptionError.html +117 -0
data/doc/classes/Addressable/URI/InvalidTemplateValue.html +117 -0
data/doc/classes/Addressable/URI/InvalidURIError.html +117 -0
data/doc/created.rid +1 -0
data/doc/files/CHANGELOG.html +111 -0
data/doc/files/LICENSE.html +130 -0
data/doc/files/README.html +110 -0
data/doc/files/lib/addressable/uri_rb.html +109 -0
data/doc/files/lib/addressable/version_rb.html +101 -0
data/doc/fr_class_index.html +33 -0
data/doc/fr_file_index.html +31 -0
data/doc/fr_method_index.html +81 -0
data/doc/index.html +24 -0
data/doc/rdoc-style.css +208 -0
data/lib/addressable/uri.rb +1092 -0
data/lib/addressable/version.rb +32 -0
data/rakefile +251 -0
data/spec/addressable/uri_spec.rb +2278 -0
data/spec/data/rfc3986.txt +3419 -0
data/specdoc/index.html +1094 -0
metadata +101 -0

data/doc/index.html ADDED

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+<!--
+    Addressable -- URI Implementation
+  -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Addressable -- URI Implementation</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+</head>
+<frameset rows="20%, 80%">
+    <frameset cols="25%,35%,45%">
+        <frame src="fr_file_index.html"   title="Files" name="Files" />
+        <frame src="fr_class_index.html"  name="Classes" />
+        <frame src="fr_method_index.html" name="Methods" />
+    </frameset>
+    <frame src="files/README.html" name="docwin" />
+</frameset>
+</html>

data/doc/rdoc-style.css ADDED

@@ -0,0 +1,208 @@
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+/* === Structural elements =================================== */
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+div#index a {
+    margin-left: 0.7em;
+}
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+div#fileHeader {
+    background: #057;
+}
+div#classHeader {
+    background: #048;
+}
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+/* === Classes =================================== */
+table.header-table {
+    color: white;
+    font-size: small;
+}
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+/* --- Context section classes ----------------------- */
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+/* --- Source code sections -------------------- */
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+/* --- Ruby keyword styles --------------------- */
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/addressable/uri.rb ADDED

@@ -0,0 +1,1092 @@
+#--
+# Addressable, Copyright (c) 2006-2007 Bob Aman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+module Addressable
+  # This is an implementation of a URI parser based on RFC 3986.
+  class URI
+    # Raised if something other than a uri is supplied.
+    class InvalidURIError < StandardError
+    end
+    # Raised if an invalid method option is supplied.
+    class InvalidOptionError < StandardError
+    end
+    # Raised if an invalid method option is supplied.
+    class InvalidTemplateValue < StandardError
+    end
+    module CharacterClasses
+      ALPHA = "a-zA-Z"
+      DIGIT = "0-9"
+      GEN_DELIMS = "\\:\\/\\?\\#\\[\\]\\@"
+      SUB_DELIMS = "\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\="
+      RESERVED = GEN_DELIMS + SUB_DELIMS
+      UNRESERVED = ALPHA + DIGIT + "\\-\\.\\_\\~"
+      PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
+      SCHEME = ALPHA + DIGIT + "\\-\\+\\."
+      AUTHORITY = PCHAR
+      PATH = PCHAR + "\\/"
+      QUERY = PCHAR + "\\/\\?"
+      FRAGMENT = PCHAR + "\\/\\?"
+    end
+    # Returns a URI object based on the parsed string.
+    def self.parse(uri_string)
+      return nil if uri_string.nil?
+      # If a URI object is passed, just return itself.
+      return uri_string if uri_string.kind_of?(self)
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      if uri_string.class.name =~ /^URI::/
+        uri_string = uri_string.to_s
+      end
+      uri_regex =
+        /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/
+      scan = uri_string.scan(uri_regex)
+      fragments = scan[0]
+      return nil if fragments.nil?
+      scheme = fragments[1]
+      authority = fragments[3]
+      path = fragments[4]
+      query = fragments[6]
+      fragment = fragments[8]
+      userinfo = nil
+      user = nil
+      password = nil
+      host = nil
+      port = nil
+      if authority != nil
+        userinfo = authority.scan(/^([^\[\]]*)@/).flatten[0]
+        if userinfo != nil
+          user = userinfo.strip.scan(/^([^:]*):?/).flatten[0]
+          password = userinfo.strip.scan(/:(.*)$/).flatten[0]
+        end
+        host = authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+        port = authority.scan(/:([^:@\[\]]*?)$/).flatten[0]
+      end
+      if port.nil? || port == ""
+        port = nil
+      end
+      # WARNING: Not standards-compliant, but follows the theme
+      # of Postel's law:
+      #
+      # Special exception for dealing with the retarded idea of the
+      # feed pseudo-protocol.  Without this exception, the parser will read
+      # the URI as having a blank port number, instead of as having a second
+      # URI embedded within.  This exception translates these broken URIs
+      # and instead treats the inner URI as opaque.
+      if scheme == "feed" && host == "http"
+        userinfo = nil
+        user = nil
+        password = nil
+        host = nil
+        port = nil
+        path = authority + path
+      end
+      return Addressable::URI.new(
+        scheme, user, password, host, port, path, query, fragment)
+    end
+    # Converts a path to a file protocol URI.  If the path supplied is
+    # relative, it will be returned as a relative URI.  If the path supplied
+    # is actually a URI, it will return the parsed URI.
+    def self.convert_path(path)
+      return nil if path.nil?
+      converted_uri = path.strip
+      if converted_uri.length > 0 && converted_uri[0..0] == "/"
+        converted_uri = "file://" + converted_uri
+      end
+      if converted_uri.length > 0 &&
+          converted_uri.scan(/^[a-zA-Z]:[\\\/]/).size > 0
+        converted_uri = "file:///" + converted_uri
+      end
+      converted_uri.gsub!(/^file:\/*/i, "file:///")
+      if converted_uri =~ /^file:/i
+        # Adjust windows-style uris
+        converted_uri.gsub!(/^file:\/\/\/([a-zA-Z])\|/i, 'file:///\1:')
+        converted_uri.gsub!(/\\/, '/')
+        converted_uri = self.parse(converted_uri).normalize
+        if File.exists?(converted_uri.path) &&
+            File.stat(converted_uri.path).directory?
+          converted_uri.path.gsub!(/\/$/, "")
+          converted_uri.path = converted_uri.path + '/'
+        end
+      else
+        converted_uri = self.parse(converted_uri)
+      end
+      return converted_uri
+    end
+    # Expands a URI template into a full URI.
+    #
+    # An optional processor object may be supplied.  The object should
+    # respond to either the :validate or :transform messages or both.
+    # Both the :validate and :transform methods should take two parameters:
+    # :name and :value.  The :validate method should return true or false;
+    # true if the value of the variable is valid, false otherwise.  The
+    # :transform method should return the transformed variable value as a
+    # string.
+    #
+    # An example:
+    #
+    #  class ExampleProcessor
+    #    def self.validate(name, value)
+    #      return !!(value =~ /^[\w ]+$/) if name == "query"
+    #      return true
+    #    end
+    #
+    #    def self.transform(name, value)
+    #      return value.gsub(/ /, "+") if name == "query"
+    #      return value
+    #    end
+    #  end
+    #
+    #  Addressable::URI.expand_template(
+    #    "http://example.com/search/{query}/",
+    #    {"query" => "an example search query"},
+    #    ExampleProcessor).to_s
+    #  => "http://example.com/search/an+example+search+query/"
+    def self.expand_template(pattern, mapping, processor=nil)
+      result = pattern.dup
+      for name, value in mapping
+        transformed_value = value
+        if processor != nil
+          if processor.respond_to?(:validate)
+            if !processor.validate(name, value)
+              raise InvalidTemplateValue,
+                "(#{name}, #{value}) is an invalid template value."
+            end
+          end
+          if processor.respond_to?(:transform)
+            transformed_value = processor.transform(name, value)
+          end
+        end
+        # Handle percent escaping
+        transformed_value = self.encode_segment(transformed_value,
+          Addressable::URI::CharacterClasses::RESERVED +
+          Addressable::URI::CharacterClasses::UNRESERVED)
+        result.gsub!(/\{#{Regexp.escape(name)}\}/, transformed_value)
+      end
+      result.gsub!(/\{[#{CharacterClasses::UNRESERVED}]+\}/, "")
+      return Addressable::URI.parse(result)
+    end
+    # Joins several uris together.
+    def self.join(*uris)
+      uri_objects = uris.collect do |uri|
+        uri.kind_of?(self) ? uri : self.parse(uri.to_s)
+      end
+      result = uri_objects.shift.dup
+      for uri in uri_objects
+        result.merge!(uri)
+      end
+      return result
+    end
+    # Percent encodes a URI segment.  Returns a string.  Takes an optional
+    # character class parameter, which should be specified as a string
+    # containing a regular expression character class (not including the
+    # surrounding square brackets).  The character class parameter defaults
+    # to the reserved plus unreserved character classes specified in
+    # RFC 3986.  Usage of the constants within the CharacterClasses module is
+    # highly recommended when using this method.
+    #
+    # An example:
+    #
+    #  Addressable::URI.escape_segment("simple-example", "b-zB-Z0-9")
+    #  => "simple%2Dex%61mple"
+    def self.encode_segment(segment, character_class=
+        Addressable::URI::CharacterClasses::RESERVED +
+        Addressable::URI::CharacterClasses::UNRESERVED)
+      return nil if segment.nil?
+      return segment.gsub(
+        /[^#{character_class}]/
+      ) do |sequence|
+        ("%" + sequence.unpack('C')[0].to_s(16).upcase)
+      end
+    end
+    # Unencodes any percent encoded characters within a URI segment.
+    # Returns a string.
+    def self.unencode_segment(segment)
+      return nil if segment.nil?
+      return segment.to_s.gsub(/%[0-9a-f]{2}/i) do |sequence|
+        sequence[1..3].to_i(16).chr
+      end
+    end
+    # Percent encodes any special characters in the URI.  This method does
+    # not take IRIs or IDNs into account.
+    def self.encode(uri)
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri.to_s)
+      return Addressable::URI.new(
+        self.encode_segment(uri_object.scheme,
+          Addressable::URI::CharacterClasses::SCHEME),
+        self.encode_segment(uri_object.user,
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        self.encode_segment(uri_object.password,
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        self.encode_segment(uri_object.host,
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        self.encode_segment(uri_object.specified_port,
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        self.encode_segment(uri_object.path,
+          Addressable::URI::CharacterClasses::PATH),
+        self.encode_segment(uri_object.query,
+          Addressable::URI::CharacterClasses::QUERY),
+        self.encode_segment(uri_object.fragment,
+          Addressable::URI::CharacterClasses::FRAGMENT)
+      ).to_s
+    end
+    class << self
+      alias_method :escape, :encode
+    end
+    # Normalizes the encoding of a URI.  Characters within a hostname are
+    # not percent encoded to allow for internationalized domain names.
+    def self.normalized_encode(uri)
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri.to_s)
+      segments = {
+        :scheme => self.unencode_segment(uri_object.scheme),
+        :user => self.unencode_segment(uri_object.user),
+        :password => self.unencode_segment(uri_object.password),
+        :host => self.unencode_segment(uri_object.host),
+        :port => self.unencode_segment(uri_object.specified_port),
+        :path => self.unencode_segment(uri_object.path),
+        :query => self.unencode_segment(uri_object.query),
+        :fragment => self.unencode_segment(uri_object.fragment)
+      }
+      if URI::IDNA.send(:use_libidn?)
+        segments.each do |key, value|
+          if value != nil
+            segments[key] = IDN::Stringprep.nfkc_normalize(value.to_s)
+          end
+        end
+      end
+      return Addressable::URI.new(
+        self.encode_segment(segments[:scheme],
+          Addressable::URI::CharacterClasses::SCHEME),
+        self.encode_segment(segments[:user],
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        self.encode_segment(segments[:password],
+          Addressable::URI::CharacterClasses::AUTHORITY),
+        segments[:host],
+        segments[:port],
+        self.encode_segment(segments[:path],
+          Addressable::URI::CharacterClasses::PATH),
+        self.encode_segment(segments[:query],
+          Addressable::URI::CharacterClasses::QUERY),
+        self.encode_segment(segments[:fragment],
+          Addressable::URI::CharacterClasses::FRAGMENT)
+      ).to_s
+    end
+    # Extracts uris from an arbitrary body of text.
+    def self.extract(text, options={})
+      defaults = {:base => nil, :parse => false}
+      options = defaults.merge(options)
+      raise InvalidOptionError unless (options.keys - defaults.keys).empty?
+      # This regular expression needs to be less forgiving or else it would
+      # match virtually all text.  Which isn't exactly what we're going for.
+      extract_regex = /((([a-z\+]+):)[^ \n\<\>\"\\]+[\w\/])/
+      extracted_uris =
+        text.scan(extract_regex).collect { |match| match[0] }
+      sgml_extract_regex = /<[^>]+href=\"([^\"]+?)\"[^>]*>/
+      sgml_extracted_uris =
+        text.scan(sgml_extract_regex).collect { |match| match[0] }
+      extracted_uris.concat(sgml_extracted_uris - extracted_uris)
+      textile_extract_regex = /\".+?\":([^ ]+\/[^ ]+)[ \,\.\;\:\?\!\<\>\"]/i
+      textile_extracted_uris =
+        text.scan(textile_extract_regex).collect { |match| match[0] }
+      extracted_uris.concat(textile_extracted_uris - extracted_uris)
+      parsed_uris = []
+      base_uri = nil
+      if options[:base] != nil
+        base_uri = options[:base] if options[:base].kind_of?(self)
+        base_uri = self.parse(options[:base].to_s) if base_uri == nil
+      end
+      for uri_string in extracted_uris
+        begin
+          if base_uri == nil
+            parsed_uris << self.parse(uri_string)
+          else
+            parsed_uris << (base_uri + self.parse(uri_string))
+          end
+        rescue Exception
+          nil
+        end
+      end
+      parsed_uris.reject! do |uri|
+        (uri.scheme =~ /T\d+/ ||
+         uri.scheme == "xmlns" ||
+         uri.scheme == "xml" ||
+         uri.scheme == "thr" ||
+         uri.scheme == "this" ||
+         uri.scheme == "float" ||
+         uri.scheme == "user" ||
+         uri.scheme == "username" ||
+         uri.scheme == "out")
+      end
+      if options[:parse]
+        return parsed_uris
+      else
+        return parsed_uris.collect { |uri| uri.to_s }
+      end
+    end
+    # Creates a new uri object from component parts.  Passing nil for
+    # any of these parameters is acceptable.
+    def initialize(scheme, user, password, host, port, path, query, fragment)
+      @scheme = scheme
+      @scheme = nil if @scheme.to_s.strip == ""
+      @user = user
+      @password = password
+      @host = host
+      @specified_port = port.to_s
+      @port = port
+      @port = @port.to_s if @port.kind_of?(Fixnum)
+      if @port != nil && !(@port =~ /^\d+$/)
+        raise InvalidURIError,
+          "Invalid port number: #{@port.inspect}"
+      end
+      @port = @port.to_i
+      @port = nil if @port == 0
+      @path = path
+      @query = query
+      @fragment = fragment
+      validate()
+    end
+    # Returns the scheme (protocol) for this URI.
+    def scheme
+      return @scheme
+    end
+    # Sets the scheme (protocol for this URI.)
+    def scheme=(new_scheme)
+      @scheme = new_scheme
+    end
+    # Returns the user for this URI.
+    def user
+      return @user
+    end
+    # Sets the user for this URI.
+    def user=(new_user)
+      @user = new_user
+      # You can't have a nil user with a non-nil password
+      if @password != nil
+        @user = "" if @user.nil?
+      end
+      # Reset dependant values
+      @userinfo = nil
+      @authority = nil
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+    # Returns the password for this URI.
+    def password
+      return @password
+    end
+    # Sets the password for this URI.
+    def password=(new_password)
+      @password = new_password
+      # You can't have a nil user with a non-nil password
+      if @password != nil
+        @user = "" if @user.nil?
+      end
+      # Reset dependant values
+      @userinfo = nil
+      @authority = nil
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+    # Returns the username and password segment of this URI.
+    def userinfo
+      if !defined?(@userinfo) || @userinfo.nil?
+        current_user = self.user
+        current_password = self.password
+        if current_user == nil && current_password == nil
+          @userinfo = nil
+        elsif current_user != nil && current_password == nil
+          @userinfo = "#{current_user}"
+        elsif current_user != nil && current_password != nil
+          @userinfo = "#{current_user}:#{current_password}"
+        end
+      end
+      return @userinfo
+    end
+    # Sets the username and password segment of this URI.
+    def userinfo=(new_userinfo)
+      new_user = new_userinfo.to_s.strip.scan(/^(.*):/).flatten[0]
+      new_password = new_userinfo.to_s.strip.scan(/:(.*)$/).flatten[0]
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+      # Reset dependant values
+      @authority = nil
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+    # Returns the host for this URI.
+    def host
+      return @host
+    end
+    # Sets the host for this URI.
+    def host=(new_host)
+      @host = new_host
+      # Reset dependant values
+      @authority = nil
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+    # Returns the authority segment of this URI.
+    def authority
+      if !defined?(@authority) || @authority.nil?
+        return nil if self.host.nil?
+        @authority = ""
+        if self.userinfo != nil
+          @authority << "#{self.userinfo}@"
+        end
+        @authority << self.host
+        if self.specified_port != nil
+          @authority << ":#{self.specified_port}"
+        end
+      end
+      return @authority
+    end
+    # Sets the authority segment of this URI.
+    def authority=(new_authority)
+      if new_authority != nil
+        new_userinfo = new_authority.scan(/^([^\[\]]*)@/).flatten[0]
+        if new_userinfo != nil
+          new_user = new_userinfo.strip.scan(/^([^:]*):?/).flatten[0]
+          new_password = new_userinfo.strip.scan(/:(.*)$/).flatten[0]
+        end
+        new_host =
+          new_authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+        new_port =
+          new_authority.scan(/:([^:@\[\]]*?)$/).flatten[0]
+      end
+      new_port = nil if new_port == ""
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+      self.host = new_host
+      # Port reset to allow port normalization
+      @port = nil
+      @specified_port = new_port
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+    # Returns an array of known ip-based schemes.  These schemes typically
+    # use a similar URI form:
+    # //<user>:<password>@<host>:<port>/<url-path>
+    def self.ip_based_schemes
+      return self.scheme_mapping.keys
+    end
+    # Returns a hash of common IP-based schemes and their default port
+    # numbers.  Adding new schemes to this hash, as necessary, will allow
+    # for better URI normalization.
+    def self.scheme_mapping
+      if !defined?(@protocol_mapping) || @protocol_mapping.nil?
+        @protocol_mapping = {
+          "http" => 80,
+          "https" => 443,
+          "ftp" => 21,
+          "tftp" => 69,
+          "ssh" => 22,
+          "svn+ssh" => 22,
+          "telnet" => 23,
+          "nntp" => 119,
+          "gopher" => 70,
+          "wais" => 210,
+          "ldap" => 389,
+          "prospero" => 1525
+        }
+      end
+      return @protocol_mapping
+    end
+    # Returns the port number for this URI.  This method will normalize to the
+    # default port for the URI's scheme if the port isn't explicitly specified
+    # in the URI.
+    def port
+      if @port.to_i == 0
+        if self.scheme.nil?
+          @port = nil
+        else
+          @port = self.class.scheme_mapping[self.scheme.strip.downcase]
+        end
+        return @port
+      else
+        @port = @port.to_i
+        return @port
+      end
+    end
+    # Sets the port for this URI.
+    def port=(new_port)
+      @port = new_port.to_s.to_i
+      @specified_port = @port
+      @authority = nil
+    end
+    # Returns the port number that was actually specified in the URI string.
+    def specified_port
+      port = @specified_port.to_s.to_i
+      if port == 0
+        return nil
+      else
+        return port
+      end
+    end
+    # Returns the path for this URI.
+    def path
+      return @path
+    end
+    # Sets the path for this URI.
+    def path=(new_path)
+      @path = new_path
+    end
+    # Returns the basename, if any, of the file at the path being referenced.
+    # Returns nil if there is no path component.
+    def basename
+      return nil if self.path == nil
+      return File.basename(self.path).gsub(/;[^\/]*$/, "")
+    end
+    # Returns the extension, if any, of the file at the path being referenced.
+    # Returns "" if there is no extension or nil if there is no path
+    # component.
+    def extname
+      return nil if self.path == nil
+      return File.extname(self.basename.gsub(/;[^\/]*$/, ""))
+    end
+    # Returns the query string for this URI.
+    def query
+      return @query
+    end
+    # Sets the query string for this URI.
+    def query=(new_query)
+      @query = new_query
+    end
+    # Returns the fragment for this URI.
+    def fragment
+      return @fragment
+    end
+    # Sets the fragment for this URI.
+    def fragment=(new_fragment)
+      @fragment = new_fragment
+    end
+    # Returns true if the URI uses an IP-based protocol.
+    def ip_based?
+      return false if self.scheme.nil?
+      return self.class.ip_based_schemes.include?(self.scheme.strip.downcase)
+    end
+    # Returns true if this URI is known to be relative.
+    def relative?
+      return self.scheme.nil?
+    end
+    # Returns true if this URI is known to be absolute.
+    def absolute?
+      return !relative?
+    end
+    # Joins two URIs together.
+    def +(uri)
+      if !uri.kind_of?(self.class)
+        uri = URI.parse(uri.to_s)
+      end
+      if uri.to_s == ""
+        return self.dup
+      end
+      joined_scheme = nil
+      joined_user = nil
+      joined_password = nil
+      joined_host = nil
+      joined_port = nil
+      joined_path = nil
+      joined_query = nil
+      joined_fragment = nil
+      # Section 5.2.2 of RFC 3986
+      if uri.scheme != nil
+        joined_scheme = uri.scheme
+        joined_user = uri.user
+        joined_password = uri.password
+        joined_host = uri.host
+        joined_port = uri.specified_port
+        joined_path = self.class.normalize_path(uri.path)
+        joined_query = uri.query
+      else
+        if uri.authority != nil
+          joined_user = uri.user
+          joined_password = uri.password
+          joined_host = uri.host
+          joined_port = uri.specified_port
+          joined_path = self.class.normalize_path(uri.path)
+          joined_query = uri.query
+        else
+          if uri.path == nil || uri.path == ""
+            joined_path = self.path
+            if uri.query != nil
+              joined_query = uri.query
+            else
+              joined_query = self.query
+            end
+          else
+            if uri.path[0..0] == "/"
+              joined_path = self.class.normalize_path(uri.path)
+            else
+              base_path = self.path.nil? ? "" : self.path.dup
+              base_path = self.class.normalize_path(base_path)
+              base_path.gsub!(/\/[^\/]+$/, "/")
+              joined_path = self.class.normalize_path(base_path + uri.path)
+            end
+            joined_query = uri.query
+          end
+          joined_user = self.user
+          joined_password = self.password
+          joined_host = self.host
+          joined_port = self.specified_port
+        end
+        joined_scheme = self.scheme
+      end
+      joined_fragment = uri.fragment
+      return Addressable::URI.new(
+        joined_scheme,
+        joined_user,
+        joined_password,
+        joined_host,
+        joined_port,
+        joined_path,
+        joined_query,
+        joined_fragment
+      )
+    end
+    # Merges two URIs together.
+    def merge(uri)
+      return self + uri
+    end
+    # Destructive form of merge.
+    def merge!(uri)
+      replace_self(self.merge(uri))
+    end
+    # Returns the shortest normalized relative form of this URI that uses the
+    # supplied URI as a base for resolution.  Returns an absolute URI if
+    # necessary.
+    def route_from(uri)
+      uri = uri.kind_of?(self.class) ? uri : self.class.parse(uri.to_s)
+      uri = uri.normalize
+      normalized_self = self.normalize
+      if normalized_self.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
+      end
+      if uri.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
+      end
+      if normalized_self == uri
+        return Addressable::URI.parse("##{normalized_self.fragment}")
+      end
+      segments = normalized_self.to_h
+      if normalized_self.scheme == uri.scheme
+        segments[:scheme] = nil
+        if normalized_self.authority == uri.authority
+          segments[:user] = nil
+          segments[:password] = nil
+          segments[:host] = nil
+          segments[:port] = nil
+          if normalized_self.path == uri.path
+            segments[:path] = nil
+            if normalized_self.query == uri.query
+              segments[:query] = nil
+            end
+          end
+        end
+      end
+      # Avoid network-path references.
+      if segments[:scheme] == nil && segments[:host] != nil
+        segments[:scheme] = normalized_self.scheme
+      end
+      return Addressable::URI.new(
+        segments[:scheme],
+        segments[:user],
+        segments[:password],
+        segments[:host],
+        segments[:port],
+        segments[:path],
+        segments[:query],
+        segments[:fragment]
+      )
+    end
+    # Returns the shortest normalized relative form of the supplied URI that
+    # uses this URI as a base for resolution.  Returns an absolute URI if
+    # necessary.
+    def route_to(uri)
+      uri = uri.kind_of?(self.class) ? uri : self.class.parse(uri.to_s)
+      return uri.route_from(self)
+    end
+    # Returns a normalized URI object.
+    #
+    # NOTE: This method does not attempt to fully conform to specifications.
+    # It exists largely to correct other people's failures to read the
+    # specifications, and also to deal with caching issues since several
+    # different URIs may represent the same resource and should not be
+    # cached multiple times.
+    def normalize
+      normalized_scheme = nil
+      normalized_scheme = self.scheme.strip.downcase if self.scheme != nil
+      normalized_scheme = "svn+ssh" if normalized_scheme == "ssh+svn"
+      if normalized_scheme == "feed"
+        if self.to_s =~ /^feed:\/*http:\/*/
+          return self.class.parse(
+            self.to_s.scan(/^feed:\/*(http:\/*.*)/).flatten[0]).normalize
+        end
+      end
+      normalized_user = nil
+      normalized_user = self.user.strip if self.user != nil
+      normalized_password = nil
+      normalized_password = self.password.strip if self.password != nil
+      normalized_host = nil
+      normalized_host = self.host.strip.downcase if self.host != nil
+      if normalized_host != nil
+        begin
+          normalized_host = URI::IDNA.to_ascii(normalized_host)
+        rescue Exception
+          nil
+        end
+      end
+      normalized_port = self.port
+      if self.class.scheme_mapping[normalized_scheme] == normalized_port
+        normalized_port = nil
+      end
+      normalized_path = nil
+      normalized_path = self.path.strip if self.path != nil
+      if normalized_path == nil &&
+          normalized_scheme != nil &&
+          normalized_host != nil
+        normalized_path = "/"
+      end
+      if normalized_path != nil
+        normalized_path = self.class.normalize_path(normalized_path)
+      end
+      if normalized_path == ""
+        if ["http", "https", "ftp", "tftp"].include?(normalized_scheme)
+          normalized_path = "/"
+        end
+      end
+      normalized_query = nil
+      normalized_query = self.query.strip if self.query != nil
+      normalized_fragment = nil
+      normalized_fragment = self.fragment.strip if self.fragment != nil
+      return Addressable::URI.parse(
+        Addressable::URI.normalized_encode(Addressable::URI.new(
+          normalized_scheme,
+          normalized_user,
+          normalized_password,
+          normalized_host,
+          normalized_port,
+          normalized_path,
+          normalized_query,
+          normalized_fragment
+        )))
+    end
+    # Destructively normalizes this URI object.
+    def normalize!
+      replace_self(self.normalize)
+    end
+    # Creates a URI suitable for display to users.  If semantic attacks are
+    # likely, the application should try to detect these and warn the user.
+    # See RFC 3986 section 7.6 for more information.
+    def display_uri
+      display_uri = self.normalize
+      begin
+        display_uri.instance_variable_set("@host",
+          URI::IDNA.to_unicode(display_uri.host))
+      rescue Exception
+        nil
+      end
+      return display_uri
+    end
+    # Returns true if the URI objects are equal.  This method normalizes
+    # both URIs before doing the comparison, and allows comparison against
+    # strings.
+    def ===(uri)
+      uri_string = nil
+      if uri.respond_to?(:normalize)
+        uri_string = uri.normalize.to_s
+      else
+        begin
+          uri_string = URI.parse(uri.to_s).normalize.to_s
+        rescue Exception
+          return false
+        end
+      end
+      return self.normalize.to_s == uri_string
+    end
+    # Returns true if the URI objects are equal.  This method normalizes
+    # both URIs before doing the comparison.
+    def ==(uri)
+      return false unless uri.kind_of?(self.class)
+      return self.normalize.to_s == uri.normalize.to_s
+    end
+    # Returns true if the URI objects are equal.  This method does NOT
+    # normalize either URI before doing the comparison.
+    def eql?(uri)
+      return false unless uri.kind_of?(self.class)
+      return self.to_s == uri.to_s
+    end
+    # Clones the URI object.
+    def dup
+      duplicated_scheme = nil
+      duplicated_scheme = self.scheme.dup if self.scheme != nil
+      duplicated_user = nil
+      duplicated_user = self.user.dup if self.user != nil
+      duplicated_password = nil
+      duplicated_password = self.password.dup if self.password != nil
+      duplicated_host = nil
+      duplicated_host = self.host.dup if self.host != nil
+      duplicated_port = self.port
+      duplicated_path = nil
+      duplicated_path = self.path.dup if self.path != nil
+      duplicated_query = nil
+      duplicated_query = self.query.dup if self.query != nil
+      duplicated_fragment = nil
+      duplicated_fragment = self.fragment.dup if self.fragment != nil
+      duplicated_uri = Addressable::URI.new(
+        duplicated_scheme,
+        duplicated_user,
+        duplicated_password,
+        duplicated_host,
+        duplicated_port,
+        duplicated_path,
+        duplicated_query,
+        duplicated_fragment
+      )
+      @specified_port = nil if !defined?(@specified_port)
+      duplicated_uri.instance_variable_set("@specified_port", @specified_port)
+      return duplicated_uri
+    end
+    # Returns the assembled URI as a string.
+    def to_s
+      uri_string = ""
+      uri_string << "#{self.scheme}:" if self.scheme != nil
+      uri_string << "//#{self.authority}" if self.authority != nil
+      uri_string << self.path.to_s
+      uri_string << "?#{self.query}" if self.query != nil
+      uri_string << "##{self.fragment}" if self.fragment != nil
+      return uri_string
+    end
+    # Returns a Hash of the URI segments.
+    def to_h
+      return {
+        :scheme => self.scheme,
+        :user => self.user,
+        :password => self.password,
+        :host => self.host,
+        :port => self.specified_port,
+        :path => self.path,
+        :query => self.query,
+        :fragment => self.fragment
+      }
+    end
+    # Returns a string representation of the URI object's state.
+    def inspect
+      sprintf("#<%s:%#0x URI:%s>", self.class.to_s, self.object_id, self.to_s)
+    end
+    # This module handles internationalized domain names.  When Ruby has an
+    # implementation of nameprep, stringprep, punycode, etc, this
+    # module should contain an actual implementation of IDNA instead of
+    # returning nil if libidn can't be used.
+    module IDNA
+      # Returns the ascii representation of the label.
+      def self.to_ascii(label)
+        return nil if label.nil?
+        if self.use_libidn?
+          return IDN::Idna.toASCII(label)
+        else
+          raise NotImplementedError,
+            "There is no available pure-ruby implementation.  " +
+            "Install libidn bindings."
+        end
+      end
+      # Returns the unicode representation of the label.
+      def self.to_unicode(label)
+        return nil if label.nil?
+        if self.use_libidn?
+          return IDN::Idna.toUnicode(label)
+        else
+          raise NotImplementedError,
+            "There is no available pure-ruby implementation.  " +
+            "Install libidn bindings."
+        end
+      end
+    private
+      # Determines if the libidn bindings are available and able to be used.
+      def self.use_libidn?
+        if !defined?(@use_libidn) || @use_libidn.nil?
+          begin
+            require 'rubygems'
+          rescue LoadError
+            nil
+          end
+          begin
+            require 'idn'
+          rescue LoadError
+            nil
+          end
+          @use_libidn = !!(defined?(IDN::Idna))
+        end
+        return @use_libidn
+      end
+    end
+  private
+    # Resolves paths to their simplest form.
+    def self.normalize_path(path)
+      return nil if path.nil?
+      normalized_path = path.dup
+      previous_state = normalized_path.dup
+      begin
+        previous_state = normalized_path.dup
+        normalized_path.gsub!(/\/\.\//, "/")
+        normalized_path.gsub!(/\/\.$/, "/")
+        parent = normalized_path.scan(/\/([^\/]+)\/\.\.\//).flatten[0]
+        if parent != "." && parent != ".."
+          normalized_path.gsub!(/\/#{parent}\/\.\.\//, "/")
+        end
+        parent = normalized_path.scan(/\/([^\/]+)\/\.\.$/).flatten[0]
+        if parent != "." && parent != ".."
+          normalized_path.gsub!(/\/#{parent}\/\.\.$/, "/")
+        end
+        normalized_path.gsub!(/^\.\.?\/?/, "")
+        normalized_path.gsub!(/^\/\.\.?\//, "/")
+      end until previous_state == normalized_path
+      return normalized_path
+    end
+    # Ensures that the URI is valid.
+    def validate
+      if self.scheme == nil && self.user == nil && self.password == nil &&
+          self.host == nil && self.port == nil && self.path == nil &&
+          self.query == nil && self.fragment == nil
+        raise InvalidURIError, "All segments were nil."
+      end
+      if self.scheme != nil &&
+          (self.host == nil || self.host == "") &&
+          (self.path == nil || self.path == "")
+        raise InvalidURIError,
+          "Absolute URI missing hierarchical segment."
+      end
+    end
+    # Replaces the internal state of self with the specified URI's state.
+    # Used in destructive operations to avoid massive code repetition.
+    def replace_self(uri)
+      # Reset dependant values
+      @userinfo = nil
+      @authority = nil
+      @scheme = uri.scheme
+      @user = uri.user
+      @password = uri.password
+      @host = uri.host
+      @specified_port = uri.instance_variable_get("@specified_port")
+      @port = @specified_port.to_s.to_i
+      @path = uri.path
+      @query = uri.query
+      @fragment = uri.fragment
+      return self
+    end
+  end
+end