gkellogg-reddy 0.2.1

data/lib/reddy/rdfaparser.rb

@@ -0,0 +1,398 @@
+module Reddy
+  ##
+  # An RDFa parser in Ruby
+  #
+  # Based on processing rules described here: http://www.w3.org/TR/rdfa-syntax/#s_model
+  #
+  # Ben Adida
+  # 2008-05-07
+  # Gregg Kellogg
+  # 2009-08-04
+  class RdfaParser < Parser
+    attr_reader :namespace
+
+    # The Recursive Baggage
+    class EvaluationContext # :nodoc:
+      attr :base, true
+      attr :parent_subject, true
+      attr :parent_object, true
+      attr :uri_mappings, true
+      attr :incomplete_triples, true
+      attr :language, true
+
+      def initialize(base)
+        # Initialize the evaluation context, [5.1]
+        @base = base
+        @parent_subject = @base
+        @parent_object = nil
+        @uri_mappings = {}
+        @incomplete_triples = []
+        @language = nil
+      end
+
+      # Copy this Evaluation Context
+      def initialize_copy(from)
+          # clone the evaluation context correctly
+          @uri_mappings = from.uri_mappings.clone
+          @incomplete_triples = from.incomplete_triples.clone
+      end
+      
+      def inspect
+        v = %w(base parent_subject parent_object language).map {|a| "#{a}='#{self.send(a).nil? ? 'nil' : self.send(a)}'"}
+        v << "uri_mappings[#{uri_mappings.keys.length}]"
+        v << "incomplete_triples[#{incomplete_triples.length}]"
+        v.join(",")
+      end
+    end
+
+    # Parse XHTML+RDFa document from a string or input stream to closure or graph.
+    #
+    # Optionally, the stream may be a Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # With a block, yeilds each statement with URIRef, BNode or Literal elements
+    #
+    # @param  [IO] stream:: the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options:: Parser options, one of
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    # @raise [Error]:: Raises RdfError if _strict_
+    #
+    # @author Gregg Kellogg
+    def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      super
+
+      @doc = case stream
+      when Nokogiri::HTML::Document then stream
+      when Nokogiri::XML::Document then stream
+      else   Nokogiri::XML.parse(stream, uri)
+      end
+      
+      raise ParserException, "Empty document" if @doc.nil? && @strict
+      @callback = block
+
+      # If the doc has a default, use that as "html"
+      ns = @doc.namespaces["xmlns"]
+      ns ||= "http://www.w3.org/1999/xhtml" # FIXME: intuite from DOCTYPE, or however
+      @namespace = Namespace.new(ns, "html") if ns
+      
+      # parse
+      parse_whole_document(@doc, @uri)
+
+      @graph
+    end
+    
+    private
+  
+    # Parsing an RDFa document (this is *not* the recursive method)
+    def parse_whole_document(doc, base)
+      # find if the document has a base element
+      base_el = doc.css('html>head>base').first
+      if (base_el)
+        base = base_el.attributes['href']
+        # Strip any fragment from base
+        base = base.to_s.split("#").first
+        add_debug(base_el, "parse_whole_doc: base='#{base}'")
+      end
+
+      # initialize the evaluation context with the appropriate base
+      evaluation_context= EvaluationContext.new(base)
+
+      traverse(doc.root, evaluation_context)
+    end
+  
+    # Extract the XMLNS mappings from an element
+    def extract_mappings(element)
+      mappings = {}
+    
+      # look for xmlns
+      element.namespaces.each do |attr_name,attr_value|
+        begin
+          abbr, suffix = attr_name.split(":")
+          mappings[suffix] = @graph.bind(Namespace.new(attr_value, suffix)) if abbr == "xmlns"
+        rescue RdfException => e
+          add_debug(element, "extract_mappings raised #{e.class}: #{e.message}")
+          raise if @strict
+        end
+      end
+
+      add_debug(element, "mappings: #{mappings.keys.join(", ")}")
+      mappings
+    end
+
+    # The recursive helper function
+    def traverse(element, evaluation_context)
+      if element.nil?
+        add_debug(element, "traverse nil element")
+        raise ParserException, "Can't parse nil element" if @strict
+        return nil
+      end
+      
+      # local variables [5.5 Step 1]
+      recurse = true
+      skip = false
+      new_subject = nil
+      current_object_resource = nil
+      uri_mappings = evaluation_context.uri_mappings.clone
+      incomplete_triples = []
+      language = evaluation_context.language
+    
+      # shortcut
+      attrs = element.attributes
+
+      about = attrs['about']
+      src = attrs['src']
+      resource = attrs['resource']
+      href = attrs['href']
+
+      # Pull out the attributes needed for the skip test.
+      property = attrs['property'].to_s if attrs['property']
+      typeof = attrs['typeof'].to_s if attrs['typeof']
+      datatype = attrs['datatype'].to_s if attrs['datatype']
+      content = attrs['content'].to_s if attrs['content']
+      rel = attrs['rel'].to_s if attrs['rel']
+      rev = attrs['rev'].to_s if attrs['rev']
+
+      # SPEC CONFUSION: not sure what to initialize this value to
+      current_object_literal = nil
+
+      # XMLNS mappings [5.5 Step 2]
+      uri_mappings.merge!(extract_mappings(element))
+    
+      # Language information [5.5 Step 3]
+      add_debug(element, "traverse, lang: #{attrs['lang']}") if attrs['lang']
+      language = attrs['lang'] || language
+    
+      # rels and revs
+      rels = parse_curies(rel, uri_mappings, evaluation_context.base, true)
+      revs = parse_curies(rev, uri_mappings, evaluation_context.base, true)
+      valid_rel_or_rev = !(rel.nil? && rev.nil?)
+    
+      add_debug(element, "traverse, ec: #{evaluation_context.inspect}")
+      add_debug(element, "traverse, about: #{about.nil? ? 'nil' : about}, src: #{src.nil? ? 'nil' : src}, resource: #{resource.nil? ? 'nil' : resource}, href: #{href.nil? ? 'nil' : href}")
+      add_debug(element, "traverse, property: #{property.nil? ? 'nil' : property}, typeof: #{typeof.nil? ? 'nil' : typeof}, datatype: #{datatype.nil? ? 'nil' : datatype}, content: #{content.nil? ? 'nil' : content}")
+      add_debug(element, "traverse, rels: #{rels.join(" ")}, revs: #{revs.join(" ")}")
+
+      if not valid_rel_or_rev
+        # Establishing a new subject if no valid rel/rev [5.5 Step 4]
+        if about
+          new_subject = uri_or_safe_curie(about, evaluation_context, uri_mappings)
+        elsif src
+          new_subject = URIRef.new(src, evaluation_context.base)
+        elsif resource
+          new_subject =  uri_or_safe_curie(resource, evaluation_context, uri_mappings)
+        elsif href
+          new_subject = URIRef.new(href, evaluation_context.base)
+        end
+
+        # SPEC CONFUSION: not sure what "If no URI is provided by a resource attribute" means, I assume 
+        # it means that new_subject is still null
+        if new_subject.nil?
+          if element.name =~ /^(head|body)$/
+            new_subject = URIRef.new(evaluation_context.base)
+          elsif element.attributes['typeof']
+            new_subject = BNode.new
+          else
+            # if it's null, it's null and nothing changes
+            new_subject = evaluation_context.parent_object
+            skip = true unless property
+          end
+        end
+        add_debug(element, "new_subject: #{new_subject}, skip = #{skip}")
+      else
+        # Establish both new subject and current object resource [5.5 Step 5]
+      
+        if about
+          new_subject =  uri_or_safe_curie(about, evaluation_context, uri_mappings)
+        elsif src
+          new_subject =  uri_or_safe_curie(src, evaluation_context, uri_mappings)
+        end
+      
+        # If no URI is provided then the first match from the following rules will apply
+        if new_subject.nil?
+          if element.name =~ /^(head|body)$/
+            new_subject = URIRef.new(evaluation_context.base)
+          elsif element.attributes['typeof']
+            new_subject = BNode.new
+          else
+            # if it's null, it's null and nothing changes
+            new_subject = evaluation_context.parent_object
+            # no skip flag set this time
+          end
+        end
+      
+        if resource
+          current_object_resource =  uri_or_safe_curie(resource, evaluation_context, uri_mappings)
+        elsif href
+          current_object_resource = URIRef.new(href, evaluation_context.base)
+        end
+
+        add_debug(element, "new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
+      end
+    
+      # Process @typeof if there is a subject [Step 6]
+      if new_subject and typeof
+        types = parse_curies(typeof, uri_mappings, evaluation_context.base, false)
+        add_debug(element, "typeof: #{typeof}")
+        types.each do |one_type|
+          add_triple(element, new_subject, RDF_TYPE, one_type)
+        end
+      end
+    
+      # Generate triples with given object [Step 7]
+      if current_object_resource
+        rels.each do |rel|
+          add_triple(element, new_subject, rel, current_object_resource)
+        end
+      
+        revs.each do |rev|
+          add_triple(element, current_object_resource, rev, new_subject)
+        end
+      else
+        # Incomplete triples and bnode creation [Step 8]
+        add_debug(element, "step 8: valid: #{valid_rel_or_rev}, rels: #{rels}, revs: #{revs}")
+        current_object_resource = BNode.new if valid_rel_or_rev
+      
+        rels.each do |rel|
+          # SPEC CONFUSION: we don't store the subject here?
+          incomplete_triples << {:predicate => rel, :direction => :forward}
+        end
+      
+        revs.each do |rev|
+          # SPEC CONFUSION: we don't store the object here?
+          incomplete_triples << {:predicate => rev, :direction => :reverse}
+        end
+
+      end
+    
+      # Establish current object literal [Step 9]
+      if property
+        properties = parse_curies(property, uri_mappings, evaluation_context.base, false)
+
+        # get the literal datatype
+        type = datatype
+        children_node_types = element.children.collect{|c| c.class}.uniq
+      
+        # the following 3 IF clauses should be mutually exclusive. Written as is to prevent extensive indentation.
+      
+        # SPEC CONFUSION: have to special case XML Literal, not clear right away.
+        # SPEC CONFUSION: specify that the conditions are in order of priority
+        type_resource = curie_to_resource_or_bnode(type, uri_mappings, evaluation_context.base) if type
+        if type and !type.empty? and (type_resource.to_s != XML_LITERAL.to_s)
+          # typed literal
+          add_debug(element, "typed literal")
+          current_object_literal = Literal.typed(content || element.inner_text, type_resource, :language => language)
+        elsif content or (children_node_types == [Nokogiri::XML::Text]) or (element.children.length == 0) or (type == '')
+          # plain literal
+          add_debug(element, "plain literal")
+          current_object_literal = Literal.untyped(content || element.inner_text, language)
+        elsif children_node_types != [Nokogiri::XML::Text] and (type == nil or type_resource.to_s == XML_LITERAL.to_s)
+          # XML Literal
+          add_debug(element, "XML Literal: #{element.inner_html}")
+          current_object_literal = Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => uri_mappings)
+          recurse = false
+        end
+      
+        # add each property
+        properties.each do |property|
+          add_triple(element, new_subject, property, current_object_literal)
+        end
+      
+        # SPEC CONFUSION: "the triple has been created" ==> there may be more than one
+        # set the recurse flag above in the IF about xmlliteral, as it is the only place that can happen
+      end
+    
+      # Complete the incomplete triples from the evaluation context [Step 10]
+      add_debug(element, "10: skip=#{skip}, new_subject=#{new_subject}")
+      if not skip and new_subject
+        evaluation_context.incomplete_triples.each do |trip|
+          if trip[:direction] == :forward
+            add_triple(element, evaluation_context.parent_subject, trip[:predicate], new_subject)
+          elsif trip[:direction] == :reverse
+            add_triple(element, new_subject, trip[:predicate], evaluation_context.parent_subject)
+          end
+        end
+      end
+    
+      # Create a new evaluation context and proceed recursively [Step 11]
+      if recurse
+        # SPEC CONFUSION: new evaluation context for each child? Probably not necessary,
+        # but maybe needs to be pointed out?
+
+        if skip
+          new_ec = evaluation_context.clone
+          new_ec.language = language
+          new_ec.uri_mappings = uri_mappings
+          add_debug(element, "skip: cloned ec: #{evaluation_context.inspect}")
+        else
+          # create a new evaluation context
+          new_ec = EvaluationContext.new(evaluation_context.base)
+          new_ec.parent_subject = new_subject || evaluation_context.parent_subject
+          new_ec.parent_object = current_object_resource || new_subject || evaluation_context.parent_subject
+          new_ec.uri_mappings = uri_mappings
+          new_ec.incomplete_triples = incomplete_triples
+          new_ec.language = language
+          #add_debug(element, "new ec: #{new_ec.inspect}")
+        end
+      
+        element.children.each do |child|
+          # recurse only if it's an element
+          traverse(child, new_ec) if child.class == Nokogiri::XML::Element
+        end
+      end
+    end
+    
+    # space-separated CURIEs or Link Types
+    def parse_curies(value, uri_mappings, base, with_link_types=false)
+      return [] unless value
+      resource_array = []
+      value.to_s.split(' ').each do |curie|
+        if curie.include?(":")
+          resource_array << curie_to_resource_or_bnode(curie, uri_mappings, base)
+        elsif with_link_types
+          # Reserved words are all mapped to lower case
+          curie = curie.to_s.downcase
+          link_type_curie = curie_to_resource_or_bnode(":#{curie}", XH_MAPPING, base) if LINK_TYPES.include?(curie)
+          resource_array << link_type_curie if link_type_curie
+        end
+      end
+      resource_array
+    end
+
+    def curie_to_resource_or_bnode(curie, uri_mappings, subject)
+      # URI mappings for CURIEs default to XH_MAPPING, rather than the default doc namespace
+      uri_mappings = uri_mappings.merge(XH_MAPPING)
+      prefix, suffix = curie.to_s.split(":")
+
+      # consider the bnode situation
+      if prefix == "_"
+        # we force a non-nil name, otherwise it generates a new name
+        BNode.new(suffix || "", @named_bnodes)
+      elsif curie.to_s.empty?
+        add_debug(nil, "curie_to_resource_or_bnode #{URIRef.new(subject)}")
+        # Empty curie resolves to current subject (No, an empty curie should be ignored)
+#        URIRef.new(subject)
+        nil
+      else
+        ns = uri_mappings[prefix.to_s]
+        unless ns
+          add_debug(nil, "curie_to_resource_or_bnode No namespace mapping for #{prefix}")
+          raise ParserException, "No namespace mapping for #{prefix}" if @strict
+          return nil
+        end
+        ns + suffix
+      end
+    end
+
+    def uri_or_safe_curie(value, evaluation_context, uri_mappings)
+      return nil if value.nil?
+      
+      # check if the value is [foo:bar]
+      if value.to_s.match(/^\[(.*)\]$/)
+        curie_to_resource_or_bnode($1, uri_mappings, evaluation_context.parent_subject)
+      else
+        URIRef.new(value, evaluation_context.base)
+      end
+    end
+  end
+end

