rdf-rdfa 0.3.7 → 0.3.8

data/README

@@ -11,7 +11,7 @@ RDF::RDFa parses [RDFa][RDFa 1.1 Core] into statements or triples.
 * Fully compliant RDFa 1.1 parser.
 * Template-based Writer to generate XHTML+RDFa.
   * Writer uses user-replacable [Haml][Haml]-based templates to generate RDFa.
-* Uses Nokogiri for parsing HTML/SVG
+* If available, Uses Nokogiri for parsing HTML/SVG, falls back to REXML otherwise (and for JRuby)
 * [RDFa tests][RDFa-test-suite] use SPARQL for most tests due to Rasqal limitations. Other tests compare directly against N-triples.
 
 Install with 'gem install rdf-rdfa'
@@ -20,6 +20,10 @@ Install with 'gem install rdf-rdfa'
 RDFa is an evolving standard, undergoing some substantial recent changes partly due to perceived competition
 with Microdata. As a result, the RDF Webapps working group is currently looking at changes in the processing model for RDFa. These changes are now being tracked in {RDF::RDFa::Reader}:
 
+#### RDFa 1.1 Lite
+This version fully supports the limited syntax of [RDFa Lite 1.1][]. This includes the ability to use
+@property exclusively.
+
 #### Remove RDFa Profiles
 RDFa Profiles were a mechanism added to allow groups of terms and prefixes to be defined in an external resource and loaded to affect the processing of an RDFa document. This introduced a problem for some implementations needing to perform a cross-origin GET in order to retrieve the profiles. The working group elected to drop support for user-defined RDFa Profiles (the default profiles defined by RDFa Core and host languages still apply) and replace it with an inference regime using vocabularies. Parsing of @profile has been removed from this version.
 
@@ -81,6 +85,66 @@ defines a playlist with an ordered set of tracks. RDFa adds the @inlist attribut
 
 This basically does the same thing, but places each track in an rdf:List in the defined order.
 
+#### Property relations
+The @property attribute has been updated to allow for creating URI references as well as object literals.
+
+1. If an element contains @property but no @rel, @datatype or @content and it contains a resource attribute (such as @href, @src, or @resource)
+    1. Generate an IRI object. Furthermore, sub-elements do not chain, i.e., the subject in effect when the @property is processed is also in effect for sub-elements.
+    2. Otherwise, generate a literal as before.
+
+For example:
+
+    <a vocab="http://schema.org" property="url" href="http://example.com">
+      <span property="title">NBA Eastern Conference ...</span>
+    </a>
+
+results in
+
+    <> schema:url <http://example.com>;
+       schema:title "NBA Eastern Conference".
+
+#### Magnetic @about/@typeof
+The @typeof attribute has changed; previously, it always created a new subject, either using a resource from @about, @resource and so forth. This has long been a source of errors for people using RDFa. The new rules cause @typeof to bind to a subject if used with @about, otherwise, to an object, if either used alone, or in combination with some other resource attribute (such as @href, @src or @resource).
+
+For example:
+
+  <div typeof="foaf:Person" about="http://greggkellogg.net/foaf#me">
+    <p property="name">Gregg Kellogg</span>
+    <a rel="knows" typeof="foaf:Person" href="http://manu.sporny.org/#this">
+      <span property="name">Manu Sporny</span>
+    </a>
+  </div>
+
+results in
+
+    <http://greggkellogg.net/foaf#me> a foaf:Person;
+      foaf:name "Gregg Kellogg";
+      foaf:knows <http://manu.sporny.org/#this> .
+    <http://manu.sporny.org/#this> a foaf:Person;
+      foaf:name "Manu Sporny" .
+
+Note that if the explicit @href is not present, i.e.,
+
+    <div typeof="foaf:Person" about="http://greggkellogg.net/foaf#me">
+      <p property="name">Gregg Kellogg</span>
+      <a href="knows" typeof="foaf:Person">
+        <span property="name">Manu Sporny</span>
+      </a>
+    </div>
+
+this results in
+
+    <http://greggkellogg.net/foaf#me> a foaf:Person;
+      foaf:name "Gregg Kellogg";
+      foaf:knows [ 
+            a foaf:Person;
+            foaf:name "Manu Sporny" 
+      ].
+
+
+#### Property chaining
+If used without @rel, but with @typeof and a resource attribute, @property will cause chaining to another object just like @rel. The effect of this and other changes is to allow pretty much all RDFa to be marked up using just @property; @rel/@rev is no longer required. Although, @rel and @rev have useful features that @property does not, so it's worth keeping them in your toolkit.
+
 ## Usage
 
 ### Reading RDF data in the RDFa format
@@ -297,9 +361,11 @@ The template hash defines four Haml templates:
     }
 
 ## Dependencies
