rdf-rdfxml 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+/pkg

data/.yardopts

@@ -1,4 +1,4 @@
---title "RDF::RDFa - RDFa Support for RDF.rb"
+--title "RDF::RDFXML - RDF/XML Support for RDF.rb"
 --output-dir doc/yard
 --protected
 --no-private
@@ -7,4 +7,5 @@
 --readme README.rdoc
 -
 AUTHORS
+CONTRIBUTORS
 VERSION

data/CONTRIBUTORS

@@ -0,0 +1 @@
+* Nicholas Humfrey <nicholas.humfrey@bbc.co.uk>

data/History.txt

@@ -1,2 +1,9 @@
+=== 0.0.2
+* Added specs from RdfContext
+* Added array_hacks, nokogiri_hacks, and rdf_escape
+* Fixed most bugs that are not related to the underlying framework.
+  * Specific failing testcases for rdf-isomorphic, RDF::Literaland others need to be constructed and added as issues against those gems.
+* Removed interal graph in Reader and implement each_triple & each_statement to perform parsing
+
 === 0.0.1
 * First port from RdfContext version 0.5.4

data/README.rdoc

@@ -1,10 +1,10 @@
-= RDF::RDFa reader/writer
+= RDF::RDFXML reader/writer
 
 RDF/XML parser for RDF.rb.
 
 == DESCRIPTION:
 
-RDF::RDFXML is an RDF/XML parser for Ruby using the RDF.rb library suite.
+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.
@@ -22,10 +22,27 @@ Instantiate a parser and parse source, specifying type and base-URL
     end
   end
 
+== Dependencies
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.6)
+  * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
+
+== TODO
+* Add support for LibXML and REXML bindings, and use the best available
+* Consider a SAX-based parser for improved performance
+* Add generic RDF/XML Writer
+
 == 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:
+* Gregg Kellogg <gregg@kellogg-assoc.com>
+
+== CONTRIBUTORS:
+* Nicholas Humfrey <nicholas.humfrey@bbc.co.uk>
 
 == LICENSE:
 

data/Rakefile

@@ -44,4 +44,18 @@ Spec::Rake::SpecTask.new("doc:spec") do |spec|
   spec.spec_opts = ["--format", "html:doc/spec.html"]
 end
 
+desc "Generate RDF Core Manifest.yml"
+namespace :spec do
+  task :prepare do
+    $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+    require 'rdf/rdfxml'
+    require 'spec/rdf_helper'
+    require 'fileutils'
+
+    yaml = File.join(RDFCORE_DIR, "Manifest.yml")
+    FileUtils.rm_f(yaml)
+    RdfHelper::TestCase.to_yaml(RDFCORE_TEST, RDFCORE_DIR, yaml)
+  end
+end
+
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/example.rb

@@ -6,7 +6,6 @@ require 'rubygems'
 require 'rdf/rdfxml'
 
 data = <<-EOF;
-  <?xml version="1.0" ?>
   <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:ex="http://www.example.org/" xml:lang="en" xml:base="http://www.example.org/foo">
     <ex:Thing rdf:about="http://example.org/joe" ex:name="bar">

data/lib/rdf/rdfxml.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
 require 'rdf'
 
 module RDF
@@ -8,7 +8,7 @@ module RDF
   # @example Requiring the `RDF::RDFXML` module
   #   require 'rdf/rdfxml'
   #
-  # @example Parsing RDF statements from an XHTML+RDFa file
+  # @example Parsing RDF statements from an XHTML+RDFXML file
   #   RDF::RDFXML::Reader.open("etc/foaf.xml") do |reader|
   #     reader.each_statement do |statement|
   #       puts statement.inspect
@@ -19,10 +19,18 @@ module RDF
   # @see http://www.w3.org/TR/REC-rdf-syntax/
   #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
-  module RDFa
-    require 'rdfxml/format'
-    require 'rdfxml/vocab'
+  module RDFXML
+    require 'rdf/rdfxml/format'
+    require 'rdf/rdfxml/vocab'
+    require 'rdf/rdfxml/patches/array_hacks'
+    require 'rdf/rdfxml/patches/nokogiri_hacks'
+    require 'rdf/rdfxml/patches/rdf_escape'
     autoload :Reader,  'rdf/rdfxml/reader'
+    autoload :Writer,  'rdf/rdfxml/writer'
     autoload :VERSION, 'rdf/rdfxml/version'
