rdf-rdfxml 0.2.3 → 0.3.0

data/.yardopts

@@ -6,6 +6,8 @@
 --markup rdoc
 --readme README.rdoc
 -
+README.rdoc
+History.rdoc
 AUTHORS
 CONTRIBUTORS
 VERSION

data/{History.txt → History.rdoc}

@@ -1,3 +1,24 @@
+=== 0.3.0
+* RDF.rb 0.3.0 compatibility updates
+  * Remove literal_normalization and qname_hacks, add back uri_hacks (until 0.3.0)
+  * Use nil for default namespace
+* In Writer
+  * Use only :prefixes for creating QNames.
+  * Add :standard_prefixes and :default_namespace options.
+  * Improve Writer#to_qname.
+  * Don't try to translate rdf:_1 to rdf:li due to complex corner cases.
+  * Fix problems with XMLLiteral, rdf:type and rdf:nodeID serialization.
+* In Reader
+  * URI canonicalization and validation.
+  * Added :canonicalize, and :intern options.
+  * Change :strict option to :validate.
+  * Don't create unnecessary namespaces.
+  * Don't use regexp to substitute base URI in URI serialization.
+  * Collect prefixes when extracting mappings.
+* Literal::XML
+  * Add all in-scope namespaces, not just those that seem to be used.
+* RSpec 2 compatibility
+
 === 0.2.3
 * Fixed QName generation in Writer based on RDF/XML Processing recommendations
 

data/README.rdoc

@@ -2,14 +2,14 @@
 
 RDF/XML parser for RDF.rb.
 
-== DESCRIPTION:
+== DESCRIPTION
 
 RDF::RDFXML is an RDF/XML reader/writer for Ruby using the RDF.rb library suite.
 
-== FEATURES:
-RDF::RDFXML parses RDF/XML into statements or triples.
+== FEATURES
+RDF::RDFXML parses RDF/XML into statements or triples and serializes triples, statements or graphs.
 
-* Fully compliant RDF/XML parser.
+* Fully compliant RDF/XML parser and serializer.
 
 Install with 'gem install rdf-rdfxml'
 
@@ -23,7 +23,7 @@ Instantiate a parser and parse source, specifying type and base-URL
   end
 
 == Dependencies
-  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.0)
   * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
 
 == TODO
@@ -31,20 +31,20 @@ Instantiate a parser and parse source, specifying type and base-URL
 * Consider a SAX-based parser for improved performance
 * Add generic RDF/XML Writer
 
