rdf 1.1.0.p0 → 1.1.0.p1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWZmZWNkYTZjMTY1NjlmMjAyMzM3MmE2ODVmZmUwZDY0NDE3NDkzMQ==
+    MmJiOTYzMzMzOTA3MWUwZGU0OWM2YjI2OTNiNTkwMGI0NmFhOTdmMw==
   data.tar.gz: !binary |-
-    MGMzZWNkNzhjYmZlOTk4NjkyY2VhNjEzOTgyMjRmY2U1MjRiMjA4Zg==
+    NmMzMGE3OGQ0ZWY0MjNhMzc3NDk3MTdhOWRiNWY4ZTBkM2YwMzliZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    M2M3OTczM2MwNjRkZWI4ZjgwNWUxZWY4MTJmNjAxMzY2NjUyYTAxMTI5NDlk
-    NDVkYWI0NTE5YmZhYmQ4NDI3ZTlhNzI4NmYxNWZiOTA0NmU5ZDhlYzFlN2M4
-    MTZlOWM1Yzk2Njg4OTYxMjgwY2E3NTlhZDJhZmU0YWY5NzIyYTE=
+    MGM3NzBiNDdkN2MxNGRjMTIyMzRhMmYyZWVkZDdmMGM0OTcxNjEwYTk4NmFh
+    YTQzODMzYjZhYzNkOTY0ZGU1ZWRjMjUwNGQ0YmZjMTcwYjY2ZjU2NmM1OGY5
+    NzM2ZmFiZWNhNTRmNzVmYjQzOTJhNmRmMWJhMzQzNzNmMjAwNzE=
   data.tar.gz: !binary |-
-    NTE0M2E3OTQyYjgyMTgwOGEyYzI3ZTZlODA0MzQ2ZmIyMDEzYWU0OWFjZDhm
-    MDc5NmE3OTJiMTc1NDI1ZTg5NjhlYmU1MzlhMjNhYTdjM2Q0ZDA3MzM4ZmMy
-    MjA4MGNlOGM1YjNlM2UxODlhMTk0ZTYyYWM5NjBkMjJhNThiMjQ=
+    YzRkYmU0YzYzYzVlZTBhOTAxNDYzMmNhYzg5ZTU1ZGZjNjEwN2E5YzdmZTc4
+    OTRhZTQyOGI3ZDhhOGZhNWJhM2ZmOGVmZDBkNGVkNmRiMjdjNmJjMmU5Njky
+    ZTcxMGJlZWU2NDJhNjhkYWE5ZTJjZmYxNzc1NjZjNjE1ZjMxNDU=

data/README