+    autoload :XML,     'rdf/rdfxml/vocab'
+    
+    # Fixme: RDF.to_s should generate this, but it doesn't
+    RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   end
-end
+end

data/lib/rdf/rdfxml/format.rb

@@ -1,9 +1,10 @@
 module RDF::RDFXML
   ##
-  # RDFa format specification.
+  # RDFXML format specification.
   #
-  # @example Obtaining an RDFa format class
-  #   RDF::Format.for(:rdfxml)     #=> RDF::RDFXML::Format
+  # @example Obtaining an RDFXML format class
+  #   RDF::Format.for(:rdf)        # RDF::RDFXML::Format
+  #   RDF::Format.for(:xml)        # RDF::RDFXML::Format
   #   RDF::Format.for("etc/foaf.xml")
   #   RDF::Format.for(:file_name      => "etc/foaf.xml")
   #   RDF::Format.for(:file_extension => "xml")
@@ -23,7 +24,7 @@ module RDF::RDFXML
     content_type     'application/rdf+xml', :extension => :rdf
     content_encoding 'utf-8'
 
-    reader { RDF::RDFa::RDFXML }
-    writer { RDF::RDFa::RDFXML }
+    reader { RDF::RDFXML::Reader }
+    writer { RDF::RDFXML::Writer }
   end
 end

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

@@ -0,0 +1,53 @@
+class Array
+  # http://wiki.rubygarden.org/Ruby/page/show/ArrayPermute
+  # Permute an array, and call a block for each permutation
+  # Author: Paul Battley
+  def permute(prefixed=[])
+    if (length < 2)
+      # there are no elements left to permute
+      yield(prefixed + self)
+    else
+      # recursively permute the remaining elements
+      each_with_index do |e, i|
+        (self[0,i]+self[(i+1)..-1]).permute(prefixed+[e]) { |a| yield a }
+      end
+    end
+  end unless Array.method_defined?(:permute)
+  
+  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  def to_sentence(options = {})
+    default_words_connector     = ", "
+    default_two_words_connector = " and "
+    default_last_word_connector = ", and "
+
+    # Try to emulate to_senteces previous to 2.3
+    if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
+      ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
+      ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
+
+      skip_last_comma = options.delete :skip_last_comma
+      if connector = options.delete(:connector)
+        options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
+      else
+        options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
+      end
+    end
+
+#    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+    options = {:words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector}.merge(options)
+
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end unless Array.method_defined?(:to_sentence)
+end

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

@@ -0,0 +1,8 @@
+require 'nokogiri'
+class Nokogiri::XML::Node
+  # URI of namespace + node_name
+  def uri
+    ns = self.namespace ? self.namespace.href : RDF::XML.to_s
+    RDF::URI.new(ns + self.node_name)
+  end
+end unless Nokogiri::XML::Node.method_defined?(:uri)

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