+* [Ruby](http://ruby-lang.org/) (>= 1.9) or (>= 1.8.1 with [Backports][])
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.1)
-* [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
 * [Haml](https://rubygems.org/gems/haml) (>= 3.0.0)
+* [HTMLEntities](https://rubygems.org/gems/htmlentities) ('>= 4.3.0')
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
 
 ## Documentation
 Full documentation available on [Rubydoc.info][RDFa doc]
@@ -313,6 +379,8 @@ Full documentation available on [Rubydoc.info][RDFa doc]
   * {RDF::RDFa::SVG}
     Asserts :svg format, image/svg+xml mime-type and .svg file extension.
 * {RDF::RDFa::Reader}
+  * {RDF::RDFa::Reader::Nokogiri}
+  * {RDF::RDFa::Reader::REXML}
 * {RDF::RDFa::Profile}
 * {RDF::RDFa::Writer}
 
@@ -373,6 +441,7 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
 [RDFa 1.1 Core]:    http://www.w3.org/TR/2011/WD-rdfa-core-20110331/     "RDFa 1.1 Core"
+[RDFa Lite 1.1]:    http://www.w3.org/2010/02/rdfa/drafts/2011/ED-rdfa-lite-20111030/   "RDFa Lite 1.1"
 [XHTML+RDFa 1.1]:   http://www.w3.org/TR/2011/WD-xhtml-rdfa-20110331/   "XHTML+RDFa 1.1"
 [RDFa-test-suite]:  http://rdfa.digitalbazaar.com/test-suite/           "RDFa test suite"
 [RDFa doc]:         http://rubydoc.info/github/gkellogg/rdf-rdfa/frames

data/VERSION

@@ -1 +1 @@
-0.3.7
+0.3.8

data/lib/rdf/rdfa.rb

@@ -25,8 +25,6 @@ module RDF
   module RDFa
     require 'rdf/rdfa/format'
     require 'rdf/rdfa/vocab'
-    require 'rdf/rdfa/patches/literal_hacks'
-    require 'rdf/rdfa/patches/nokogiri_hacks'
     require 'rdf/rdfa/patches/string_hacks'
     autoload :Expansion,  'rdf/rdfa/expansion'
     autoload :Profile,    'rdf/rdfa/profile'

data/lib/rdf/rdfa/reader.rb

@@ -1,10 +1,24 @@
-require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
+begin
+  raise LoadError, "not with java" if RUBY_PLATFORM == "java"
+  require 'nokogiri'
+rescue LoadError => e
+  :rexml
+end
 require 'rdf/ntriples'
+require 'rdf/xsd'
 
 module RDF::RDFa
   ##
   # An RDFa parser in Ruby
   #
+  # This class supports [Nokogiri][] for HTML
+  # processing, and will automatically select the most performant
+  # implementation (Nokogiri or LibXML) that is available. If need be, you
+  # can explicitly override the used implementation by passing in a
+  # `:library` option to `Reader.new` or `Reader.open`.
+  #
+  # [Nokogiri]: http://nokogiri.org/
+  #
   # Based on processing rules described here:
   # @see http://www.w3.org/TR/rdfa-syntax/#s_model RDFa 1.0
   # @see http://www.w3.org/TR/2011/WD-rdfa-core-20110331/ RDFa Core 1.1
@@ -174,7 +188,7 @@ module RDF::RDFa
       
       def inspect
         v = ['base', 'parent_subject', 'parent_object', 'language', 'default_vocabulary'].map do |a|
-          "#{a}='#{self.send(a).inspect}'"
+          "#{a}=#{self.send(a).inspect}"
         end
         v << "uri_mappings[#{uri_mappings.keys.length}]"
         v << "incomplete_triples[#{incomplete_triples.length}]"
@@ -184,27 +198,22 @@ module RDF::RDFa
       end
     end
 
+    # Returns the XML implementation module for this reader instance.
+    #
+    # @attr_reader [Module]
+    attr_reader :implementation
+
     ##
     # Initializes the RDFa reader instance.
     #
-    # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, IO, File, String] input
+    # @param  [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
+    #   any additional options (see `RDF::Reader#initialize`)
+    # @option options [Symbol] :library
+    #   One of :nokogiri or :rexml. If nil/unspecified uses :nokogiri if available, :rexml otherwise.
     # @option options [Boolean]  :expand (false)
     #   whether to perform RDFS expansion on the resulting graph
-    # @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 [:xml1, :xhtml1, :xhtml5, :html4, :html5, :svg] :host_language (:xhtml1)
     #   Host Language
     # @option options [:"rdfa1.0", :"rdfa1.1"] :version (:"rdfa1.1")
@@ -224,33 +233,33 @@ module RDF::RDFa
       super do
         @debug = options[:debug]
 
-        detect_host_language_version(input, options)
-        
         @processor_graph = options[:processor_graph]
 
-        @doc = case input
-        when Nokogiri::HTML::Document, Nokogiri::XML::Document
-          input
-        else
-          # Try to detect charset from input
-          options[:encoding] ||= input.charset if input.respond_to?(:charset)
-          
-          # Otherwise, default is utf-8
-          options[:encoding] ||= 'utf-8'
-
-          case @host_language
-          when :html4, :html5
-            Nokogiri::HTML.parse(input, base_uri.to_s, options[:encoding])
+        @library = case options[:library]
+          when nil
+            # Use Nokogiri when available, and REXML otherwise:
+            (defined?(::Nokogiri) && RUBY_PLATFORM != 'java') ? :nokogiri : :rexml
+          when :nokogiri, :rexml
+            options[:library]
           else
-            Nokogiri::XML.parse(input, base_uri.to_s, options[:encoding])
-          end
+            raise ArgumentError.new("expected :rexml or :nokogiri, but got #{options[:library].inspect}")
         end
-        
-        if ((@doc.nil? || @doc.root.nil?) && validate?)
+
+        require "rdf/rdfa/reader/#{@library}"
+        @implementation = case @library
+          when :nokogiri then Nokogiri
+          when :rexml    then REXML
+        end
+        self.extend(@implementation)
+
+        detect_host_language_version(input, options)
+        initialize_xml(input, options) rescue raise RDF::ReaderError.new($!.message)
+
+        if (root.nil? && validate?)
           add_error(nil, "Empty document", RDF::RDFA.DocumentError)
           raise RDF::ReaderError, "Empty Document"
         end
-        add_warning(nil, "Syntax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
+        add_warning(nil, "Syntax errors:\n#{doc_errors}", RDF::RDFA.DocumentError) if !doc_errors.empty? && validate?
 
         # Section 4.2 RDFa Host Language Conformance
         #
@@ -276,96 +285,12 @@ module RDF::RDFa
           @host_defaults[:profiles] = [XML_RDFA_PROFILE, XHTML_RDFA_PROFILE]
         end
 
-        add_info(@doc, "version = #{@version},  host_language = #{@host_language}")
+        add_info(@doc, "version = #{@version},  host_language = #{@host_language}, library = #{@library}")
 
         block.call(self) if block_given?
       end
     end
 
-    # Determine the host language and/or version from options and the input document
-    def detect_host_language_version(input, options)
-      @host_language = options[:host_language] ? options[:host_language].to_sym : nil
-      @version = options[:version] ? options[:version].to_sym : nil
-      return if @host_language && @version
-      
-      # Snif version based on input
-      case input
-      when Nokogiri::XML::Document, Nokogiri::HTML::Document
-        doc_type_string = input.doctype.to_s
-        version_attr = input.root && input.root.attribute("version").to_s
-        root_element = input.root.name.downcase
-        root_namespace = input.root.namespace.to_s
-        root_attrs = input.root.attributes
-        content_type = case
-        when root_element == "html" && input.is_a?(Nokogiri::HTML::Document)
-          "text/html"
-        when root_element == "html" && input.is_a?(Nokogiri::XML::Document)
-          "application/xhtml+html"
-        end
-      else
-        content_type = input.content_type if input.respond_to?(:content_type)
-
-        # Determine from head of document
-        head = if input.respond_to?(:read)
-          input.rewind
-          string = input.read(1000)
-          input.rewind
-          string.to_s
-        else
-          input.to_s[0..1000]
-        end
-        
-        doc_type_string = head.match(%r(<!DOCTYPE[^>]*>)m).to_s
-        root = head.match(%r(<[^!\?>]*>)m).to_s
-        root_element = root.match(%r(^<(\S+)[ >])) ? $1 : ""
-        version_attr = root.match(/version\s+=\s+(\S+)[\s">]/m) ? $1 : ""
-        head_element = head.match(%r(<head.*<\/head>)mi)
-        head_doc = Nokogiri::HTML.parse(head_element.to_s)
-        
-        # May determine content-type and/or charset from meta
-        # Easist way is to parse head into a document and iterate
-        # of CSS matches
-        head_doc.css("meta").each do |e|
-          if e.attr("http-equiv").to_s.downcase == 'content-type'
-            content_type, e = e.attr("content").to_s.downcase.split(";")
-            options[:encoding] = $1.downcase if e.to_s =~ /charset=([^\s]*)$/i
-          elsif e.attr("charset")
-            options[:encoding] = e.attr("charset").to_s.downcase
-          end
-        end
-      end
-
-      # Already using XML parser, determine from DOCTYPE and/or root element
-      @version ||= :"rdfa1.0" if doc_type_string =~ /RDFa 1\.0/
-      @version ||= :"rdfa1.0" if version_attr =~ /RDFa 1\.0/
-      @version ||= :"rdfa1.1" if version_attr =~ /RDFa 1\.1/
-      @version ||= :"rdfa1.1"
-
-      @host_language ||= case content_type
-      when "application/xml"  then :xml1
-      when "image/svg+xml"    then :svg
-      when "text/html"
-        case doc_type_string
-        when /html 4/i        then :html4
-        when /xhtml/i         then :xhtml1
-        when /html/i          then :html5
-        end
-      when "application/xhtml+xml"
-        case doc_type_string
-        when /html 4/i        then :html4
-        when /xhtml/i         then :xhtml1
-        when /html/i          then :xhtml5
-        end
-      else
-        case root_element
-        when /svg/i           then :svg
-        when /html/i          then :html4
-        end
-      end
-      
-      @host_language ||= :xml1
-    end
-    
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -414,17 +339,14 @@ module RDF::RDFa
       @bnode_cache[value.to_s] ||= RDF::Node.new(value)
     end
     
-    # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
+    # Figure out the document path, if it is an Element or Attribute
     def node_path(node)
-      "<#{base_uri}>" + case node
-      when Nokogiri::XML::Node then node.display_path
-      else node.to_s
-      end
+      "<#{base_uri}>#{node.respond_to?(:display_path) ? node.display_path : node}"
     end
     
     # Add debug event to debug array, if specified
     #
-    # @param [Nokogiri::XML::Node, #to_s] node:: XML Node or string for showing context
+    # @param [#display_path, #to_s] node:: XML Node or string for showing context
     # @param [String] message::
     # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
     def add_debug(node, message = "")
@@ -464,7 +386,7 @@ module RDF::RDFa
 
     # add a statement, object can be literal or URI or bnode
     #
-    # @param [Nokogiri::XML::Node, #to_s] node:: XML Node or string for showing context
+    # @param [#display_path, #to_s] node:: XML Node or string for showing context
     # @param [RDF::URI, RDF::BNode] subject:: the subject of the statement
     # @param [RDF::URI] predicate:: the predicate of the statement
     # @param [URI, RDF::BNode, RDF::Literal] object:: the object of the statement
@@ -478,16 +400,7 @@ module RDF::RDFa
 
     # Parsing an RDFa document (this is *not* the recursive method)
     def parse_whole_document(doc, base)
-      # find if the document has a base element
-      case @host_language
-      when :xhtml1, :xhtml5, :html4, :html5
-        base_el = doc.at_css("html>head>base")
-        base = base_el.attribute("href").to_s.split("#").first if base_el
-      else
-        xml_base = doc.root.attribute_with_ns("base", RDF::XML.to_s)
-        base = xml_base if xml_base
-      end
-      
+      base = doc_base(base)
       if (base)
         # Strip any fragment from base
         base = base.to_s.split("#").first
@@ -500,8 +413,8 @@ module RDF::RDFa
       
       if @version != :"rdfa1.0"
         # Process default vocabularies
-        process_profile(doc.root, @host_defaults[:profiles]) do |which, value|
-          add_debug(doc.root) { "parse_whole_document, #{which}: #{value.inspect}"}
+        process_profile(root, @host_defaults[:profiles]) do |which, value|
+          add_debug(root) { "parse_whole_document, #{which}: #{value.inspect}"}
           case which
           when :uri_mappings        then evaluation_context.uri_mappings.merge!(value)
           when :term_mappings       then evaluation_context.term_mappings.merge!(value)
@@ -510,7 +423,7 @@ module RDF::RDFa
         end
       end
       
-      traverse(doc.root, evaluation_context)
+      traverse(root, evaluation_context)
       add_debug("", "parse_whole_doc: traversal complete'")
     end
   
@@ -521,33 +434,33 @@ module RDF::RDFa
       profiles.
         map {|uri| uri(uri).normalize}.
         each do |uri|
-        # Don't try to open ourselves!
-        if base_uri == uri
-          add_debug(element, "process_profile: skip recursive profile <#{uri}>")
-          next
-        end
+          # Don't try to open ourselves!
+          if base_uri == uri
+            add_debug(element) {"process_profile: skip recursive profile <#{uri}>"}
+            next
+          end
 
-        old_debug = RDF::RDFa.debug?
-        begin
-          add_info(element, "process_profile: load <#{uri}>")
-          RDF::RDFa.debug = false
-          profile = Profile.find(uri)
-        rescue Exception => e
-          RDF::RDFa.debug = old_debug
-          add_error(element, e.message, RDF::RDFA.ProfileReferenceError)
-          raise # In case we're not in strict mode, we need to be sure processing stops
-        ensure
-          RDF::RDFa.debug = old_debug
-        end
+          old_debug = RDF::RDFa.debug?
+          begin
+            add_info(element, "process_profile: load <#{uri}>")
+            RDF::RDFa.debug = false
+            profile = Profile.find(uri)
+          rescue Exception => e
+            RDF::RDFa.debug = old_debug
+            add_error(element, e.message, RDF::RDFA.ProfileReferenceError)
+            raise # In case we're not in strict mode, we need to be sure processing stops
+          ensure
+            RDF::RDFa.debug = old_debug
+          end
 
-        # Add URI Mappings to prefixes
-        profile.prefixes.each_pair do |prefix, value|
-          prefix(prefix, value)
+          # Add URI Mappings to prefixes
+          profile.prefixes.each_pair do |prefix, value|
+            prefix(prefix, value)
+          end
+          yield :uri_mappings, profile.prefixes unless profile.prefixes.empty?
+          yield :term_mappings, profile.terms unless profile.terms.empty?
+          yield :default_vocabulary, profile.vocabulary if profile.vocabulary
         end
-        yield :uri_mappings, profile.prefixes unless profile.prefixes.empty?
-        yield :term_mappings, profile.terms unless profile.terms.empty?
-        yield :default_vocabulary, profile.vocabulary if profile.vocabulary
-      end
     end
 
     # Extract the XMLNS mappings from an element
@@ -558,15 +471,20 @@ module RDF::RDFa
       # and the URI is not processed in any way; in particular if it is a relative path it is
       # not resolved against the current base.
       ns_defs = {}
-      element.namespace_definitions.each do |ns|
-        ns_defs[ns.prefix] = ns.href.to_s
+      element.namespaces.each do |prefix, href|
+        prefix = nil if prefix == "xmlns"
+        add_debug("extract_mappings") { "ns: #{prefix}: #{href}"}
+        ns_defs[prefix] = href
       end
 
       # HTML parsing doesn't create namespace_definitions
       if ns_defs.empty?
         ns_defs = {}
-        element.attributes.each do |k, v|
-          ns_defs[$1] = v.to_s if k =~ /^xmlns(?:\:(.+))?/
+        element.attributes.each do |attr, href|
+          next unless attr =~ /^xmlns(?:\:(.+))?/
+          prefix = $1
+          add_debug("extract_mappings") { "ns(attr): #{prefix}: #{href}"}
+          ns_defs[prefix] = href.to_s
         end
       end
 
@@ -624,6 +542,7 @@ module RDF::RDFa
       recurse = true
       skip = false
       new_subject = nil
+      typed_resource = nil
       current_object_resource = nil
       uri_mappings = evaluation_context.uri_mappings.clone
       namespaces = evaluation_context.namespaces.clone
@@ -633,58 +552,39 @@ module RDF::RDFa
       default_vocabulary = evaluation_context.default_vocabulary
       list_mapping = evaluation_context.list_mapping
 
-      # shortcut
-      attrs = element.attributes
-
-      about = attrs['about']
-      src = attrs['src']
-      resource = attrs['resource']
-      href = attrs['href']
-      vocab = attrs['vocab']
-      xml_base = element.attribute_with_ns("base", RDF::XML.to_s)
+      xml_base = element.base
       base = xml_base.to_s if xml_base && ![:xhtml1, :xhtml5, :html4, :html5].include?(@host_language)
       base ||= evaluation_context.base
 
       # Pull out the attributes needed for the skip test.
-      property = attrs['property'].to_s.strip if attrs['property']
-      typeof = attrs['typeof'].to_s.strip if attrs.has_key?('typeof')
-      datatype = attrs['datatype'].to_s if attrs['datatype']
-      content = attrs['content'].to_s if attrs['content']
-      rel = attrs['rel'].to_s.strip if attrs['rel']
-      rev = attrs['rev'].to_s.strip if attrs['rev']
-
-      # Lists:
-      # @inlist
-      #   an attribute (value ignored) used to indicate that the object associated with a
-      #   @rel or @property attribute on the same element is to be added to the list
-      #   for that property. Causes a list to be created if it does not already exist.
-      inlist = attrs['inlist'].to_s.strip if attrs.has_key?('inlist')
+      attrs = {}
+      %w(
+        about
+        content
+        data
+        datatype
+        datetime
+        href
+        inlist
+        property
+        rel
+        resource
+        rev
+        src
+        typeof
+        vocab
+      ).each do |a|
+        attrs[a.to_sym] = element.attributes[a].to_s.strip if element.attributes[a]
+      end
 
-      add_debug(element) do
-        attrs = {
-          :about => about,
-          :src => src,
-          :resource => resource,
-          :href => href,
-          :vocab => vocab,
-          :base => xml_base,
-          :property => property,
-          :typeof => typeof,
-          :datatype => datatype,
-          :rel => rel,
-          :rev => rev,
-          :inlist => inlist,
-        }.select {|k,v| v}
-
-        "attrs " + attrs.map {|a| "#{a.first}: #{a.last}"}.join(", ")
-      end unless attrs.empty?
+      add_debug(element) {"attrs " + attrs.inspect} unless attrs.empty?
 
       # Default vocabulary [7.5 Step 2]
       # Next the current element is examined for any change to the default vocabulary via @vocab.
       # If @vocab is present and contains a value, its value updates the local default vocabulary.
       # If the value is empty, then the local default vocabulary must be reset to the Host Language defined default.
-      unless vocab.nil?
-        default_vocabulary = if vocab.to_s.empty?
+      if attrs[:vocab]
+        default_vocabulary = if attrs[:vocab].empty?
           # Set default_vocabulary to host language default
           add_debug(element) {
             "[Step 3] reset default_vocaulary to #{@host_defaults.fetch(:vocabulary, nil).inspect}"
@@ -692,9 +592,9 @@ module RDF::RDFa
           @host_defaults.fetch(:vocabulary, nil)
         else
           # Generate a triple indicating that the vocabulary is used
-          add_triple(element, base, RDF::RDFA.hasVocabulary, uri(vocab))
+          add_triple(element, base, RDF::RDFA.hasVocabulary, uri(attrs[:vocab]))
 
-          uri(vocab)
+          uri(attrs[:vocab])
         end
         add_debug(element) {
           "[Step 2] default_vocaulary: #{default_vocabulary.inspect}"
@@ -707,33 +607,17 @@ module RDF::RDFa
       extract_mappings(element, uri_mappings, namespaces)
     
       # Language information [7.5 Step 4]
-      # From HTML5 [3.2.3.3]
-      #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
-      #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
-      #   attribute in no namespace must be ignored for the purposes of determining the element's
-      #   language.
-      language = case
-      when @doc.is_a?(Nokogiri::HTML::Document) && element.attributes["xml:lang"]
-        element.attributes["xml:lang"].to_s
-      when @doc.is_a?(Nokogiri::HTML::Document) && element.attributes["lang"]
-        element.attributes["lang"].to_s
-      when element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s)
-        element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s).to_s
-      when element.at_xpath("@lang")
-        element.at_xpath("@lang").to_s
-      else
-        language
-      end
+      language = element.language || language
       language = nil if language.to_s.empty?
-      add_debug(element, "HTML5 [3.2.3.3] lang: #{language || 'nil'}") if language
+      add_debug(element) {"HTML5 [3.2.3.3] lang: #{language.inspect}"} if language
     
       # rels and revs
-      rels = process_uris(element, rel, evaluation_context, base,
+      rels = process_uris(element, attrs[:rel], evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
                           :restrictions => TERMorCURIEorAbsURI.fetch(@version, []))
-      revs = process_uris(element, rev, evaluation_context, base,
+      revs = process_uris(element, attrs[:rev], evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
@@ -743,64 +627,152 @@ module RDF::RDFa
         "rels: #{rels.join(" ")}, revs: #{revs.join(" ")}"
       end unless (rels + revs).empty?
 
-      if !(rel || rev)
+      if !(attrs[:rel] || attrs[:rev])
         # Establishing a new subject if no rel/rev [7.5 Step 5]
-        # May not be valid, but can exist
-        new_subject = if about
-          process_uri(element, about, evaluation_context, base,
-                      :uri_mappings => uri_mappings,
-                      :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
-        elsif resource
-          process_uri(element, resource, evaluation_context, base,
-                      :uri_mappings => uri_mappings,
-                      :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
-        elsif href
-          process_uri(element, href, evaluation_context, base, :restrictions => [:uri])
-        elsif src
-          process_uri(element, src, evaluation_context, base, :restrictions => [:uri])
-        end
+        
+        if @version == :"rdfa1.0"
+          new_subject = if attrs[:about]
+            process_uri(element, attrs[:about], evaluation_context, base,
+                        :uri_mappings => uri_mappings,
+                        :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+          elsif attrs[:resource]
+            process_uri(element, attrs[:resource], evaluation_context, base,
+                        :uri_mappings => uri_mappings,
+                        :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+          elsif attrs[:href] || attrs[:src]
+            process_uri(element, (attrs[:href] || attrs[:src]), evaluation_context, base, :restrictions => [:uri])
+          end
 
-        # If no URI is provided by a resource attribute, then the first match from the following rules
-        # will apply:
-        #   if @typeof is present, then new subject is set to be a newly created bnode.
-        # otherwise,
-        #   if parent object is present, new subject is set to the value of parent object.
-        # Additionally, if @property is not present then the skip element flag is set to 'true';
-        new_subject ||= if [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
-          # From XHTML+RDFa 1.1:
-          # if no URI is provided, then first check to see if the element is the head or body element.
-          # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
-          uri(base)
-        elsif element == @doc.root && base
-          uri(base)
-        elsif typeof
-          RDF::Node.new
+          # If no URI is provided by a resource attribute, then the first match from the following rules
+          # will apply:
+          new_subject ||= if [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
+            # From XHTML+RDFa 1.1:
+            # if no URI is provided, then first check to see if the element is the head or body element.
+            # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
+            uri(base)
+          elsif element == root && base
+            # if the element is the root element of the document, then act as if there is an empty @about present,
+            # and process it according to the rule for @about, above;
+            uri(base)
+          elsif attrs[:typeof]
+            RDF::Node.new
+          else
+            # otherwise, if parent object is present, new subject is set to the value of parent object.
+            skip = true unless attrs[:property]
+            evaluation_context.parent_object
+          end
+
+          # if the @typeof attribute is present, set typed resource to new subject
+          typed_resource = new_subject if attrs[:typeof]
         else
-          # if it's null, it's null and nothing changes
-          skip = true unless property
-          evaluation_context.parent_object
+          # If the current element contains the @property attribute, but does not contain the @content or the @datatype attribute
+          if attrs[:property] && !(attrs[:content] || attrs[:datatype]) && evaluation_context.incomplete_triples.empty?
+            new_subject = process_uri(element, attrs[:about], evaluation_context, base,
+                        :uri_mappings => uri_mappings,
+                        :restrictions => SafeCURIEorCURIEorURI.fetch(@version, [])) if attrs[:about]
+
+            # if the @typeof attribute is present, set typed resource to new subject
+            typed_resource = new_subject if attrs[:typeof]
+
+            # If no URI is provided by a resource attribute, then the first match from the following rules
+            # will apply:
+            new_subject ||= if [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
+              # From XHTML+RDFa 1.1:
+              # if no URI is provided, then first check to see if the element is the head or body element.
+              # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
+              uri(base)
+            elsif element == root && base
+              # if the element is the root element of the document, then act as if there is an empty @about present,
+              # and process it according to the rule for @about, above;
+              uri(base)
+            else
+              # otherwise, if parent object is present, new subject is set to the value of parent object.
+              evaluation_context.parent_object
+            end
+
+            if attrs[:typeof]
+              typed_resource ||= if attrs[:resource]
+                process_uri(element, attrs[:resource], evaluation_context, base,
+                            :uri_mappings => uri_mappings,
+                            :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+              elsif attrs[:href] || attrs[:src]
+                process_uri(element, (attrs[:href] || attrs[:src]), evaluation_context, base, :restrictions => [:uri])
+              else
+                # if none of these are present, the value of typed resource is set to a newly defined bnode.
+                RDF::Node.new
+              end
+              
+              # The value of the current object resource is set to the value of typed resource.
+              current_object_resource = typed_resource
+            end
+          else
+            # otherwise (ie, the @property element is not present)
+
+            new_subject = if attrs[:about]
+              process_uri(element, attrs[:about], evaluation_context, base,
+                          :uri_mappings => uri_mappings,
+                          :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+            elsif attrs[:resource]
+              process_uri(element, attrs[:resource], evaluation_context, base,
+                          :uri_mappings => uri_mappings,
+                          :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+            elsif attrs[:href] || attrs[:src]
+              process_uri(element, (attrs[:href] || attrs[:src]), evaluation_context, base, :restrictions => [:uri])
+            end
+
+            # If no URI is provided by a resource attribute, then the first match from the following rules
+            # will apply:
+            new_subject ||= if [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
+              # From XHTML+RDFa 1.1:
+              # if no URI is provided, then first check to see if the element is the head or body element.
+              # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
+              uri(base)
+            elsif element == root && base
+              # if the element is the root element of the document, then act as if there is an empty @about present,
+              # and process it according to the rule for @about, above;
+              uri(base)
+            elsif attrs[:typeof]
+              RDF::Node.new
+            else
+              # otherwise, if parent object is present, new subject is set to the value of parent object.
+              # Additionally, if @property is not present then the skip element flag is set to 'true'.
+              skip = true unless attrs[:property]
+              evaluation_context.parent_object
+            end
+
+            # if @typeof is present, set the typed resource to the value of new subject</code>
+            typed_resource ||= new_subject if attrs[:typeof]
+          end
         end
-        add_debug(element, "[Step 5] new_subject: #{new_subject.to_ntriples rescue 'nil'}, skip = #{skip}")
+
+        add_debug(element) {
+          "[Step 5] new_subject: #{new_subject.to_ntriples rescue 'nil'}, " +
+          "typed_resource: #{typed_resource.to_ntriples rescue 'nil'}, " +
+          "skip = #{skip}"
+        }
       else
         # [7.5 Step 6]
         # If the current element does contain a @rel or @rev attribute, then the next step is to
         # establish both a value for new subject and a value for current object resource:
-        new_subject = process_uri(element, about, evaluation_context, base,
+        new_subject = process_uri(element, attrs[:about], evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
-        new_subject ||= process_uri(element, src, evaluation_context, base,
+        new_subject ||= process_uri(element, attrs[:src], evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => [:uri]) if @version == :"rdfa1.0"
       
+        # if the @typeof attribute is present, set typed resource to new subject
+        typed_resource = new_subject if attrs[:typeof]
+
         # If no URI is provided then the first match from the following rules will apply
-        new_subject ||= if element == @doc.root && base
+        new_subject ||= if element == root && base
           uri(base)
         elsif [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
           # From XHTML+RDFa 1.1:
           # if no URI is provided, then first check to see if the element is the head or body element.
           # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
           uri(base)
-        elsif element.attributes['typeof']
+        elsif attrs[:typeof] && @version == :"rdfa1.0"
           RDF::Node.new
         else
           # if it's null, it's null and nothing changes
@@ -809,32 +781,49 @@ module RDF::RDFa
         end
       
         # Then the current object resource is set to the URI obtained from the first match from the following rules:
-        current_object_resource = if resource
-          process_uri(element, resource, evaluation_context, base,
+        current_object_resource = if attrs[:resource]
+          process_uri(element, attrs[:resource], evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
-        elsif href
-          process_uri(element, href, evaluation_context, base,
+        elsif attrs[:href]
+          process_uri(element, attrs[:href], evaluation_context, base,
                       :restrictions => [:uri])
-        elsif src && @version != :"rdfa1.0"
-          process_uri(element, src, evaluation_context, base,
+        elsif attrs[:src] && @version != :"rdfa1.0"
+          process_uri(element, attrs[:src], evaluation_context, base,
                       :restrictions => [:uri])
+        elsif attrs[:typeof] && !attrs[:about] && @version != :"rdfa1.0"
+          # otherwise, if @typeof is present and @about is not and the  incomplete triples
+          # within the current context is empty, use a newly created bnode
+          RDF::Node.new
         end
 
-        add_debug(element, "[Step 6] new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
+        # and also set the value typed resource to this bnode
+        if attrs[:typeof]
+          if @version == :"rdfa1.0"
+            typed_resource = new_subject
+          else
+            typed_resource = current_object_resource if !attrs[:about]
+          end
+        end
+
+        add_debug(element) {
+          "[Step 6] new_subject: #{new_subject}, " +
+          "current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource} " +
+          "typed_resource: #{typed_resource.to_ntriples rescue 'nil'}, "
+        }
       end
     
       # Process @typeof if there is a subject [Step 7]
-      if new_subject and typeof
+      if typed_resource
         # Typeof is TERMorCURIEorAbsURIs
-        types = process_uris(element, typeof, evaluation_context, base,
+        types = process_uris(element, attrs[:typeof], evaluation_context, base,
                             :uri_mappings => uri_mappings,
                             :term_mappings => term_mappings,
                             :vocab => default_vocabulary,
                             :restrictions => TERMorCURIEorAbsURI.fetch(@version, []))
-        add_debug(element, "typeof: #{typeof}")
+        add_debug(element, "[Step 7] typeof: #{attrs[:typeof]}")
         types.each do |one_type|
-          add_triple(element, new_subject, RDF["type"], one_type)
+          add_triple(element, typed_resource, RDF["type"], one_type)
         end
       end
 
@@ -855,16 +844,17 @@ module RDF::RDFa
       #
       # If the current element has a @inlist attribute, add the property to the
       # list associated with that property, creating a new list if necessary.
-      if new_subject and current_object_resource
+      if new_subject && current_object_resource && (attrs[:rel] || attrs[:rev])
+        add_debug(element) {"[Step 9] rels: #{rels.inspect} revs: #{revs.inspect}"}
         rels.each do |r|
-          if inlist
+          if attrs[:inlist]
             # If the current list mapping does not contain a list associated with this IRI,
             # instantiate a new list
             unless list_mapping[r]
               list_mapping[r] = RDF::List.new
               add_debug(element) {"list(#{r}): create #{list_mapping[r].inspect}"}
             end
-            add_debug(element, "[Step 9] add #{current_object_resource.to_ntriples} to #{r} #{list_mapping[r].inspect}")
+            add_debug(element) {"[Step 9] add #{current_object_resource.to_ntriples} to #{r} #{list_mapping[r].inspect}"}
             list_mapping[r] << current_object_resource
           else
             add_triple(element, new_subject, r, current_object_resource)
@@ -874,7 +864,7 @@ module RDF::RDFa
         revs.each do |r|
           add_triple(element, current_object_resource, r, new_subject)
         end
-      elsif rel || rev
+      elsif attrs[:rel] || attrs[:rev]
         # Incomplete triples and bnode creation [Step 10]
         add_debug(element) {"[Step 10] incompletes: rels: #{rels}, revs: #{revs}"}
         current_object_resource = RDF::Node.new
@@ -884,7 +874,7 @@ module RDF::RDFa
         # lists: Save into list, don't generate triple
 
         rels.each do |r|
-          if inlist
+          if attrs[:inlist]
             # If the current list mapping does not contain a list associated with this IRI,
             # instantiate a new list
             unless list_mapping[r]
@@ -906,8 +896,8 @@ module RDF::RDFa
       #
       # If the current element has a @inlist attribute, add the property to the
       # list associated with that property, creating a new list if necessary.
-      if property
-        properties = process_uris(element, property, evaluation_context, base,
+      if attrs[:property]
+        properties = process_uris(element, attrs[:property], evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :term_mappings => term_mappings,
                                   :vocab => default_vocabulary,
@@ -917,27 +907,23 @@ module RDF::RDFa
           if p.is_a?(RDF::URI)
             false
           else
-            add_debug(element, "[Step 11] predicate #{p.to_ntriples} must be a URI")
+            add_warning(element, "[Step 11] predicate #{p.to_ntriples} must be a URI")
             true
           end
         end
 
-        # get the literal 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.
-        datatype = process_uri(element, datatype, evaluation_context, base,
+        datatype = process_uri(element, attrs[:datatype], evaluation_context, base,
                               :uri_mappings => uri_mappings,
                               :term_mappings => term_mappings,
                               :vocab => default_vocabulary,
-                              :restrictions => TERMorCURIEorAbsURI.fetch(@version, [])) unless datatype.to_s.empty?
+                              :restrictions => TERMorCURIEorAbsURI.fetch(@version, [])) unless attrs[:datatype].to_s.empty?
         begin
-          current_object_literal = if !datatype.to_s.empty? && datatype.to_s != RDF.XMLLiteral.to_s
+          current_property_value = if datatype && datatype != RDF.XMLLiteral
             # typed literal
             add_debug(element, "[Step 11] typed literal (#{datatype})")
-            RDF::Literal.new(content || element.inner_text.to_s, :datatype => datatype, :language => language, :validate => validate?, :canonicalize => canonicalize?)
+            RDF::Literal.new(attrs[:content] || element.inner_text.to_s, :datatype => datatype, :language => language, :validate => validate?, :canonicalize => canonicalize?)
           elsif @version == :"rdfa1.1"
-            if datatype.to_s == RDF.XMLLiteral.to_s
+            if datatype == RDF.XMLLiteral
               # XML Literal
               add_debug(element) {"[Step 11(1.1)] XML Literal: #{element.inner_html}"}
 
@@ -948,35 +934,73 @@ module RDF::RDFa
               # generating the serialized element definition. For avoidance of doubt, any re-declarations on the
               # child node must take precedence over declarations that were active on the current node.
               begin
-                RDF::Literal.new(element.inner_html,
-                                :datatype => RDF.XMLLiteral,
-                                :language => language,
-                                :namespaces => namespaces,
-                                :validate => validate?,
-                                :canonicalize => canonicalize?)
+                c14nxl = element.children.c14nxl(
+                  :library => @library,
+                  :language => language,
+                  :namespaces => {nil => XHTML}.merge(namespaces))
+                RDF::Literal.new(c14nxl,
+                  :library => @library,
+                  :datatype => RDF.XMLLiteral,
+                  :validate => validate?,
+                  :canonicalize => canonicalize?)
               rescue ArgumentError => e
                 add_error(element, e.message)
               end
+            elsif attrs[:datetime]
+              # Lexically scan value and assign appropriate type, otherwise, leave untyped
+              v = element.attribute('datetime').to_s
+              datatype = %w(Date Time DateTime Duration).map {|t| RDF::Literal.const_get(t)}.detect do |dt|
+                v.match(dt::GRAMMAR)
+              end || RDF::Literal
+              add_debug(element) {"[Step 11(1.1)] datetime literal: #{v.class}"}
+              datatype.new(v)
+            elsif attrs[:content]
+              # plain literal
+              add_debug(element, "[Step 11(1.1)] plain literal (content)")
+              RDF::Literal.new(attrs[:content], :language => language, :validate => validate?, :canonicalize => canonicalize?)
+            elsif attrs[:value]
+              # plain literal
+              add_debug(element, "[Step 11(1.1)] plain literal (value)")
+              RDF::Literal.new(attrs[:value], :validate => validate?, :canonicalize => canonicalize?)
+            elsif (attrs[:resource] || attrs[:href] || attrs[:src] || attrs[:data]) &&
+                 !(attrs[:rel] || attrs[:rev]) &&
+                 evaluation_context.incomplete_triples.empty? &&
+                 @version != :"rdfa1.0"
+              if attrs[:resource]
+                add_debug(element, "[Step 11(1.1)] IRI literal (resource)")
+                process_uri(element, attrs[:resource], evaluation_context, base,
+                            :uri_mappings => uri_mappings,
+                            :restrictions => SafeCURIEorCURIEorURI.fetch(@version, []))
+              else
+                add_debug(element, "[Step 11(1.1)] IRI literal (href/src/data)")
+                process_uri(element, (attrs[:href] || attrs[:src] || attrs[:data]), evaluation_context, base, :restrictions => [:uri])
+              end
+            elsif typed_resource && !attrs[:about] && evaluation_context.incomplete_triples.empty? && @version != :"rdfa1.0"
+              add_debug(element, "[Step 11(1.1)] typed_resource")
+              typed_resource
             else
               # plain literal
-              add_debug(element, "[Step 11(1.1)] plain literal")
-              RDF::Literal.new(content || element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
+              add_debug(element, "[Step 11(1.1)] plain literal (inner text)")
+              RDF::Literal.new(element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
             end
           else
-            if content || (children_node_types == [Nokogiri::XML::Text]) || (element.children.length == 0) || datatype == ""
+            if element.text_content? || (element.children.length == 0) || attrs[:datatype] == ""
               # plain literal
               add_debug(element, "[Step 11 (1.0)] plain literal")
-              RDF::Literal.new(content || element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
-            elsif children_node_types != [Nokogiri::XML::Text] and (datatype == nil or datatype.to_s == RDF.XMLLiteral.to_s)
+              RDF::Literal.new(attrs[:content] || element.inner_text.to_s, :language => language, :validate => validate?, :canonicalize => canonicalize?)
+            elsif !element.text_content? and (datatype == nil or datatype.to_s == RDF.XMLLiteral.to_s)
               # XML Literal
               add_debug(element) {"[Step 11 (1.0)] XML Literal: #{element.inner_html}"}
               recurse = false
-              RDF::Literal.new(element.inner_html,
-                               :datatype => RDF.XMLLiteral,
-                               :language => language,
-                               :namespaces => namespaces,
-                               :validate => validate?,
-                               :canonicalize => canonicalize?)
+              c14nxl = element.children.c14nxl(
+                :library => @library,
+                :language => language,
+                :namespaces => {nil => XHTML}.merge(namespaces))
+              RDF::Literal.new(c14nxl,
+                :library => @library,
+                :datatype => RDF.XMLLiteral,
+                :validate => validate?,
+                :canonicalize => canonicalize?)
             end
           end
         rescue ArgumentError => e
@@ -986,22 +1010,22 @@ module RDF::RDFa
         # add each property
         properties.each do |p|
           # Lists: If element has an @inlist attribute, add the value to a list
-          if inlist
+          if attrs[:inlist]
             # If the current list mapping does not contain a list associated with this IRI,
             # instantiate a new list
             unless list_mapping[p]
               list_mapping[p] = RDF::List.new
               add_debug(element) {"[Step 11] lists(#{p}): create #{list_mapping[p].inspect}"}
             end
-            add_debug(element)  {"[Step 11] add #{current_object_literal.to_ntriples} to #{p.to_ntriples} #{list_mapping[p].inspect}"}
-            list_mapping[p] << current_object_literal
+            add_debug(element)  {"[Step 11] add #{current_property_value.to_ntriples} to #{p.to_ntriples} #{list_mapping[p].inspect}"}
+            list_mapping[p] << current_property_value
           elsif new_subject
-            add_triple(element, new_subject, p, current_object_literal) 
+            add_triple(element, new_subject, p, current_property_value) 
           end
         end
       end
     
-      if not skip and new_subject && !evaluation_context.incomplete_triples.empty?
+      if !skip and new_subject && !evaluation_context.incomplete_triples.empty?
         # Complete the incomplete triples from the evaluation context [Step 12]
         add_debug(element) do
           "[Step 12] complete incomplete triples: " +
@@ -1061,7 +1085,7 @@ module RDF::RDFa
       
         element.children.each do |child|
           # recurse only if it's an element
-          traverse(child, new_ec) if child.class == Nokogiri::XML::Element
+          traverse(child, new_ec) if child.element?
         end
         
         # Step 14: after traversing through child elements, for each list associated with