data/lib/reddy/rdfxmlparser.rb

@@ -0,0 +1,529 @@
+#require 'ruby-debug'
+require 'xml'
+
+module Reddy
+  class RdfXmlParser < Parser
+    CORE_SYNTAX_TERMS = %w(RDF ID about parseType resource nodeID datatype).map {|n| "http://www.w3.org/1999/02/22-rdf-syntax-ns##{n}"}
+    OLD_TERMS = %w(aboutEach aboutEachPrefix bagID).map {|n| "http://www.w3.org/1999/02/22-rdf-syntax-ns##{n}"}
+
+    # The Recursive Baggage
+    class EvaluationContext # :nodoc:
+      attr_reader :base
+      attr :subject, true
+      attr :uri_mappings, true
+      attr :language, true
+      attr :graph, true
+      attr :li_counter, true
+
+      def initialize(base, element, graph)
+        # Initialize the evaluation context, [5.1]
+        self.base = base
+        @uri_mappings = {}
+        @language = nil
+        @graph = graph
+        @li_counter = 0
+        @uri_mappings = {}
+
+        extract_from_element(element) if element
+      end
+      
+      # Clone existing evaluation context adding information from element
+      def clone(element, options = {})
+        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
+        
+        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)
+        ancestors = el.ancestors
+        while ancestors.length > 0
+          a = ancestors.pop
+          next unless a.element?
+          extract_from_element(a)
+        end
+        extract_from_element(el)
+      end
+
+      # 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)
+        self.base = URIRef.new(b, self.base)
+        self.language = lang if lang
+        self.uri_mappings.merge!(extract_mappings(el))
+      end
+      
+      # Extract the XMLNS mappings from an element
+      def extract_mappings(element)
+        mappings = {}
+
+        # look for xmlns
+        element.namespaces.each do |attr_name,attr_value|
+          abbr, suffix = attr_name.to_s.split(":")
+          if abbr == "xmlns"
+            mappings[suffix] = Namespace.new(attr_value, suffix)
+            @graph.bind(mappings[suffix])
+          end
+        end
+        mappings
+      end
+      
+      # Produce the next list entry for this context
+      def li_next(predicate)
+        @li_counter += 1
+        predicate = Addressable::URI.parse(predicate.to_s)
+        predicate.fragment = "_#{@li_counter}"
+        predicate = URIRef.new(predicate)
+      end
+
+      # Set XML base. Ignore any fragment
+      def base=(b)
+        b = Addressable::URI.parse(b.to_s)
+        b.fragment = nil
+        @base = b.to_s
+      end
+
+      def inspect
+        v = %w(base subject language).map {|a| "#{a}='#{self.send(a).nil? ? 'nil' : self.send(a)}'"}
+        v << "uri_mappings[#{uri_mappings.keys.length}]"
+        v.join(",")
+      end
+    end
+
+    # Parse RDF/XML document from a string or input stream to closure or graph.
+    #
+    # Optionally, the stream may be a string or Nokogiri::XML::Document
+    # With a block, yeilds each statement with URIRef, BNode or Literal elements
+    # 
+    # @param [IO] stream:: the RDF/XML IO stream, string or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options:: Parser options, one of
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    # @raise [Error]:: Raises RdfError if _strict_
+    #
+    # @author Gregg Kellogg
+    def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      super
+
+      @doc = case stream
+      when Nokogiri::XML::Document then stream
+      else   Nokogiri::XML.parse(stream, uri)
+      end
+      
+      @id_mapping = Hash.new
+
+      raise ParserException, "Empty document" if @doc.nil? && @strict
+      @callback = block
+      
+      root = @doc.root
+      
+      # Look for rdf:RDF elements and process each.
+      rdf_nodes = root.xpath("//rdf:RDF", RDF_NS.prefix => RDF_NS.uri.to_s)
+      if rdf_nodes.length == 0
+        # If none found, root element may be processed as an RDF Node
+
+        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
+
+      @graph
+    end
+  
+    private
+    # Is the node rdf:RDF?
+    def is_rdf_root? (node)
+      node.name == "RDF" && node.namespace.href == RDF_NS.uri.to_s
+    end
+    
+    # XML nodeElement production
+    #
+    # @param [XML Element] el:: XMl Element to parse
+    # @param [EvaluationContext] ec:: Evaluation context
+    # @return [URIRef] subject:: The subject found for the node
+    # @raise [RdfException]:: Raises Exception if _strict_
+    #
+    # @author Gregg Kellogg
+    def nodeElement(el, ec)
+      # subject
+      subject = ec.subject || parse_subject(el, ec)
+      
+      add_debug(el, "nodeElement, ec: #{ec.inspect}")
+      add_debug(el, "nodeElement, el: #{el.uri}")
+      add_debug(el, "nodeElement, subject: #{subject.nil? ? 'nil' : subject.to_s}")
+
+      unless el.uri == RDF_NS.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 there is an attribute a in propertyAttr with a.URI == rdf:type
+          # then u:=uri(identifier:=resolve(a.string-value))
+          # and the following tiple is added to the graph:
+          u = URIRef.new(attr.value, ec.base)
+          add_triple(attr, subject, RDF_TYPE, u)
+        elsif is_propertyAttr?(attr)
+          # Attributes not RDF_TYPE
+          predicate = attr.uri
+          lit = Literal.untyped(attr.value, ec.language)
+          add_triple(attr, subject, predicate, lit)
+        end
+      end
+      
+      # Handle the propertyEltList children events in document order
+      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)
+        predicate = child.uri
+        add_debug(child, "propertyElt, predicate: #{predicate}")
+        propertyElementURI_check(child)
+        
+        # Determine the content type of this property element
+        text_nodes = child.children.select {|e| e.text? && !e.blank?}
+        element_nodes = child.children.select(&:element?)
+
+        # List expansion
+        predicate = ec.li_next(predicate) if predicate == RDF_NS.li
+        
+        # Productions based on set of attributes
+        
+        # All remaining reserved XML Names (See Name in XML 1.0) are now removed from the set.
+        # These are, all attribute information items in the set with property [prefix] beginning with xml
+        # (case independent comparison) and all attribute information items with [prefix] property having
+        # no value and which have [local name] beginning with xml (case independent comparison) are removed.
+        # Note that the [base URI] accessor is computed by XML Base before any xml:base attribute information item
+        # is deleted.
+        attrs = {}
+        id = datatype = parseType = resourceAttr = nodeID = nil
+        
+        child.attribute_nodes.each do |attr|
+          if attr.namespace.to_s.empty?
+            # The support for a limited set of non-namespaced names is REQUIRED and intended to allow
+            # RDF/XML documents specified in [RDF-MS] to remain valid;
+            # new documents SHOULD NOT use these unqualified attributes and applications
+            # 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
+            # No production. Lang and base elements already extracted
+          elsif attr.namespace.href == RDF_NS.uri.to_s
+            case attr.name
+            when "ID"         then id = attr.value
+            when "datatype"   then datatype = attr.value
+            when "parseType"  then parseType = attr.value
+            when "resource"   then resourceAttr = attr.value
+            when "nodeID"     then nodeID = attr.value
+            else                   attrs[attr] = attr.value
+            end
+          else
+            attrs[attr] = attr.value
+          end
+        end
+        
+        if nodeID && resourceAttr
+          add_debug(el, "Cannot have rdf:nodeID and rdf:resource.")
+          raise ParserException.new("Cannot have rdf:nodeID and rdf:resource.") if @strict
+        end
+
+        # Apply character transformations
+        id = id_check(el, id.rdf_escape, nil) if id
+        resourceAttr = resourceAttr.rdf_escape if resourceAttr
+        nodeID = nodeID_check(el, nodeID.rdf_escape) if nodeID
+
+        add_debug(el, "attrs: #{attrs.inspect}")
+        add_debug(el, "datatype: #{datatype}") if datatype
+        add_debug(el, "parseType: #{parseType}") if parseType
+        add_debug(el, "resource: #{resourceAttr}") if resourceAttr
+        add_debug(el, "nodeID: #{nodeID}") if nodeID
+        add_debug(el, "id: #{id}") if id
+        
+        if attrs.empty? && datatype.nil? && parseType.nil? && element_nodes.length == 1
+          # Production resourcePropertyElt
+
+          new_ec = child_ec.clone(nil)
+          new_node_element = element_nodes.first
+          add_debug(child, "resourcePropertyElt: #{node_path(new_node_element)}")
+          new_subject = nodeElement(new_node_element, new_ec)
+          add_triple(child, subject, predicate, new_subject)
+        elsif attrs.empty? && parseType.nil? && element_nodes.length == 0 && text_nodes.length > 0
+          # Production literalPropertyElt
+          add_debug(child, "literalPropertyElt")
+          
+          literal = datatype ? Literal.typed(child.inner_html, datatype) : Literal.untyped(child.inner_html, child_ec.language)
+          add_triple(child, subject, predicate, literal)
+          reify(id, child, subject, predicate, literal, ec) if id
+        elsif parseType == "Resource"
+          # Production parseTypeResourcePropertyElt
+          add_debug(child, "parseTypeResourcePropertyElt")
+
+          unless attrs.empty?
+            warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
+            add_debug(child, warn)
+            raise ParserException.new(warn) if @strict
+          end
+
+          # For element e with possibly empty element content c.
+          n = BNode.new
+          add_triple(child, subject, predicate, n)
+
+          # Reification
+          reify(id, child, subject, predicate, n, child_ec) if id
+          
+          # If the element content c is not empty, then use event n to create a new sequence of events as follows:
+          #
+          # start-element(URI := rdf:Description,
+          #     subject := n,
+          #     attributes := set())
+          # c
+          # end-element()
+          add_debug(child, "compose new sequence with rdf:Description")
+          node = child.clone
+          pt_attr = node.attribute("parseType")
+          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)
+          nodeElement(node, new_ec)
+        elsif parseType == "Collection"
+          # Production parseTypeCollectionPropertyElt
+          add_debug(child, "parseTypeCollectionPropertyElt")
+
+          unless attrs.empty?
+            warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
+            add_debug(child, warn)
+            raise ParserException.new(warn) if @strict
+          end
+
+          # For element event e with possibly empty nodeElementList l. Set s:=list().
+          # For each element event f in l, n := bnodeid(identifier := generated-blank-node-id()) and append n to s to give a sequence of events.
+          s = element_nodes.map { BNode.new }
+          n = s.first || RDF_NS.send("nil")
+          add_triple(child, subject, predicate, n)
+          reify(id, child, subject, predicate, n, child_ec) if id
+          
+          # Add first/rest entries for all list elements
+          s.each_index do |i|
+            n = s[i]
+            o = s[i+1]
+            f = element_nodes[i]
+
+            new_ec = child_ec.clone(nil)
+            object = nodeElement(f, new_ec)
+            add_triple(child, n, RDF_NS.first, object)
+            add_triple(child, n, RDF_NS.rest, o ? o : RDF_NS.nil)
+          end
+        elsif parseType   # Literal or Other
+          # Production parseTypeResourcePropertyElt
+          add_debug(child, parseType == "Literal" ? "parseTypeResourcePropertyElt" : "parseTypeOtherPropertyElt (#{parseType})")
+
+          unless attrs.empty?
+            warn = "Resource Property with extra attributes: '#{attrs.inspect}'"
+            add_debug(child, warn)
+            raise ParserException.new(warn) if @strict
+          end
+
+          if resourceAttr
+            warn = "illegal rdf:resource"
+            add_debug(child, warn)
+            raise ParserException.new(warn) if @strict
+          end
+
+          object = Literal.typed(child.children, XML_LITERAL, :namespaces => child_ec.uri_mappings)
+          add_triple(child, subject, predicate, object)
+        elsif text_nodes.length == 0 && element_nodes.length == 0
+          # Production emptyPropertyElt
+          add_debug(child, "emptyPropertyElt")
+
+          if attrs.empty? && resourceAttr.nil? && nodeID.nil?
+            literal = Literal.untyped("", ec.language)
+            add_triple(child, subject, predicate, literal)
+            
+            # Reification
+            reify(id, child, subject, predicate, literal, child_ec) if id
+          else
+            if resourceAttr
+              resource = URIRef.new(resourceAttr, ec.base)
+            elsif nodeID
+              resource = BNode.new(nodeID, @named_bnodes)
+            else
+              resource = BNode.new
+            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
+                add_triple(child, resource, RDF_TYPE, val)
+              else
+                # Check for illegal attributes
+                next unless is_propertyAttr?(attr)
+
+                # Attributes not in RDF_TYPE
+                lit = Literal.untyped(val, child_ec.language)
+                add_triple(child, resource, attr.uri.to_s, lit)
+              end
+            end
+            add_triple(child, subject, predicate, resource)
+            
+            # Reification
+            reify(id, child, subject, predicate, resource, child_ec) if id
+          end
+        end
+      end
+      
+      # Return subject
+      subject
+    end
+    
+    private
+    # Reify subject, predicate, and object given the EvaluationContext (ec) and current XMl element (el)
+    def reify(id, el, subject, predicate, object, ec)
+      add_debug(el, "reify, id: #{id}")
+      rsubject = URIRef.new("#" + id, ec.base)
+      add_triple(el, rsubject, RDF_NS.subject, subject)
+      add_triple(el, rsubject, RDF_NS.predicate, predicate)
+      add_triple(el, rsubject, RDF_NS.object, object)
+      add_triple(el, rsubject, RDF_TYPE, RDF_NS.Statement)
+    end
+
+    # Figure out the subject from the element.
+    def parse_subject(el, ec)
+      old_property_check(el)
+      
+      nodeElementURI_check(el)
+      about = el.attribute("about")
+      id = el.attribute("ID")
+      nodeID = el.attribute("nodeID")
+      
+      if nodeID && about
+        add_debug(el, "Cannot have rdf:nodeID and rdf:about.")
+        raise ParserException.new("Cannot have rdf:nodeID and rdf:about.") if @strict
+      elsif nodeID && id
+        add_debug(el, "Cannot have rdf:nodeID and rdf:ID.")
+        raise ParserException.new("Cannot have rdf:nodeID and rdf:ID.") if @strict
+      end
+
+      case
+      when id
+        add_debug(el, "parse_subject, id: '#{id.value.rdf_escape}'")
+        id_check(el, id.value.rdf_escape, ec.base) # Returns URI
+      when nodeID
+        # 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}")
+        BNode.new(nodeID, @named_bnodes)
+      when about
+        about = about.value.rdf_escape
+        add_debug(el, "parse_subject, about: '#{about}'")
+        URIRef.new(about, ec.base)
+      else
+        add_debug(el, "parse_subject, BNode")
+        BNode.new
+      end
+    end
+    
+    # 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
+          uri = URIRef.new("##{id}", base)
+          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 Reddy::ParserException.new(warn) if @strict
+          end
+          
+          @id_mapping[id] = uri
+          # Returns URI, in this case
+        else
+          id
+        end
+      else
+        warn = "ID addtribute '#{id}' must be a NCName"
+        add_debug(el, "ID addtribute '#{id}' must be a NCName")
+        add_debug(el, warn)
+        raise Reddy::ParserException.new(warn) if @strict
+        nil
+      end
+    end
+    
+    # nodeID must be an XML Name
+    # nodeID must pass Production rdf-id
+    def nodeID_check(el, nodeID)
+      if NC_REGEXP.match(nodeID)
+        nodeID
+      else
+        add_debug(el, "nodeID addtribute '#{nodeID}' must be an XML Name")
+        raise Reddy::ParserException.new("nodeID addtribute '#{nodeID}' must be a NCName") if @strict
+        nil
+      end
+    end
+    
+    # Is this attribute a Property Attribute?
+    def is_propertyAttr?(attr)
+      if ([RDF_NS.Description.to_s, RDF_NS.li.to_s] + OLD_TERMS).include?(attr.uri.to_s)
+        warn = "Invalid use of rdf:#{attr.name}"
+        add_debug(attr, warn)
+        raise InvalidPredicate.new(warn) if @strict
+        return false
+      end
+      !CORE_SYNTAX_TERMS.include?(attr.uri.to_s) &&
+      attr.namespace.href != XML_NS.uri.to_s
+    end
+    
+    # Check Node Element name
+    def nodeElementURI_check(el)
+      if (CORE_SYNTAX_TERMS + [RDF_NS.li.to_s] + OLD_TERMS).include?(el.uri.to_s)
+        warn = "Invalid use of rdf:#{el.name}"
+        add_debug(el, warn)
+        raise InvalidSubject.new(warn) if @strict
+      end
+    end
+
+    # Check Property Element name
+    def propertyElementURI_check(el)
+      if (CORE_SYNTAX_TERMS + [RDF_NS.Description.to_s] + OLD_TERMS).include?(el.uri.to_s)
+        warn = "Invalid use of rdf:#{el.name}"
+        add_debug(el, warn)
+        raise InvalidPredicate.new(warn) if @strict
+      end
+    end
+
+    # Check for the use of an obsolete RDF property
+    def old_property_check(el)
+      el.attribute_nodes.each do |attr|
+        if OLD_TERMS.include?(attr.uri.to_s)
+          add_debug(el, "Obsolete attribute '#{attr.uri}'")
+          raise InvalidPredicate.new("Obsolete attribute '#{attr.uri}'") if @strict
+        end
+      end
+    end
+    
+  end
+end