-== Resources:
+== Resources
 * Distiller[http://kellogg-assoc/distiller]
 * RDoc[http://rdoc.info/projects/gkellogg/rdf-rdfxml]
 * History[http://github.com/gkellogg/rdf-rdfxml/blob/master/History.txt]
 * "XHTML+RDFXML 1.1 Core"[http://www.w3.org/TR/2010/WD-xhtml-rdfa-20100422/]
 * "RDF Tests"[http://www.w3.org/2000/10/rdf-tests/rdfcore/allTestCases.html]
 
-== AUTHOR:
+== AUTHOR
 * Gregg Kellogg <gregg@kellogg-assoc.com>
 
-== CONTRIBUTORS:
+== CONTRIBUTORS
 * Nicholas Humfrey <nicholas.humfrey@bbc.co.uk>
 
-== LICENSE:
+== LICENSE
 
 (The MIT License)
 
@@ -72,7 +72,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 == FEEDBACK
 
 * gregg@kellogg-assoc.com
-* rubygems.org/rdf-rdfxml
-* github.com/gkellogg/rdf-rdfxml
-* gkellogg.lighthouseapp.com for bug reports
+* http://rubygems.org/rdf-rdfxml
+* http://github.com/gkellogg/rdf-rdfxml
 * public-rdf-ruby mailing list on w3.org

data/Rakefile

@@ -7,43 +7,35 @@ begin
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "rdf-rdfxml"
     gemspec.summary = "RDF/XML reader/writer for RDF.rb."
-    gemspec.description = <<-DESCRIPTION
-    RDF::RDFXML is an RDF/XML reader and writer for Ruby using the RDF.rb library suite.
-    DESCRIPTION
+    gemspec.description = %q(RDF::RDFXML is an RDF/XML reader and writer for Ruby using the RDF.rb library suite.)
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfxml"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.2.2')
+    gemspec.add_dependency('rdf', '>= 0.3.0')
     gemspec.add_dependency('nokogiri', '>= 1.3.3')
-    gemspec.add_development_dependency('rspec')
-    gemspec.add_development_dependency('rdf-spec', '>= 0.2.2')
+    gemspec.add_development_dependency('rspec', '>= 2.1.0')
+    gemspec.add_development_dependency('rdf-spec')
     gemspec.add_development_dependency('rdf-isomorphic')
     gemspec.add_development_dependency('yard')
-    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS CONTRIBUTORS)
+    gemspec.extra_rdoc_files     = %w(README.rdoc History.rdoc AUTHORS CONTRIBUTORS)
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/*_spec.rb']
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
 desc "Run specs through RCov"
-Spec::Rake::SpecTask.new("spec:rcov") do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/*_spec.rb'
+RSpec::Core::RakeTask.new("spec:rcov") do |spec|
   spec.rcov = true
+  spec.rcov_opts =  %q[--exclude "spec"]
 end
 
 desc "Generate HTML report specs"
-Spec::Rake::SpecTask.new("doc:spec") do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/*_spec.rb']
-  spec.spec_opts = ["--format", "html:doc/spec.html"]
+RSpec::Core::RakeTask.new("doc:spec") do |spec|
+  spec.rspec_opts = ["--format", "html", "-o", "doc/spec.html"]
 end
 
 YARD::Rake::YardocTask.new do |t|

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/rdf/rdfxml.rb

@@ -25,11 +25,12 @@ module RDF
     require 'rdf/rdfxml/patches/array_hacks'
     require 'rdf/rdfxml/patches/literal_hacks'
     require 'rdf/rdfxml/patches/nokogiri_hacks'
-    require 'rdf/rdfxml/patches/qname_hacks'
-    require 'rdf/rdfxml/patches/uri_hacks'
     autoload :Reader,  'rdf/rdfxml/reader'
     autoload :Writer,  'rdf/rdfxml/writer'
     autoload :VERSION, 'rdf/rdfxml/version'
     autoload :XML,     'rdf/rdfxml/vocab'
+    
+    def self.debug?; @debug; end
+    def self.debug=(value); @debug = value; end
   end
 end

data/lib/rdf/rdfxml/patches/literal_hacks.rb

@@ -20,7 +20,7 @@ module RDF; class Literal
     ##
     # @param  [Object] value
     # @option options [String] :lexical (nil)
-    # @option options [Hash] :namespaces ({}) Use :__default__ or "" to declare default namespace
+    # @option options [Hash] :namespaces ({}) Use "" to declare default namespace
     # @option options [Symbol] :language (nil)
     # @option options [:nokogiri, :libxml, or :rexml] :library
     def initialize(value, options = {})
@@ -68,17 +68,15 @@ module RDF; class Literal
     def parse_value(value, options)
       ns_hash = {}
       options[:namespaces].each_pair do |prefix, uri|
-        prefix = prefix == :__default__ ? "" : prefix.to_s
+        prefix = prefix.to_s
         attr = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
         ns_hash[attr] = uri.to_s
       end
-      ns_strs = []
-      ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
 
       case @library
-      when :nokogiri  then parse_value_nokogiri(value, ns_strs, options[:language])
-      when :libxml    then parse_value_libxml(value, ns_strs, options[:language])
-      when :rexml     then parse_value_rexml(value, ns_strs, options[:language])
+      when :nokogiri  then parse_value_nokogiri(value, ns_hash, options)
+      when :libxml    then parse_value_libxml(value, ns_hash, options)
+      when :rexml     then parse_value_rexml(value, ns_hash, options)
       else                 value.to_s
       end
     end
@@ -99,10 +97,12 @@ module RDF; class Literal
       # to the required element, and does not properly order either namespaces or attributes.
       #
       # An open-issue in Nokogiri is to add support for C14N from the underlying libxml2 libraries.
-      def parse_value_nokogiri(value, ns_strs, language)
+      def parse_value_nokogiri(value, ns_hash, options)
         elements = if value.is_a?(Nokogiri::XML::NodeSet)
           value
         else
+          ns_strs = []
+          ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
           # Add inherited namespaces to created root element so that they're inherited to sub-elements
           Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
         end
@@ -110,17 +110,15 @@ module RDF; class Literal
         elements.map do |c|
           if c.is_a?(Nokogiri::XML::Element)
             c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).root
-            # Gather namespaces from self and decendant nodes
-            c.traverse do |n|
-              ns = n.namespace
-              next unless ns
-              prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
-              c[prefix] = ns.href.to_s unless c.namespaces[prefix]
-            end
 
+            # Apply defined namespaces
+            ns_hash.each_pair do |prefix, href|
+              c[prefix] = href unless c.namespaces[prefix]
+            end
+            
             # Add language
-            if language && c["lang"].to_s.empty?
-              c["xml:lang"] = language.to_s
+            if options[:language] && c["lang"].to_s.empty?
+              c["xml:lang"] = options[:language].to_s
             end
           end
           c

data/lib/rdf/rdfxml/reader.rb

@@ -4,6 +4,8 @@ module RDF::RDFXML
   ##
   # An RDF/XML parser in Ruby
   #
+  # Based on RDF/XML Syntax Specification: http://www.w3.org/TR/REC-rdf-syntax/
+  #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
     format Format
@@ -33,7 +35,7 @@ module RDF::RDFXML
       attr :graph, true
       attr :li_counter, true
 
-      def initialize(base, element, graph)
+      def initialize(base, element, graph, &cb)
         # Initialize the evaluation context, [5.1]
         self.base = RDF::URI.intern(base)
         @uri_mappings = {}
@@ -41,51 +43,52 @@ module RDF::RDFXML
         @graph = graph
         @li_counter = 0
 
-        extract_from_element(element) if element
+        extract_from_element(element, &cb) if element
       end
       
       # Clone existing evaluation context adding information from element
-      def clone(element, options = {})
+      def clone(element, options = {}, &cb)
         new_ec = EvaluationContext.new(@base, nil, @graph)
         new_ec.uri_mappings = self.uri_mappings.clone
         new_ec.language = self.language
 
-        new_ec.extract_from_element(element) if element
+        new_ec.extract_from_element(element, &cb) if element
         
         options.each_pair {|k, v| new_ec.send("#{k}=", v)}
         new_ec
       end
       
       # Extract Evaluation Context from an element by looking at ancestors recurively
-      def extract_from_ancestors(el)
+      def extract_from_ancestors(el, &cb)
         ancestors = el.ancestors
         while ancestors.length > 0
           a = ancestors.pop
           next unless a.element?
-          extract_from_element(a)
+          extract_from_element(a, &cb)
         end
-        extract_from_element(el)
+        extract_from_element(el, &cb)
       end
 
       # Extract Evaluation Context from an element
-      def extract_from_element(el)
+      def extract_from_element(el, &cb)
         b = el.attribute_with_ns("base", RDF::XML.to_s)
         lang = el.attribute_with_ns("lang", RDF::XML.to_s)
         self.base = self.base.join(b) if b
         self.language = lang if lang
-        self.uri_mappings.merge!(extract_mappings(el))
+        self.uri_mappings.merge!(extract_mappings(el, &cb))
       end
       
       # Extract the XMLNS mappings from an element
-      def extract_mappings(element)
+      def extract_mappings(element, &cb)
         mappings = {}
 
         # look for xmlns
         element.namespaces.each do |attr_name,attr_value|
-          abbr, suffix = attr_name.to_s.split(":")
+          abbr, prefix = attr_name.to_s.split(":")
           if abbr == "xmlns"
             attr_value = self.base.to_s + attr_value if attr_value.match(/^\#/)
-            mappings[suffix] = attr_value
+            mappings[prefix] = attr_value
+            cb.call(prefix, attr_value) if block_given?
           end
         end
         mappings
@@ -99,8 +102,9 @@ module RDF::RDFXML
 
       # Set XML base. Ignore any fragment
       def base=(b)
-        @base = RDF::URI.intern(b)
-        @base.fragment = nil
+        base = Addressable::URI.parse(b)
+        base.fragment = nil
+        @base = RDF::URI.intern(base)
       end
 
       def inspect
@@ -113,29 +117,41 @@ module RDF::RDFXML
     ##
     # Initializes the RDF/XML reader instance.
     #
-    # @param  [IO, File, String]       input
-    # @option options [Array] :debug (nil) Array to place debug messages
-    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
-    # @option options [Boolean] :base_uri (nil) Base URI to use for relative URIs.
+    # @param  [Nokogiri::XML::Document, IO, File, String] input
+    #   the input stream to read
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options
+    # @option options [Encoding] :encoding     (Encoding::UTF_8)
+    #   the encoding of the input stream (Ruby 1.9+)
+    # @option options [Boolean]  :validate     (false)
+    #   whether to validate the parsed statements and values
+    # @option options [Boolean]  :canonicalize (false)
+    #   whether to canonicalize parsed literals
+    # @option options [Boolean]  :intern       (true)
+    #   whether to intern all parsed URIs
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (not supported by all readers)
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when resolving relative URIs
+    # @option options [Array] :debug
+    #   Array to place debug messages
     # @return [reader]
-    # @yield  [reader]
-    # @yieldparam [Reader] reader
-    # @raise [Error]:: Raises RDF::ReaderError if _strict_
+    # @yield  [reader] `self`
+    # @yieldparam  [RDF::Reader] reader
+    # @yieldreturn [void] ignored
+    # @raise [Error]:: Raises RDF::ReaderError if _validate_
     def initialize(input = $stdin, options = {}, &block)
       super do
         @debug = options[:debug]
-        @strict = options[:strict]
-        @base_uri = RDF::URI.intern(options[:base_uri])
+        @base_uri = uri(options[:base_uri]) if options[:base_uri]
             
-        @id_mapping = Hash.new
-
         @doc = case input
         when Nokogiri::XML::Document then input
         else Nokogiri::XML.parse(input, @base_uri.to_s)
         end
         
-        raise RDF::ReaderError, "Synax errors:\n#{@doc.errors}" if !@doc.errors.empty? && @strict
-        raise RDF::ReaderError, "Empty document" if (@doc.nil? || @doc.root.nil?) && @strict
+        raise RDF::ReaderError, "Synax errors:\n#{@doc.errors}" if !@doc.errors.empty? && validate?
+        raise RDF::ReaderError, "Empty document" if (@doc.nil? || @doc.root.nil?) && validate?
 
         block.call(self) if block_given?
       end
@@ -165,18 +181,25 @@ module RDF::RDFXML
       if rdf_nodes.length == 0
         # If none found, root element may be processed as an RDF Node
 
-        ec = EvaluationContext.new(@base_uri, root, @graph)
+        ec = EvaluationContext.new(@base_uri, root, @graph) do |prefix, value|
+          prefix(prefix, value)
+        end
+        
         nodeElement(root, ec)
       else
         rdf_nodes.each do |node|
           # XXX Skip this element if it's contained within another rdf:RDF element
 
           # Extract base, lang and namespaces from parents to create proper evaluation context
-          ec = EvaluationContext.new(@base_uri, nil, @graph)
+          ec = EvaluationContext.new(@base_uri, nil, @graph) do |prefix, value|
+            prefix(prefix, value)
+          end
           ec.extract_from_ancestors(node)
           node.children.each {|el|
             next unless el.elem?
-            new_ec = ec.clone(el)
+            new_ec = ec.clone(el) do |prefix, value|
+              prefix(prefix, value)
+            end
             nodeElement(el, new_ec)
           }
         end
@@ -218,7 +241,7 @@ module RDF::RDFXML
     # @param [XML Node, any] node:: XML Node or string for showing context
     # @param [String] message::
     def add_debug(node, message)
-      puts "#{node_path(node)}: #{message}" if $DEBUG
+      puts "#{node_path(node)}: #{message}" if ::RDF::RDFXML::debug?
       @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
     end
 
@@ -229,7 +252,7 @@ module RDF::RDFXML
     # @param [URI] predicate:: the predicate of the statement
     # @param [URI, BNode, Literal] object:: the object of the statement
     # @return [Statement]:: Added statement
-    # @raise [RDF::ReaderError]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
+    # @raise [RDF::ReaderError]:: Checks parameter types and raises if they are incorrect if validating.
     def add_triple(node, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
       add_debug(node, "statement: #{statement}")
@@ -241,7 +264,7 @@ module RDF::RDFXML
     # @param [XML Element] el:: XMl Element to parse
     # @param [EvaluationContext] ec:: Evaluation context
     # @return [RDF::URI] subject:: The subject found for the node
-    # @raise [RDF::ReaderError]:: Raises Exception if _strict_
+    # @raise [RDF::ReaderError]:: Raises Exception if validating
     def nodeElement(el, ec)
       # subject
       subject = ec.subject || parse_subject(el, ec)
@@ -266,7 +289,7 @@ module RDF::RDFXML
         elsif is_propertyAttr?(attr)
           # Attributes not RDF.type
           predicate = attr.uri
-          lit = RDF::Literal.new(attr.value, :language => ec.language)
+          lit = RDF::Literal.new(attr.value, :language => ec.language, :validate => validate?, :canonicalize => canonicalize?)
           add_triple(attr, subject, predicate, lit)
         end
       end
@@ -275,7 +298,9 @@ module RDF::RDFXML
       li_counter = 0 # this will increase for each li we iterate through
       el.children.each do |child|
         next unless child.elem?
-        child_ec = ec.clone(child)
+        child_ec = ec.clone(child) do |prefix, value|
+          prefix(prefix, value)
+        end
         predicate = child.uri
         add_debug(child, "propertyElt, predicate: #{predicate}")
         propertyElementURI_check(child)
@@ -330,13 +355,13 @@ module RDF::RDFXML
         
         if nodeID && resourceAttr
           add_debug(el, "Cannot have rdf:nodeID and rdf:resource.")
-          raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:resource.") if @strict
+          raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:resource.") if validate?
         end
 
         # Apply character transformations
-        id = id_check(el, RDF::NTriples.escape(id), nil) if id
-        resourceAttr = RDF::NTriples.escape(resourceAttr) if resourceAttr
-        nodeID = nodeID_check(el, RDF::NTriples.escape(nodeID)) if nodeID
+        id = id_check(el, RDF::NTriples.unescape(id), nil) if id
+        resourceAttr = RDF::NTriples.unescape(resourceAttr) if resourceAttr
+        nodeID = nodeID_check(el, RDF::NTriples.unescape(nodeID)) if nodeID
 
         add_debug(child, "attrs: #{attrs.inspect}")
         add_debug(child, "datatype: #{datatype}") if datatype
@@ -348,7 +373,9 @@ module RDF::RDFXML
         if attrs.empty? && datatype.nil? && parseType.nil? && element_nodes.length == 1
           # Production resourcePropertyElt
 
-          new_ec = child_ec.clone(nil)
+          new_ec = child_ec.clone(nil) do |prefix, value|
+            prefix(prefix, value)
+          end
           new_node_element = element_nodes.first
           add_debug(child, "resourcePropertyElt: #{node_path(new_node_element)}")
           new_subject = nodeElement(new_node_element, new_ec)
@@ -357,9 +384,9 @@ module RDF::RDFXML
           # Production literalPropertyElt
           add_debug(child, "literalPropertyElt")
           
-          literal_opts = {}
+          literal_opts = {:validate => validate?, :canonicalize => canonicalize?}
           if datatype
-            literal_opts[:datatype] = RDF::URI.intern(datatype)
+            literal_opts[:datatype] = uri(datatype)
           else
             literal_opts[:language] = child_ec.language
           end
@@ -373,7 +400,7 @@ module RDF::RDFXML
           unless attrs.empty?
             warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
             add_debug(child, warn)
-            raise RDF::ReaderError.new(warn) if @strict
+            raise RDF::ReaderError.new(warn) if validate?
           end
 
           # For element e with possibly empty element content c.
@@ -396,7 +423,9 @@ module RDF::RDFXML
           node.namespace = pt_attr.namespace
           node.attributes.keys.each {|a| node.remove_attribute(a)}
           node.node_name = "Description"
-          new_ec = child_ec.clone(nil, :subject => n)
+          new_ec = child_ec.clone(nil, :subject => n) do |prefix, value|
+            prefix(prefix, value)
+          end
           nodeElement(node, new_ec)
         elsif parseType == "Collection"
           # Production parseTypeCollectionPropertyElt
@@ -405,7 +434,7 @@ module RDF::RDFXML
           unless attrs.empty?
             warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
             add_debug(child, warn)
-            raise RDF::ReaderError.new(warn) if @strict
+            raise RDF::ReaderError.new(warn) if validate?
           end
 
           # For element event e with possibly empty nodeElementList l. Set s:=list().
@@ -421,7 +450,9 @@ module RDF::RDFXML
             o = s[i+1]
             f = element_nodes[i]
 
-            new_ec = child_ec.clone(nil)
+            new_ec = child_ec.clone(nil) do |prefix, value|
+              prefix(prefix, value)
+            end
             object = nodeElement(f, new_ec)
             add_triple(child, n, RDF.first, object)
             add_triple(child, n, RDF.rest, o ? o : RDF.nil)
@@ -433,13 +464,13 @@ module RDF::RDFXML
           unless attrs.empty?
             warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
             add_debug(child, warn)
-            raise RDF::ReaderError.new(warn) if @strict
+            raise RDF::ReaderError.new(warn) if validate?
           end
 
           if resourceAttr
             warn = "illegal rdf:resource"
             add_debug(child, warn)
-            raise RDF::ReaderError.new(warn) if @strict
+            raise RDF::ReaderError.new(warn) if validate?
           end
 
           object = RDF::Literal.new(child.children, :datatype => RDF.XMLLiteral, :namespaces => child_ec.uri_mappings, :language => ec.language)
@@ -512,23 +543,23 @@ module RDF::RDFXML
       
       if nodeID && about
         add_debug(el, "Cannot have rdf:nodeID and rdf:about.")
-        raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:about.") if @strict
+        raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:about.") if validate?
       elsif nodeID && id
         add_debug(el, "Cannot have rdf:nodeID and rdf:ID.")
-        raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:ID.") if @strict
+        raise RDF::ReaderError.new("Cannot have rdf:nodeID and rdf:ID.") if validate?
       end
 
       case
       when id
-        add_debug(el, "parse_subject, id: '#{RDF::NTriples.escape(id.value)}'")
-        id_check(el, RDF::NTriples.escape(id.value), ec.base) # Returns URI
+        add_debug(el, "parse_subject, id: '#{RDF::NTriples.unescape(id.value)}'")
+        id_check(el, RDF::NTriples.unescape(id.value), ec.base) # Returns URI
       when nodeID
         # The value of rdf:nodeID must match the XML Name production
-        nodeID = nodeID_check(el, RDF::NTriples.escape(nodeID.value))
+        nodeID = nodeID_check(el, RDF::NTriples.unescape(nodeID.value))
         add_debug(el, "parse_subject, nodeID: '#{nodeID}")
         bnode(nodeID)
       when about
-        about = RDF::NTriples.escape(about.value)
+        about = RDF::NTriples.unescape(about.value)
         add_debug(el, "parse_subject, about: '#{about}'")
         ec.base.join(about)
       else
@@ -539,28 +570,24 @@ module RDF::RDFXML
     
     # ID attribute must be an NCName
     def id_check(el, id, base)
-      if NC_REGEXP.match(id)
-        # ID may only be specified once for the same URI
-        if base
-          # FIXME: Known bug in RDF::URI#join
-          uri = base.join("##{id}")
-          if @id_mapping[id] && @id_mapping[id] == uri
-            warn = "ID addtribute '#{id}' may only be defined once for the same URI"
-            add_debug(el, warn)
-            raise RDF::ReaderError.new(warn) if @strict
-          end
-          
-          @id_mapping[id] = uri
-          # Returns URI, in this case
-        else
-          id
-        end
-      else
+      unless NC_REGEXP.match(id)
         warn = "ID addtribute '#{id}' must be a NCName"
-        add_debug(el, "ID addtribute '#{id}' must be a NCName")
         add_debug(el, warn)
-        raise RDF::ReaderError.new(warn) if @strict
-        nil
+        raise RDF::ReaderError.new(warn) if validate?
+      end
+      # ID may only be specified once for the same URI
+      if base
+        uri = uri(base, "##{id}")
+        if prefix(id) && RDF::URI(prefix(id)) == uri
+          warn = "ID addtribute '#{id}' may only be defined once for the same URI"
+          add_debug(el, warn)
+          raise RDF::ReaderError.new(warn) if validate?
+        end
+        
+        RDF::URI(prefix(id, uri))
+        # Returns URI, in this case
+      else
+        id
       end
     end
     
@@ -571,7 +598,7 @@ module RDF::RDFXML
         nodeID
       else
         add_debug(el, "nodeID addtribute '#{nodeID}' must be an XML Name")
-        raise RDF::ReaderError.new("nodeID addtribute '#{nodeID}' must be a NCName") if @strict
+        raise RDF::ReaderError.new("nodeID addtribute '#{nodeID}' must be a NCName") if validate?
         nil
       end
     end
@@ -581,7 +608,7 @@ module RDF::RDFXML
       if ([RDF.Description.to_s, RDF.li.to_s] + OLD_TERMS).include?(attr.uri.to_s)
         warn = "Invalid use of rdf:#{attr.name}"
         add_debug(attr, warn)
-        raise RDF::ReaderError.new(warn) if @strict
+        raise RDF::ReaderError.new(warn) if validate?
         return false
       end
       !CORE_SYNTAX_TERMS.include?(attr.uri.to_s) && attr.namespace && attr.namespace.href != RDF::XML.to_s
@@ -592,7 +619,7 @@ module RDF::RDFXML
       if (CORE_SYNTAX_TERMS + [RDF.li.to_s] + OLD_TERMS).include?(el.uri.to_s)
         warn = "Invalid use of rdf:#{el.name}"
         add_debug(el, warn)
-        raise RDF::ReaderError.new(warn) if @strict
+        raise RDF::ReaderError.new(warn) if validate?
       end
     end
 
@@ -601,7 +628,7 @@ module RDF::RDFXML
       if (CORE_SYNTAX_TERMS + [RDF.Description.to_s] + OLD_TERMS).include?(el.uri.to_s)
         warn = "Invalid use of rdf:#{el.name}"
         add_debug(el, warn)
-        raise RDF::ReaderError.new(warn) if @strict
+        raise RDF::ReaderError.new(warn) if validate?
       end
     end
 
@@ -610,10 +637,19 @@ module RDF::RDFXML
       el.attribute_nodes.each do |attr|
         if OLD_TERMS.include?(attr.uri.to_s)
           add_debug(el, "Obsolete attribute '#{attr.uri}'")
-          raise RDF::ReaderError.new("Obsolete attribute '#{attr.uri}'") if @strict
+          raise RDF::ReaderError.new("Obsolete attribute '#{attr.uri}'") if validate?
         end
       end
     end
     
+    def uri(value, append = nil)
+      value = RDF::URI.new(value)
+      value = value.join(append) if append
+      value.validate! if validate?
+      value.canonicalize! if canonicalize?
+      value = RDF::URI.intern(value) if intern?
+      value
+    end
+
   end
 end