@@ -25,7 +25,7 @@ This is a pure-Ruby library for working with [Resource Description Framework
   not modify any of Ruby's core classes or standard library.
 * Based entirely on Ruby's autoloading, meaning that you can generally make
   use of any one part of the library without needing to load up the rest.
-* Compatible with Ruby Ruby 1.9.x, Ruby 2.0, Rubinius and JRuby 1.7+.
+* Compatible with Ruby Ruby 1.9.2, Ruby 2.0, Rubinius and JRuby 1.7+.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Performs auto-detection of input to select appropriate Reader class if one
   cannot be determined from file characteristics.
@@ -117,7 +117,7 @@ to use when loading a file. The specific format to use can be forced using, e.g.
 option where the specific format symbol is determined by the available readers. Both also use
 MimeType or file extension, where available.
 
-    require 'linkeddata'
+    require 'rdf/nquads'
     
     graph = RDF::Graph.load("http://ruby-rdf.github.com/rdf/etc/doap.nq", :format => :nquads)
 
@@ -151,7 +151,10 @@ appropriate writer to use.
 
 A specific sub-type of Writer can also be invoked directly:
 
-    graph.dump(:nquads)
+    require 'rdf/nquads'
+
+    repo = RDF::Repository.new << RDF::Statement.new(:hello, RDF::DC.title, "Hello, world!", :context => RDF::URI("context"))
+    File.open("hello.nq", "w") {|f| f << repo.dump(:nquads)}
 
 ## Reader/Writer convenience methods
 {RDF::Enumerable} implements `to_{format}` for each available instance of {RDF::Reader}.
@@ -331,15 +334,14 @@ from BNode identity (i.e., they each entail the other)
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.9.x)
-* [Addressable](http://rubygems.org/gems/addressable) (>= 2.2.0)
+* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
 
 ## Installation
 
 The recommended installation method is via [RubyGems](http://rubygems.org/).
 To install the latest official release of RDF.rb, do:
 
-    % [sudo] gem install rdf             # Ruby 1.9.x+
+    % [sudo] gem install rdf             # Ruby 1.9.2+
 
 ## Download
 

data/VERSION

@@ -1 +1 @@
-1.1.0.p0
+1.1.0.p1

data/lib/rdf.rb

@@ -5,6 +5,7 @@ require 'bigdecimal'
 require 'date'
 require 'time'
 
+require 'rdf/version'
 require 'rdf/version'
 
 module RDF
@@ -64,6 +65,7 @@ module RDF
   ##
   # Alias for `RDF::Resource.new`.
   #
+  # @param (see RDF::Resource#initialize)
   # @return [RDF::Resource]
   def self.Resource(*args, &block)
     Resource.new(*args, &block)
@@ -72,6 +74,7 @@ module RDF
   ##
   # Alias for `RDF::Node.new`.
   #
+  # @param (see RDF::Node#initialize)
   # @return [RDF::Node]
   def self.Node(*args, &block)
     Node.new(*args, &block)
@@ -80,13 +83,7 @@ module RDF
   ##
   # Alias for `RDF::URI.new`.
   #
-  # @overload URI(uri)
-  #   @param  [URI, String, #to_s]    uri
-  #
-  # @overload URI(options = {})
-  #   @param  [Hash{Symbol => Object}] options
-  #     passed to `Addressable::URI.new`
-  #
+  # @param (see RDF::URI#initialize)
   # @return [RDF::URI]
   def self.URI(*args, &block)
     case uri = args.first
@@ -101,6 +98,7 @@ module RDF
   ##
   # Alias for `RDF::Literal.new`.
   #
+  # @param (see RDF::Literal#initialize)
   # @return [RDF::Literal]
   def self.Literal(*args, &block)
     case literal = args.first
@@ -112,6 +110,7 @@ module RDF
   ##
   # Alias for `RDF::Graph.new`.
   #
+  # @param (see RDF::Graph#initialize)
   # @return [RDF::Graph]
   def self.Graph(*args, &block)
     Graph.new(*args, &block)
@@ -120,6 +119,7 @@ module RDF
   ##
   # Alias for `RDF::Statement.new`.
   #
+  # @param (see RDF::Statement#initialize)
   # @return [RDF::Statement]
   def self.Statement(*args, &block)
     Statement.new(*args, &block)
@@ -128,7 +128,7 @@ module RDF
   ##
   # Alias for `RDF::Vocabulary.create`.
   #
-  # @param  [String] uri
+  # @param (see RDF::Vocabulary#initialize)
   # @return [Class]
   def self.Vocabulary(uri)
     Vocabulary.create(uri)

data/lib/rdf/mixin/mutable.rb

@@ -106,6 +106,9 @@ module RDF
 
     ##
     # Deletes RDF statements from `self`.
+    # If any statement contains a {Query::Variable}, it is
+    # considered to be a pattern, and used to query
+    # self to find matching statements to delete.
     #
     # @param  [Enumerable<RDF::Statement>] statements
     # @raise  [TypeError] if `self` is immutable
@@ -118,7 +121,7 @@ module RDF
           when value.respond_to?(:each_statement)
             delete_statements(value)
             nil
-          when (statement = Statement.from(value)).valid?
+          when (statement = Statement.from(value)).constant?
             statement
           else
             delete_statements(query(value))

data/lib/rdf/model/literal.rb

@@ -78,7 +78,6 @@ module RDF
     require 'rdf/model/literal/datetime'
     require 'rdf/model/literal/time'
     require 'rdf/model/literal/token'
-    require 'rdf/model/literal/xml'
 
     include RDF::Term
 
@@ -132,8 +131,14 @@ module RDF
     # depending on if there is language
     #
     # @param  [Object] value
-    # @option options [Symbol] :language (nil)
-    # @option options [URI]    :datatype (nil)
+    # @option options [Symbol]  :language (nil)
+    # @option options [String]  :lexical (nil)
+    #   Supplied lexical representation of this literal,
+    #   otherwise it comes from transforming `value` to a string form
+    #   See {#to_s}.
+    # @option options [URI]     :datatype (nil)
+    # @option options [Boolean] :validate (false)
+    # @option options [Boolean] :canonicalize (false)
     # @raise [ArgumentError]
     #   if there is a language and datatype is no rdf:langString
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal

data/lib/rdf/model/statement.rb

@@ -105,6 +105,18 @@ module RDF
       true
     end
 
+    ##
+    # Returns `true` if any element of the statement is not a
+    # URI, Node or Literal.
+    #
+    # @return [Boolean]
+    def variable?
+      !(has_subject?    && subject.resource? && 
+        has_predicate?  && predicate.resource? &&
+        has_object?     && (object.resource? || object.literal?) &&
+        (has_context?    ? context.resource? : true ))
+    end
+
     ##
     # @return [Boolean]
     def invalid?

data/lib/rdf/model/term.rb

@@ -56,15 +56,6 @@ module RDF
       super
     end
 
-    ##
-    # Returns `true` if this term is constant.
-    #
-    # @return [Boolean] `true` or `false`
-    # @see    #variable?
-    def constant?
-      !(variable?)
-    end
-
     ##
     # Returns a base representation of `self`.
     #

data/lib/rdf/model/uri.rb

@@ -1,12 +1,11 @@
-require 'addressable/uri'
+# coding: utf-8
+require 'uri'
 
 module RDF
   ##
   # A Uniform Resource Identifier (URI).
   # Also compatible with International Resource Identifier (IRI)
   #
-  # `RDF::URI` supports all the instance methods of `Addressable::URI`.
-  #
   # @example Creating a URI reference (1)
   #   uri = RDF::URI.new("http://rdf.rubyforge.org/")
   #
@@ -45,7 +44,7 @@ module RDF
     SCHEME = Regexp.compile("[A-za-z](?:[A-Za-z0-9+-\.])*").freeze
     PORT = Regexp.compile("[0-9]*").freeze
     IP_literal = Regexp.compile("\\[[0-9A-Fa-f:\\.]*\\]").freeze  # Simplified, no IPvFuture
-    PCT_ENCODED = Regexp.compile("%[0-9A-Fa-f]{2}").freeze
+    PCT_ENCODED = Regexp.compile("%[0-9A-Fa-f][0-9A-Fa-f]").freeze
     GEN_DELIMS = Regexp.compile("[:/\\?\\#\\[\\]@]").freeze
     SUB_DELIMS = Regexp.compile("[!\\$&'\\(\\)\\*\\+,;=]").freeze
     RESERVED = Regexp.compile("(?:#{GEN_DELIMS}|#{SUB_DELIMS})").freeze
@@ -79,7 +78,36 @@ module RDF
 
     IHIER_PART = Regexp.compile("(?:(?://#{IAUTHORITY}#{IPATH_ABEMPTY})|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_ROOTLESS})|(?:#{IPATH_EMPTY}))").freeze
     IRI = Regexp.compile("^#{SCHEME}:(?:#{IHIER_PART})(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$").freeze
-    
+
+    # Split an IRI into it's component parts
+    IRI_PARTS = /^(?:([^:\/?#]+):)?(?:\/\/([^\/?#]*))?([^?#]*)(\?[^#]*)?(#.*)?$/
+
+    # Remove dot expressions regular expressions
+    RDS_2A = /^\.?\.\/(.*)$/.freeze
+    RDS_2B1 = /^\/\.$/.freeze
+    RDS_2B2 = /^(?:\/\.\/)(.*)$/.freeze
+    RDS_2C1 = /^\/\.\.$/.freeze
+    RDS_2C2 = /^(?:\/\.\.\/)(.*)$/.freeze
+    RDS_2D  = /^\.\.?$/.freeze
+    RDS_2E = /^(\/?[^\/]*)(\/?.*)?$/.freeze
+
+    # Remove port, if it is standard for the scheme when normalizing
+    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
+    }
+
     ##
     # @return [RDF::Util::Cache]
     # @private
@@ -103,7 +131,7 @@ module RDF
     # object can't be returned for some reason, this method will fall back
     # to returning a freshly-allocated one.
     #
-    # @param  [String, #to_s] str
+    # @param (see #initialize)
     # @return [RDF::URI] an immutable, frozen URI object
     def self.intern(str)
       (cache[str = str.to_s] ||= self.new(str)).freeze
@@ -113,7 +141,8 @@ module RDF
     # Creates a new `RDF::URI` instance based on the given `uri` string.
     #
     # This is just an alias for {RDF::URI#initialize} for compatibity
-    # with `Addressable::URI.parse`.
+    # with `Addressable::URI.parse`. Actual parsing is defered
+    # until {#object} is accessed.
     #
     # @param  [String, #to_s] str
     # @return [RDF::URI]
@@ -122,20 +151,97 @@ module RDF
     end
 
     ##
-    # @overload URI.new(uri)
-    #   @param  [RDF::URI, String, #to_s] uri
+    # Resolve paths to their simplest form.
     #
-    # @overload URI.new(options = {})
+    # TODO: This process is correct, but overly iterative. It could be better done with a single regexp which handled most of the segment collapses all at once. Parent segments would still require iteration.
+    #
+    # @param [String] path
+    # @return [String] normalized path
+    # @see http://tools.ietf.org/html/rfc3986#section-5.2.4
+    def self.normalize_path(path)
+      output, input = "", path.to_s
+      if input.encoding != Encoding::ASCII_8BIT
+        input = input.dup if input.frozen?
+        input = input.force_encoding(Encoding::ASCII_8BIT)
+      end
+      until input.empty?
+        if input.match(RDS_2A)
+          # If the input buffer begins with a prefix of "../" or "./", then remove that prefix from the input buffer; otherwise,
+          input = $1
+        elsif input.match(RDS_2B1) || input.match(RDS_2B2)
+          # if the input buffer begins with a prefix of "/./" or "/.", where "." is a complete path segment, then replace that prefix with "/" in the input buffer; otherwise,
+          input = "/#{$1}"
+        elsif input.match(RDS_2C1) || input.match(RDS_2C2)
+          # if the input buffer begins with a prefix of "/../" or "/..", where ".." is a complete path segment, then replace that prefix with "/" in the input buffer
+          input = "/#{$1}"
+
+          #  and remove the last segment and its preceding "/" (if any) from the output buffer; otherwise,
+          output.sub!(/\/?[^\/]*$/, '')
+        elsif input.match(RDS_2D)
+          # if the input buffer consists only of "." or "..", then remove that from the input buffer; otherwise,
+          input = ""
+        elsif input.match(RDS_2E)
+          # move the first path segment in the input buffer to the end of the output buffer, including the initial "/" character (if any) and any subsequent characters up to, but not including, the next "/" character or the end of the input buffer.end
+          seg, input = $1, $2
+          output << seg
+        end
+      end
+
+      output.sub(/\/+/, '/').force_encoding(Encoding::UTF_8)
+    end
+
+    ##
+    # @overload URI(uri, options = {})
+    #   @param  [URI, String, #to_s]    uri
     #   @param  [Hash{Symbol => Object}] options
-    def initialize(uri_or_options)
-      case uri_or_options
-        when Hash
-          @uri = Addressable::URI.new(uri_or_options)
-        when Addressable::URI
-          @uri = uri_or_options
-        else
-          @uri = Addressable::URI.parse(uri_or_options.to_s)
+    #   @option options [Boolean] :validate (false)
+    #   @option options [Boolean] :canonicalize (false)
+    #
+    # @overload URI(options = {})
+    #   @param  [Hash{Symbol => Object}] options
+    #   @option options [Boolean] :validate (false)
+    #   @option options [Boolean] :canonicalize (false)
+    #   @option [String, #to_s] :scheme The scheme component.
+    #   @option [String, #to_s] :user The user component.
+    #   @option [String, #to_s] :password The password component.
+    #   @option [String, #to_s] :userinfo
+    #     The userinfo component. If this is supplied, the user and password
+    #     components must be omitted.
+    #   @option [String, #to_s] :host The host component.
+    #   @option [String, #to_s] :port The port component.
+    #   @option [String, #to_s] :authority
+    #     The authority component. If this is supplied, the user, password,
+    #     userinfo, host, and port components must be omitted.
+    #   @option [String, #to_s] :path The path component.
+    #   @option [String, #to_s] :query The query component.
+    #   @option [String, #to_s] :fragment The fragment component.
+    def initialize(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      uri = args.first
+      case uri
+      when Hash
+        %w(
+          scheme
+          user password userinfo
+          host port authority
+          path query fragment
+        ).map(&:to_sym).each do |meth|
+          if uri.has_key?(meth)
+            self.send("#{meth}=".to_sym, uri[meth])
+          else
+            self.send(meth)
+          end
+        end
+      else
+        @value = uri.to_s
+        if @value.encoding != Encoding::UTF_8
+          @value = @value.dup if @value.frozen?
+          @value.force_encoding(Encoding::UTF_8)
+        end
       end
+
+      validate!     if options[:validate]
+      canonicalize! if options[:canonicalize]
     end
 
     ##
@@ -157,7 +263,7 @@ module RDF
     # @see    http://en.wikipedia.org/wiki/Uniform_Resource_Name
     # @since  0.2.0
     def urn?
-      self.start_with?('urn:')
+      @object ? @object[:scheme] == 'urn' : start_with?('urn:')
     end
 
     ##
@@ -173,6 +279,16 @@ module RDF
       !urn?
     end
 
+    ##
+    # A URI is absolute when it has a scheme
+    # @return [Boolean] `true` or `false`
+    def absolute?; !scheme.nil?; end
+
+    ##
+    # A URI is relative when it does not have a scheme
+    # @return [Boolean] `true` or `false`
+    def relative?; !absolute?; end
+
     ##
     # Returns the string length of this URI.
     #
@@ -187,14 +303,13 @@ module RDF
     alias_method :size, :length
 
     ##
-    # Determine if the URI is avalid according to RFC3987
+    # Determine if the URI is a valid according to RFC3987
     #
     # @return [Boolean] `true` or `false`
     # @since 0.3.9
     def valid?
-      # As Addressable::URI does not perform adequate validation, validate
-      # relative to RFC3987
-      to_s.match(RDF::URI::IRI) || to_s.match(RDF::URI::IRELATIVE_REF) || false
+      # Validate relative to RFC3987
+      to_s.match(RDF::URI::IRI) || false
     end
 
     ##
@@ -217,6 +332,7 @@ module RDF
     def canonicalize
       self.dup.canonicalize!
     end
+    alias_method :normalize, :canonicalize
 
     ##
     # Converts this URI into its canonical lexical representation.
@@ -224,9 +340,17 @@ module RDF
     # @return [RDF::URI] `self`
     # @since  0.3.0
     def canonicalize!
-      @uri.normalize!
+      @object = {
+        :scheme => normalized_scheme,
+        :authority => normalized_authority,
+        :path => normalized_path,
+        :query => normalized_query,
+        :fragment => normalized_fragment
+      }
+      @value = nil
       self
     end
+    alias_method :normalize!, :canonicalize!
 
     ##
     # Joins several URIs together.
@@ -250,12 +374,40 @@ module RDF
     # @see RDF::URI#+
     # @param  [Array<String, RDF::URI, #to_s>] uris
     # @return [RDF::URI]
+    # @see http://tools.ietf.org/html/rfc3986#section-5.2.2
+    # @see http://tools.ietf.org/html/rfc3986#section-5.2.3
     def join(*uris)
-      result = @uri.dup
+      joined_parts = object.dup.delete_if {|k, v| [:user, :password, :host, :port].include?(k)}
+
       uris.each do |uri|
-        result = result.join(uri)
+        uri = RDF::URI.new(uri) unless uri.is_a?(RDF::URI)
+        next if uri.to_s.empty? # Don't mess with base URI
+
+        case
+        when uri.scheme
+          joined_parts = uri.object.merge(:path => self.class.normalize_path(uri.path))
+        when uri.authority
+          joined_parts[:authority] = uri.authority
+          joined_parts[:path] = self.class.normalize_path(uri.path)
+          joined_parts[:query] = uri.query
+        when uri.path.to_s.empty?
+          joined_parts[:query] = uri.query if uri.query
+        when uri.path[0,1] == '/'
+          joined_parts[:path] = self.class.normalize_path(uri.path)
+          joined_parts[:query] = uri.query
+        else
+          base_path = self.class.normalize_path(path.to_s)
+
+          # Merge path segments from section 5.2.3
+          base_path.sub!(/\/[^\/]*$/, '/')
+          joined_parts[:path] = self.class.normalize_path(base_path + uri.path)
+          joined_parts[:query] = uri.query
+        end
+        joined_parts[:fragment] = uri.fragment
       end
-      self.class.new(result)
+
+      # Return joined URI
+      RDF::URI.new(joined_parts)
     end
 
     ##
@@ -281,6 +433,7 @@ module RDF
     #
     # @param [Any] fragment A URI fragment to be appended to this URI
     # @return [RDF::URI]
+    # @raise  [ArgumentError] if the URI is invalid
     # @see RDF::URI#+
     # @see RDF::URI#join
     # @see <http://tools.ietf.org/html/rfc3986#section-5.2>
@@ -303,22 +456,34 @@ module RDF
       if urn?
         RDF::URI.intern(to_s.sub(/:+$/,'') + ':' + fragment.to_s.sub(/^:+/,''))
       else # !urn?
-        case to_s[-1].chr
-        when '#'
-          case fragment.to_s[0].chr
-          when '/' then # Base ending with '#', fragment beginning with '/'.  The fragment wins, we use '/'.
-            RDF::URI.intern(to_s.sub(/#+$/,'') + '/' + fragment.to_s.sub(/^\/+/,''))
+        res = self.dup
+        if res.fragment
+          case fragment.to_s[0,1]
+          when '/'
+            # Base with a fragment, fragment beginning with '/'. The fragment wins, we use '/'.
+            path, frag = fragment.to_s.split('#', 2)
+            res.path = "#{res.path}/#{path.sub(/^\/*/,'')}"
+            res.fragment = frag
           else
-            RDF::URI.intern(to_s.sub(/#+$/,'') + '#' + fragment.to_s.sub(/^#+/,''))
+            # Replace fragment
+            res.fragment = fragment.to_s.sub(/^#+/,'')
           end
-        else # includes '/'.  Results from bases ending in '/' are the same as if there were no trailing slash.
-          case fragment.to_s[0].chr
-          when '#' then # Base ending with '/', fragment beginning with '#'.  The fragment wins, we use '#'.
-            RDF::URI.intern(to_s.sub(/\/+$/,'') + '#' + fragment.to_s.sub(/^#+/,''))
+        else
+          # Not a fragment. includes '/'. Results from bases ending in '/' are the same as if there were no trailing slash.
+          case fragment.to_s[0,1]
+          when '#'
+            # Base ending with '/', fragment beginning with '#'. The fragment wins, we use '#'.
+            res.path = res.path.to_s.sub!(/\/*$/, '')
+            # Add fragment
+            res.fragment = fragment.to_s.sub(/^#+/,'')
           else
-            RDF::URI.intern(to_s.sub(/\/+$/,'') + '/' + fragment.to_s.sub(/^\/+/,''))
+            # Add fragment as path component
+            path, frag = fragment.to_s.split('#', 2)
+            res.path = res.path.to_s.sub(/\/*$/,'/') + path.sub(/^\/*/,'')
+            res.fragment = frag
           end
         end
+        RDF::URI.intern(res.to_s)
       end
     end
 
@@ -353,7 +518,7 @@ module RDF
     #
     # @return [Boolean] `true` or `false`
     def root?
-      self.path == '/' || self.path.empty?
+      self.path == '/' || self.path.to_s.empty?
     end
 
     ##
@@ -368,9 +533,9 @@ module RDF
       if root?
         self
       else
-        uri = self.dup
-        uri.path = '/'
-        uri
+        RDF::URI.new(
+          object.merge(:path => '/').
+          keep_if {|k, v| [:scheme, :authority, :path].include?(k)})
       end
     end
 
@@ -410,7 +575,7 @@ module RDF
     end
 
     ##
-    # Returns a qualified name (QName) for this URI, if possible.
+    # Returns a qualified name (QName) for this URI based on available vocabularies, if possible.
     #
     # @example
     #   RDF::URI('http://purl.org/dc/terms/').qname             #=> [:dc, nil]
@@ -446,14 +611,21 @@ module RDF
     #
     # @return [RDF::URI]
     def dup
-      self.class.new(@uri.dup)
+      self.class.new((@value || @object).dup)
     end
 
     ##
     # @private
     def freeze
-      @uri.freeze
-      super
+      unless frozen?
+        # Create derived components
+        authority; userinfo; user; password; host; port
+        @value  = value.freeze
+        @object = object.freeze
+        @hash = hash.freeze
+        super
+      end
+      self
     end
 
     ##
@@ -521,7 +693,7 @@ module RDF
         # If other is a Literal, reverse test to consolodate complex type checking logic
         other == self
       when String then to_s == other
-      when URI, Addressable::URI then to_s == other.to_s
+      when URI then to_s == other.to_s
       else other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
       end
     end
@@ -577,7 +749,7 @@ module RDF
     #
     # @return [Sring]
     def to_base
-      "<#{escape(@uri.to_s)}>"
+      "<#{escape(to_s)}>"
     end
 
     ##
@@ -587,48 +759,401 @@ module RDF
     #   RDF::URI('http://example.org/').to_str                  #=> 'http://example.org/'
     #
     # @return [String]
-    def to_str
-      @uri.to_s
-    end
+    def to_str; value; end
     alias_method :to_s, :to_str
 
+    ##
+    # Returns a <code>String</code> representation of the URI object's state.
+    #
+    # @return [String] The URI object's state, as a <code>String</code>.
+    def inspect
+      sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
+    end
+
+    ##
+    # lexical representation of URI, either absolute or relative
+    # @return [String] 
+    def value
+      @value ||= [
+        ("#{scheme}:" if absolute?),
+        ("//#{authority}" if authority),
+        path,
+        ("?#{query}" if query),
+        ("##{fragment}" if fragment)
+      ].compact.join("")
+    end
+
     ##
     # Returns a hash code for this URI.
     #
     # @return [Fixnum]
     def hash
-      @uri.hash
+      return @hash ||= (to_s.hash * -1)
     end
 
     ##
-    # Returns `true` if this URI instance supports the `symbol` method.
+    # Returns object representation of this URI, broken into components
     #
-    # @param  [Symbol, String, #to_s] symbol
-    # @return [Boolean] `true` or `false`
-    def respond_to?(symbol)
-      @uri.respond_to?(symbol) || super
+    # @return [Hash{Symbol => String}]
+    def object
+      @object ||= begin
+        parse @value
+      end
     end
+    alias_method :to_hash, :object
 
-  protected
+    ##{
+    # Parse a URI into it's components
+    #
+    # @param [String, to_s] value
+    # @return [Object{Symbol => String}]
+    def parse(value)
+      value = value.to_s.dup.force_encoding(Encoding::ASCII_8BIT)
+      parts = {}
+      if matchdata = value.to_s.match(IRI_PARTS)
+        scheme, authority, path, query, fragment = matchdata.to_a[1..-1]
+        userinfo, hostport = authority.to_s.split('@', 2)
+        hostport, userinfo = userinfo, nil unless hostport
+        user, password = userinfo.to_s.split(':', 2)
+        host, port = hostport.to_s.split(':', 2)
+
+        parts[:scheme] = (scheme.force_encoding(Encoding::UTF_8) if scheme)
+        parts[:authority] = (authority.force_encoding(Encoding::UTF_8) if authority)
+        parts[:userinfo] = (userinfo.force_encoding(Encoding::UTF_8) if userinfo)
+        parts[:user] = (user.force_encoding(Encoding::UTF_8) if user)
+        parts[:password] = (password.force_encoding(Encoding::UTF_8) if password)
+        parts[:host] = (host.force_encoding(Encoding::UTF_8) if host)
+        parts[:port] = (::URI.decode(port).to_i if port)
+        parts[:path] = (path.to_s.force_encoding(Encoding::UTF_8) unless path.empty?)
+        parts[:query] = (query[1..-1].force_encoding(Encoding::UTF_8) if query)
+        parts[:fragment] = (fragment[1..-1].force_encoding(Encoding::UTF_8) if fragment)
+
+        parts.each_key do |k|
+          parts[k].force_encoding(Encoding::UTF_8) if parts[k].respond_to?(:encoding)
+        end
+      end
+      
+      parts
+    end
 
     ##
-    # @param  [Symbol, String, #to_s] symbol
-    # @param  [Array<Object>] args
-    # @yield
-    # @return [Object]
-    # @private
-    def method_missing(symbol, *args, &block)
-      if @uri.respond_to?(symbol)
-        case result = @uri.send(symbol, *args, &block)
-          when Addressable::URI
-            self.class.new(result)
-          else result
+    # @return [String]
+    def scheme; object.fetch(:scheme, nil); end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def scheme=(value)
+      object[:scheme] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @value = nil
+      self
+    end
+
+    ##
+    # Return normalized version of scheme, if any
+    # @return [String]
+    def normalized_scheme
+      scheme.strip.downcase if scheme
+    end
+
+    ##
+    # @return [String]
+    def user
+      object.fetch(:user) do
+        @object[:user] = (userinfo.split(':', 2)[0] if userinfo)
+      end
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def user=(value)
+      object[:user] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @object[:userinfo] = format_userinfo("")
+      @object[:authority] = format_authority
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of user
+    # @return [String]
+    def normalized_user
+      ::URI.encode(::URI.decode(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if user
+    end
+
+    ##
+    # @return [String]
+    def password
+      object.fetch(:password) do
+        @object[:password] = (userinfo.split(':', 2)[1] if userinfo)
+      end
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def password=(value)
+      object[:password] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @object[:userinfo] = format_userinfo("")
+      @object[:authority] = format_authority
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of password
+    # @return [String]
+    def normalized_password
+      ::URI.encode(::URI.decode(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if password
+    end
+
+    ##
+    # @return [String]
+    def host
+      object.fetch(:host) do
+        @object[:host] = ($1 if @object[:authority].to_s.match(/(?:[^@]+@)?([^:]+)(?::.*)?$/))
+      end
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def host=(value)
+      object[:host] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @object[:authority] = format_authority
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of host
+    # @return [String]
+    def normalized_host
+      # Remove trailing '.' characters
+      normalize_segment(host, IHOST, true).sub(/\.*$/, '') if host
+    end
+
+    ##
+    # @return [String]
+    def port
+      object.fetch(:port) do
+        @object[:port] = ($1 if @object[:authority].to_s.match(/:(\d+)$/))
+      end
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def port=(value)
+      object[:port] = (value.to_s.to_i if value)
+      @object[:authority] = format_authority
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of port
+    # @return [String]
+    def normalized_port
+      if port
+        np = normalize_segment(port.to_s, PORT)
+        if PORT_MAPPING[normalized_scheme] == np.to_i
+          nil
+        else
+          np.to_i
         end
+      end
+    end
+
+    ##
+    # @return [String]
+    def path; object.fetch(:path, nil); end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def path=(value)
+      if value
+        # Always lead with a slash
+        value = "/#{value}" if host && value.to_s =~ /^[^\/]/
+        object[:path] = value.to_s.force_encoding(Encoding::UTF_8)
       else
-        super
+        object[:path] = nil
+      end
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of path
+    # @return [String]
+    def normalized_path
+      segments = path.to_s.split('/', -1) # preserve null segments
+
+      norm_segs = case
+      when authority
+        # ipath-abempty
+        segments.map {|s| normalize_segment(s, ISEGMENT)}
+      when segments.first.nil?
+        # ipath-absolute
+        res = [nil]
+        res << normalize_segment(segments[1], ISEGMENT_NZ) if segments.length > 1
+        res += segments[2..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 2
+        res
+      when segments.first.to_s.index(':')
+        # ipath-noscheme
+        res = []
+        res << normalize_segment(segments[1], ISEGMENT_NZ_NC)
+        res += segments[1..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 1
+      when segments.first
+        # ipath-rootless
+        # ipath-noscheme
+        res = []
+        res << normalize_segment(segments[0], ISEGMENT_NZ)
+        res += segments[1..-1].map {|s| normalize_segment(s, ISEGMENT)} if segments.length > 1
+        res
+      else
+        # Should be empty
+        segments
+      end
+
+      res = self.class.normalize_path(norm_segs.join("/"))
+      # Special rules for specific protocols having empty paths
+      res.empty? ? (%w(http https ftp tftp).include?(normalized_scheme) ? '/' : "") : res
+    end
+
+    ##
+    # @return [String]
+    def query; object.fetch(:query, nil); end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def query=(value)
+      object[:query] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @value = nil
+      self
+    end
+
+    ##
+    # Normalized version of query
+    # @return [String]
+    def normalized_query
+      normalize_segment(query, IQUERY) if query
+    end
+
+    ##
+    # @return [String]
+    def fragment; object.fetch(:fragment, nil); end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def fragment=(value)
+      object[:fragment] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      @value = nil
+      self
+    end
+
+    ##
+    # Normalized version of fragment
+    # @return [String]
+    def normalized_fragment
+      normalize_segment(fragment, IFRAGMENT) if fragment
+    end
+
+    ##
+    # Authority is a combination of user, password, host and port
+    def authority
+      object.fetch(:authority) {
+        @object[:authority] = (format_authority if @object[:host])
+      }
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def authority=(value)
+      object.delete_if {|k, v| [:user, :password, :host, :port, :userinfo].include?(k)}
+      object[:authority] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      user; password; userinfo; host; port
+      @value = nil
+      self
+    end
+
+    ##
+    # Return normalized version of authority, if any
+    # @return [String]
+    def normalized_authority
+      if authority
+        (userinfo ? "#{normalized_userinfo}@" : "") +
+        normalized_host +
+        (normalized_port ? ":#{normalized_port}" : "")
+      end
+    end
+
+    ##
+    # Userinfo is a combination of user and password
+    def userinfo
+      object.fetch(:userinfo) {
+        @object[:userinfo] = (format_userinfo("") if @object[:user])
+      }
+    end
+
+    ##
+    # @param [String, #to_s] value
+    # @return [RDF::URI] self
+    def userinfo=(value)
+      object.delete_if {|k, v| [:user, :password, :authority].include?(k)}
+      object[:userinfo] = (value.to_s.force_encoding(Encoding::UTF_8) if value)
+      user; password; authority
+      @value = nil
+      self
+    end
+    
+    ##
+    # Normalized version of userinfo
+    # @return [String]
+    def normalized_userinfo
+      normalized_user + (password ? ":#{normalized_password}" : "") if userinfo
+    end
+
+  private
+
+    ##
+    # Normalize a segment using a character range
+    #
+    # @param [String] segment
+    # @param [Regexp] expr
+    # @param [Boolean] downcase
+    # @result [String]
+    def normalize_segment(value, expr, downcase = false)
+      if value
+        value = value.dup if value.frozen?
+        value = value.force_encoding(Encoding::UTF_8)
+        decoded = ::URI.decode(value)
+        decoded.downcase! if downcase
+        ::URI.encode(decoded, /[^#{expr}]/)
+      end
+    end
+
+    def format_userinfo(append = "")
+      if @object[:user]
+        @object[:user] + (@object[:password] ? ":#{@object[:password]}" : "") + append
+      else
+        ""
+      end
+    end
+
+    def format_authority
+      if @object[:host]
+        format_userinfo("@") + @object[:host] + (object[:port] ? ":#{object[:port]}" : "")
+      else
+        ""
       end
     end
-  end # URI
+  end
 
   # RDF::IRI is a synonym for RDF::URI
   IRI = URI