@@ -0,0 +1,131 @@
+# coding: utf-8
+require 'iconv'
+
+class String
+  #private
+  # "Borrowed" from JSON utf8_to_json
+  RDF_MAP = {
+    "\x0" => '\u0000',
+    "\x1" => '\u0001',
+    "\x2" => '\u0002',
+    "\x3" => '\u0003',
+    "\x4" => '\u0004',
+    "\x5" => '\u0005',
+    "\x6" => '\u0006',
+    "\x7" => '\u0007',
+    "\b"  =>  '\b',
+    "\t"  =>  '\t',
+    "\n"  =>  '\n',
+    "\xb" => '\u000B',
+    "\f"  =>  '\f',
+    "\r"  =>  '\r',
+    "\xe" => '\u000E',
+    "\xf" => '\u000F',
+    "\x10" => '\u0010',
+    "\x11" => '\u0011',
+    "\x12" => '\u0012',
+    "\x13" => '\u0013',
+    "\x14" => '\u0014',
+    "\x15" => '\u0015',
+    "\x16" => '\u0016',
+    "\x17" => '\u0017',
+    "\x18" => '\u0018',
+    "\x19" => '\u0019',
+    "\x1a" => '\u001A',
+    "\x1b" => '\u001B',
+    "\x1c" => '\u001C',
+    "\x1d" => '\u001D',
+    "\x1e" => '\u001E',
+    "\x1f" => '\u001F',
+    '"'   =>  '\"',
+    '\\'  =>  '\\\\',
+    '/'   =>  '/',
+  } # :nodoc:
+
+  if defined?(::Encoding)
+    # Funky way to define constant, but if parsed in 1.8 it generates an 'invalid regular expression' error otherwise
+    eval %(ESCAPE_RE = %r([\u{80}-\u{10ffff}]))
+  else
+    ESCAPE_RE = %r(
+                    [\xc2-\xdf][\x80-\xbf]    |
+                    [\xe0-\xef][\x80-\xbf]{2} |
+                    [\xf0-\xf4][\x80-\xbf]{3}
+                  )nx
+  end
+  
+  # Convert a UTF8 encoded Ruby string _string_ to an escaped string, encoded with
+  # UTF16 big endian characters as \U????, and return it.
+  #
+  # \\:: Backslash
+  # \':: Single quote
+  # \":: Double quot
+  # \n:: ASCII Linefeed
+  # \r:: ASCII Carriage Return
+  # \t:: ASCCII Horizontal Tab
+  # \uhhhh:: character in BMP with Unicode value U+hhhh
+  # \U00hhhhhh:: character in plane 1-16 with Unicode value U+hhhhhh
+  def rdf_escape
+    string = self + '' # XXX workaround: avoid buffer sharing
+    string.gsub!(/["\\\/\x0-\x1f]/) { RDF_MAP[$&] }
+    if defined?(::Encoding)
+      string.force_encoding(Encoding::UTF_8)
+      string.gsub!(ESCAPE_RE) { |c|
+                      s = c.dump.sub(/\"\\u\{(.+)\}\"/, '\1').upcase
+                      (s.length <= 4 ? "\\u0000"[0,6-s.length] : "\\U00000000"[0,10-s.length]) + s
+                    }
+      string.force_encoding(Encoding::ASCII_8BIT)
+    else
+      string.gsub!(ESCAPE_RE) { |c|
+                      s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*').first.upcase
+                      "\\u" + s
+                    }
+    end
+    string
+  end
+  
+  # Unescape characters in strings.
+  RDF_UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+  RDF_UNESCAPE_MAP.update({
+    ?"  => '"',
+    ?\\ => '\\',
+    ?/  => '/',
+    ?b  => "\b",
+    ?f  => "\f",
+    ?n  => "\n",
+    ?r  => "\r",
+    ?t  => "\t",
+    ?u  => nil, 
+  })
+
+  if defined?(::Encoding)
+    UNESCAPE_RE = %r(
+      (?:\\[\\bfnrt"/])   # Escaped control characters, " and /
+      |(?:\\U00\h{6})     # 6 byte escaped Unicode
+      |(?:\\u\h{4})       # 4 byte escaped Unicode
+    )x
+  else
+    UNESCAPE_RE = %r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n
+  end
+  
+  # Reverse operation of escape
+  # From JSON parser
+  def rdf_unescape
+    return '' if self.empty?
+    string = self.gsub(UNESCAPE_RE) do |c|
+      case c[1,1]
+      when 'U'
+        raise RDF::ReaderError, "Long Unicode escapes no supported in Ruby 1.8" unless defined?(::Encoding)
+        eval(c.sub(/\\U00(\h+)/, '"\u{\1}"'))
+      when 'u'
+        bytes = [c[2, 2].to_i(16), c[4, 2].to_i(16)]
+        Iconv.new('utf-8', 'utf-16').iconv(bytes.pack("C*"))
+      else
+        RDF_UNESCAPE_MAP[c[1]]
+      end
+    end
+    string.force_encoding(Encoding::UTF_8) if defined?(::Encoding)
+    string
+  rescue Iconv::Failure => e
+    raise RDF::ReaderError, "Caught #{e.class}: #{e}"
+  end
+end unless String.method_defined?(:rdf_escape)

data/lib/rdf/rdfxml/reader.rb

@@ -72,8 +72,8 @@ module RDF::RDFXML
 
       # Extract Evaluation Context from an element
       def extract_from_element(el)
-        b = el.attribute_with_ns("base", XML_NS.uri.to_s)
-        lang = el.attribute_with_ns("lang", XML_NS.uri.to_s)
+        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))
@@ -88,8 +88,7 @@ module RDF::RDFXML
           abbr, suffix = attr_name.to_s.split(":")
           if abbr == "xmlns"
             attr_value = self.base.to_s + attr_value if attr_value.match(/^\#/)
-            mappings[suffix] = Namespace.new(attr_value, suffix)
-            @graph.bind(mappings[suffix])
+            mappings[suffix] = attr_value
           end
         end
         mappings
@@ -98,14 +97,13 @@ module RDF::RDFXML
       # Produce the next list entry for this context
       def li_next
         @li_counter += 1
-        predicate = URIRef.new(RDF["_#{@li_counter}"])
+        predicate = RDF["_#{@li_counter}"]
       end
 
       # Set XML base. Ignore any fragment
       def base=(b)
-        b = Addressable::URI.parse(b.to_s)
-        b.fragment = nil
         @base = RDF::URI.new(b)
+        @base.fragment = nil
       end
 
       def inspect
@@ -128,48 +126,87 @@ module RDF::RDFXML
     # @raise [Error]:: Raises RDF::ReaderError if _strict_
     def initialize(input = $stdin, options = {}, &block)
       super do
-        @graph = RDF::Graph.new
         @debug = options[:debug]
         @strict = options[:strict]
-        @base_uri = options[:base_uri]
-        @base_uri = RDF::URI.parse(@base_uri) if @base_uri.is_a?(String)
+        @base_uri = RDF::URI.parse(options[:base_uri]) if options[:base_uri]
+            
+        @id_mapping = Hash.new
 
-        @doc = case stream
-        when Nokogiri::XML::Document then stream
-        else Nokogiri::XML.parse(stream, uri.to_s)
+        @doc = case input
+        when Nokogiri::XML::Document then input
+        else Nokogiri::XML.parse(input, @base_uri.to_s)
         end
         
-        raise RDF::ReaderError, "Empty document" if @doc.nil? && @strict
-        @callback = block
-  
-        # Look for rdf:RDF elements and process each.
-        rdf_nodes = root.xpath("//rdf:RDF", RDF.prefix => RDF.uri.to_s)
-        if rdf_nodes.length == 0
-          # If none found, root element may be processed as an RDF Node
+        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
 
-          ec = EvaluationContext.new(@uri, root, @graph)
-          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(@uri, nil, @graph)
-            ec.extract_from_ancestors(node)
-            node.children.each {|el|
-              next unless el.elem?
-              new_ec = ec.clone(el)
-              nodeElement(el, new_ec)
-            }
-          end
-        end
-        
         block.call(self) if block_given?
       end
     end
 
+    # XXX Invoke the parser, and allow add_triple to make the callback?
+    ##
+    # Iterates the given block for each RDF statement in the input.
+    #
+    # @yield  [statement]
+    # @yieldparam [RDF::Statement] statement
+    # @return [void]
+    def each_statement(&block)
+      # Block called from add_statement
+      @callback = block
+
+      root = @doc.root
+
+      add_debug(root, "base_uri: #{@base_uri || 'nil'}")
+      
+      rdf_nodes = root.xpath("//rdf:RDF", "rdf" => RDF_NS)
+      if rdf_nodes.length == 0
+        # If none found, root element may be processed as an RDF Node
+
+        ec = EvaluationContext.new(@base_uri, root, @graph)
+        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.extract_from_ancestors(node)
+          node.children.each {|el|
+            next unless el.elem?
+            new_ec = ec.clone(el)
+            nodeElement(el, new_ec)
+          }
+        end
+      end
+    end
+
+    ##
+    # Iterates the given block for each RDF triple in the input.
+    #
+    # @yield  [subject, predicate, object]
+    # @yieldparam [RDF::Resource] subject
+    # @yieldparam [RDF::URI]      predicate
+    # @yieldparam [RDF::Value]    object
+    # @return [void]
+    def each_triple(&block)
+      each_statement do |statement|
+        block.call(*statement.to_triple)
+      end
+    end
+    
     private
 
+    # Keep track of allocated BNodes
+    def bnode(value = nil)
+      if value
+        @bnode_cache ||= {}
+        @bnode_cache[value.to_s] ||= RDF::Node.new(value)
+      else
+        RDF::Node.new
+      end
+    end
+    
     # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
     def node_path(node)
       case node
@@ -199,12 +236,7 @@ module RDF::RDFXML
     def add_triple(node, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
       add_debug(node, "statement: #{statement}")
-      @graph << statement
-      statement
-    rescue RDF::ReaderError => e
-      add_debug(node, "add_triple raised #{e.class}: #{e.message}")
-      puts e.backtrace if $DEBUG
-      raise if @strict
+      @callback.call(statement)
     end
 
     # XML nodeElement production
@@ -221,14 +253,14 @@ module RDF::RDFXML
       add_debug(el, "nodeElement, el: #{el.uri}")
       add_debug(el, "nodeElement, subject: #{subject.nil? ? 'nil' : subject.to_s}")
 
-      unless el.uri == RDF.Description.to_s
+      unless el.uri.to_s == RDF.Description.to_s
         add_triple(el, subject, RDF.type, el.uri)
       end
 
       # produce triples for attributes
       el.attribute_nodes.each do |attr|
         add_debug(el, "propertyAttr: #{attr.uri}='#{attr.value}'")
-        if attr.uri == RDF.type
+        if attr.uri.to_s == RDF.type.to_s
           # If there is an attribute a in propertyAttr with a.URI == rdf:type
           # then u:=uri(identifier:=resolve(a.string-value))
           # and the following triple is added to the graph:
@@ -237,7 +269,7 @@ module RDF::RDFXML
         elsif is_propertyAttr?(attr)
           # Attributes not RDF.type
           predicate = attr.uri
-          lit = Literal.untyped(attr.value, ec.language)
+          lit = RDF::Literal.new(attr.value, :language => ec.language)
           add_triple(attr, subject, predicate, lit)
         end
       end
@@ -283,9 +315,9 @@ module RDF::RDFXML
             # MAY choose to warn when the unqualified form is seen in a document.
             add_debug(el, "Unqualified attribute '#{attr}'")
             #attrs[attr.to_s] = attr.value unless attr.to_s.match?(/^xml/)
-          elsif attr.namespace.href == XML_NS.uri.to_s
+          elsif attr.namespace.href == RDF::XML.to_s
             # No production. Lang and base elements already extracted
-          elsif attr.namespace.href == RDF.uri.to_s
+          elsif attr.namespace.href == RDF_NS
             case attr.name
             when "ID"         then id = attr.value
             when "datatype"   then datatype = attr.value
@@ -342,7 +374,7 @@ module RDF::RDFXML
           end
 
           # For element e with possibly empty element content c.
-          n = BNode.new
+          n = bnode
           add_triple(child, subject, predicate, n)
 
           # Reification
@@ -423,16 +455,16 @@ module RDF::RDFXML
             if resourceAttr
               resource = ec.base.join(resourceAttr)
             elsif nodeID
-              resource = RDF::Node.new(nodeID)
+              resource = bnode(nodeID)
             else
-              resource = RDF::Node.new
+              resource = bnode
             end
 
             # produce triples for attributes
             attrs.each_pair do |attr, val|
               add_debug(el, "attr: #{attr.name}='#{val}'")
               
-              if attr.uri.to_s == RDF.type
+              if attr.uri.to_s == RDF.type.to_s
                 add_triple(child, resource, RDF.type, val)
               else
                 # Check for illegal attributes
@@ -463,7 +495,7 @@ module RDF::RDFXML
       add_triple(el, rsubject, RDF.subject, subject)
       add_triple(el, rsubject, RDF.predicate, predicate)
       add_triple(el, rsubject, RDF.object, object)
-      add_triple(el, rsubject, RDF.type, RDF.Statement)
+      add_triple(el, rsubject, RDF.type, RDF["Statement"])
     end
 
     # Figure out the subject from the element.
@@ -491,14 +523,14 @@ module RDF::RDFXML
         # The value of rdf:nodeID must match the XML Name production
         nodeID = nodeID_check(el, nodeID.value.rdf_escape)
         add_debug(el, "parse_subject, nodeID: '#{nodeID}")
-        RDF::Node.new(nodeID, @named_bnodes)
+        bnode(nodeID)
       when about
         about = about.value.rdf_escape
         add_debug(el, "parse_subject, about: '#{about}'")
         ec.base.join(about)
       else
         add_debug(el, "parse_subject, BNode")
-        RDF::Node.new
+        bnode
       end
     end
     
@@ -507,7 +539,8 @@ module RDF::RDFXML
       if NC_REGEXP.match(id)
         # ID may only be specified once for the same URI
         if base
-          uri = base.join("##{id}", 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)
@@ -548,7 +581,7 @@ module RDF::RDFXML
         raise RDF::ReaderError.new(warn) if @strict
         return false
       end
-      !CORE_SYNTAX_TERMS.include?(attr.uri.to_s) && attr.namespace && attr.namespace.href != XML_NS.uri.to_s
+      !CORE_SYNTAX_TERMS.include?(attr.uri.to_s) && attr.namespace && attr.namespace.href != RDF::XML.to_s
     end
     
     # Check Node Element name