RubyGems - rdf_context - Versions diffs - 0.5.3 → 0.5.5 - Mend

rdf_context 0.5.3 → 0.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

data/History.txt +12 -0
data/VERSION +1 -1
data/bin/rdf_context +48 -3
data/lib/rdf_context.rb +4 -1
data/lib/rdf_context/exceptions.rb +1 -0
data/lib/rdf_context/graph.rb +6 -1
data/lib/rdf_context/namespace.rb +11 -15
data/lib/rdf_context/parser.rb +1 -1
data/lib/rdf_context/rdfaparser.rb +385 -131
data/lib/rdf_context/serializer/recursive_serializer.rb +3 -7
data/lib/rdf_context/serializer/xml_serializer.rb +21 -8
data/lib/rdf_context/store/abstract_store.rb +0 -1
data/lib/rdf_context/uriref.rb +25 -19
data/spec/graph_spec.rb +16 -7
data/spec/literal_spec.rb +10 -10
data/spec/matchers.rb +1 -0
data/spec/n3parser_spec.rb +2 -2
data/spec/namespaces_spec.rb +16 -2
data/spec/rdfa_helper.rb +8 -13
data/spec/rdfa_parser_spec.rb +50 -6
data/spec/spec_helper.rb +5 -0
data/spec/turtle_serializer_spec.rb +6 -7
data/spec/uriref_spec.rb +11 -27
metadata +3 -5
data/cmx.db +0 -0
data/ep.nt +0 -194

data/History.txt CHANGED Viewed

@@ -1,3 +1,15 @@
+=== 0.5.4
+* RDFa 1.1 parsing supported (based on RDFa Core 1.1 W3C Working Draft 22 April 2010)
+* Fix URIRef#short_name (and consequently #base and #namespace) to not extract a non-hierarchical path as a short_name
+* Namespace no longer uses URIRef, but just acts on strings.
+* Namespace#new does not take an optional _fragment_ argument any longer.
+* Added Namespace#to_s to output "prefix: uri" format
+* Graph#qname first trys generating using bound namespaces, then adds well-known namespaces.
+* URIRef#to_qname and #to_namespace No longer generates an exception. Each take either a Hash or an Array of namespaces and tries them from longest to shortest.
+* Improved Turtle and XML serializers in use of namespaces.
+* Generate pending messages if RDFa tests skipped due to lack of Redland installation.
+* Change dcterms: prefix to dc: (fully compatible with previous /elements/ definitions)
 === 0.5.3
 * Fix bug in XML serializer when type is a BNode.
 * Undo change in 0.5.2 to remove old binding based on equivalent URI to equivalent prefix.

data/VERSION CHANGED Viewed

	@@ -1 +1 @@
1	- 0.5.3
1	+ 0.5.5

data/bin/rdf_context CHANGED Viewed

@@ -5,7 +5,7 @@ require 'getoptlong'
 class Parse
   include RdfContext
   def parse(file, base_uri, store = nil)
-    puts "Parse: #{file}" if $quiet
+    puts "Parse: #{file.is_a?(StringIO) ? base_uri : file}" if $quiet
     graph_opts = {:identifier => base_uri}
     graph_opts[:store] = store if store
     parser = Parser.new(:graph => Graph.new(graph_opts))
@@ -25,6 +25,38 @@ class Parse
   end
 end
+TEST_DIR = File.join(File.dirname(__FILE__), '..', 'spec', 'rdfa-test-suite', 'tests')
+BASE_MANIFEST_URL = "http://rdfa.digitalbazaar.com/test-suite/"
+BASE_TEST_CASE_URL = "#{BASE_MANIFEST_URL}test-cases/"
+def rdfa_tc(number, parse, store)
+  f = File.expand_path("#{TEST_DIR}/#{number}.txt")
+  found_head = false
+  namespaces = ""
+  body = File.readlines(f).map do |line|
+    found_head ||= line.match(/<head/)
+    if found_head
+      line.chop
+    else
+      namespaces << line
+      nil
+    end
+  end.compact.join("\n")
+  namespaces.chop!  # Remove trailing newline
+  tcpath = BASE_TEST_CASE_URL + "xhtml1"
+  head = "" +
+  %(<?xml version="1.0" encoding="UTF-8"?>\n) +
+  %(<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">\n) +
+  %(<html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1"\n)
+  tc = head + "#{namespaces}>\n#{body.gsub(/\$TCPATH/, tcpath)}\n</html>"
+  puts "Input file: #{tc}" if $DEBUG || $verbose
+  parse.parse(StringIO.new(tc), "#{tcpath}/#{number}.xhtml")
+end
 mode = ARGV.shift
 raise "Mode must be one of 'parse'" unless mode == "parse"
@@ -38,7 +70,8 @@ opts = GetoptLong.new(
   ["--debug", GetoptLong::NO_ARGUMENT],
   ["--format", GetoptLong::REQUIRED_ARGUMENT],
   ["--store", GetoptLong::REQUIRED_ARGUMENT],
-  ["--uri", GetoptLong::REQUIRED_ARGUMENT]
+  ["--uri", GetoptLong::REQUIRED_ARGUMENT],
+  ["--rdfa", GetoptLong::NO_ARGUMENT]
 )
 opts.each do |opt, arg|
   case opt
@@ -47,6 +80,7 @@ opts.each do |opt, arg|
   when '--debug' then $DEBUG = true
   when '--format' then $format = arg
   when '--uri' then base_uri = arg
+  when '--rdfa' then $rdfa = true
   when '--store'
     case arg
     when /list/
@@ -61,9 +95,20 @@ opts.each do |opt, arg|
 end
 x = Parse.new
-if ARGV.empty?
+if $rdfa && ARGV.empty?
+  # Run all RDFa test cases
+  Dir.foreach(TEST_DIR) do |f|
+    next unless f.match(/^(.*)\.txt$/)
+    rdfa_tc($1, x, store)
+  end
+elsif ARGV.empty?
   s = $stdin.read
   x.parse(StringIO.new(s), base_uri, store)
+elsif $rdfa
+  # Run specified RDFa test cases
+  ARGV.each do |tc|
+    rdfa_tc(tc, x, store)
+  end
 else
   ARGV.each do |test_file|
     x.parse(test_file, base_uri, store)

data/lib/rdf_context.rb CHANGED Viewed

@@ -9,6 +9,7 @@ rescue LoadError
   require 'rubygems' unless ENV['NO_RUBYGEMS']
   gem 'nokogiri'
   gem 'addressable'
+  gem 'treetop'
   require 'nokogiri'
   require 'addressable/uri'
   require 'builder'
@@ -60,15 +61,17 @@ module RdfContext
   RDF_TYPE    = URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
   XML_LITERAL = Literal::Encoding.xmlliteral
-  DC_NS       = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+  DC_NS       = Namespace.new("http://purl.org/dc/terms/", "dc")
   OWL_NS      = Namespace.new("http://www.w3.org/2002/07/owl#", "owl")
   LOG_NS      = Namespace.new("http://www.w3.org/2000/10/swap/log#", "log")
   RDF_NS      = Namespace.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf")
+  RDFA_NS     = Namespace.new("http://www.w3.org/ns/rdfa#", "rdfa")
   RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")
   XHV_NS      = Namespace.new("http://www.w3.org/1999/xhtml/vocab#", "xhv")
   XML_NS      = Namespace.new("http://www.w3.org/XML/1998/namespace", "xml")
   XSD_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema#", "xsd")
   XSI_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema-instance", "xsi")
+  WELLKNOWN_NAMESPACES = [DC_NS, OWL_NS, LOG_NS, RDF_NS, RDFA_NS, RDFS_NS, XHV_NS, XML_NS, XSD_NS, XSI_NS]
   XH_MAPPING  = {"" => Namespace.new("http://www.w3.org/1999/xhtml/vocab\#", nil)}
 end

data/lib/rdf_context/exceptions.rb CHANGED Viewed

@@ -2,6 +2,7 @@ module RdfContext
   class RdfException    < RuntimeError; end
   class ParserException < RdfException; end
+  class SparqlException < RdfException; end
   class GraphException  < RdfException; end
   class StoreException  < RdfException; end
   class BNodeException  < RdfException; end

data/lib/rdf_context/graph.rb CHANGED Viewed

@@ -163,8 +163,13 @@ module RdfContext
     def uri_binding; @store.uri_binding; end
     # QName for a URI
+    # Try bound namespaces, and if not found, try well-known namespaces
     def qname(uri)
-      uri.to_qname(self.uri_binding)
+      uri.to_qname(self.uri_binding) || begin
+        qn = uri.to_qname(WELLKNOWN_NAMESPACES)
+        self.bind(uri.namespace) if qn
+        qn
+      end
     end
     # Namespace for prefix

data/lib/rdf_context/namespace.rb CHANGED Viewed

@@ -12,21 +12,14 @@ module RdfContext
     #
     # @param [String] uri:: the URI of the namespace
     # @param [String] prefix:: the prefix of the namespace
-    # @param [Boolean] fragment:: are the identifiers on this resource fragment identifiers? (e.g. '#')  Defaults to false.
     # @return [Namespace]:: The newly created namespace.
     # @raise [Error]:: Checks validity of the desired prefix and raises if it is incorrect.
     #
     # @author Tom Morris, Pius Uzamere
-    def initialize(uri, prefix, fragment = nil)
+    def initialize(uri, prefix)
       prefix = prefix.to_s
-      @fragment = fragment
-      if uri.to_s.match(/^(.*)\#$/)
-        # Remove frag hash from URI so URIRef doesn't screw it up
-        uri = $1
-        @fragment ||= true
-      end
-      @uri = uri.is_a?(URIRef) ? uri : URIRef.new(uri, :normalize => false, :namespace => self)
+      @uri = uri.to_s
       raise ParserException, "Invalid prefix '#{prefix}'" unless prefix_valid?(prefix)
       @prefix = prefix
@@ -41,7 +34,7 @@ module RdfContext
     #
     # To avoid naming problems, a suffix may have an appended '_', which will be removed when the URI is generated.
     #
-    # @return [URIRef]:: The newly created URIRegerence.
+    # @return [String]:: The newly created URI.
     # @raise [Error]:: Checks validity of the desired prefix and raises if it is incorrect.
     # @author Tom Morris, Pius Uzamere
     def method_missing(methodname, *args)
@@ -52,11 +45,10 @@ module RdfContext
     # Rules are somewhat different than for normal URI unions, as the raw URI is used as the source,
     # not a normalized URI, and the result is not normalized
     def +(suffix)
-      prefix = @uri.to_s
-      prefix += '#' if @fragment && !prefix.index("#")
+      prefix = @uri
       suffix = suffix.to_s.sub(/^\#/, "") if prefix.index("#")
       suffix = suffix.to_s.sub(/_$/, '')
-      URIRef.new(prefix + suffix, :normalize => false, :namespace => self)
+      URIRef.new(prefix + suffix.to_s, :normalize => false, :namespace => self)
     end
     # Make sure to attach fragment
@@ -71,7 +63,7 @@ module RdfContext
     # Compare namespaces
     def eql?(other)
-      @prefix == other.prefix && self.uri == other.uri && @fragment == other.fragment
+      self.uri == other.uri
     end
     alias_method :==, :eql?
@@ -85,6 +77,10 @@ module RdfContext
       {xmlns_attr => @uri.to_s}
     end
+    def to_s
+      "#{prefix}: #{@uri}"
+    end
     def inspect
       "Namespace[abbr='#{prefix}',uri='#{@uri}']"
     end
@@ -92,7 +88,7 @@ module RdfContext
     private
     # The Namespace prefix must be an NCName
     def prefix_valid?(prefix)
-      NC_REGEXP.match(prefix) || prefix.to_s.empty?
+      NC_REGEXP.match(prefix.to_s) || prefix.to_s.empty?
     end
   end
 end

data/lib/rdf_context/parser.rb CHANGED Viewed

@@ -7,7 +7,7 @@ module RdfContext
     attr_accessor :doc, :graph
     ##
-    # Creates a new parser for N3 (or Turtle).
+    # Creates a new parser
     #
     # @param [Hash] options:: Options from
     # <em>options[:graph]</em>:: Graph to parse into, otherwise a new RdfContext::Graph instance is created

data/lib/rdf_context/rdfaparser.rb CHANGED Viewed

@@ -4,25 +4,58 @@ module RdfContext
   ##
   # An RDFa parser in Ruby
   #
-  # Based on processing rules described here: http://www.w3.org/TR/rdfa-syntax/#s_model
+  # Based on processing rules described here:
+  #   file:///Users/gregg/Projects/rdf_context/RDFa%20Core%201.1.html#sequence
   #
   # Ben Adida
   # 2008-05-07
   # Gregg Kellogg
   # 2009-08-04
   class RdfaParser < Parser
-    attr_reader :namespace
+    # Host language, One of:
+    #   :xhtml_rdfa_1_0
+    #   :xhtml_rdfa_1_1
+    attr_reader :host_language
     # The Recursive Baggage
     class EvaluationContext # :nodoc:
+      # The base. This will usually be the URL of the document being processed,
+      # but it could be some other URL, set by some other mechanism,
+      # such as the (X)HTML base element. The important thing is that it establishes
+      # a URL against which relative paths can be resolved.
       attr :base, true
+      # The parent subject.
+      # The initial value will be the same as the initial value of base,
+      # but it will usually change during the course of processing.
       attr :parent_subject, true
+      # The parent object.
+      # In some situations the object of a statement becomes the subject of any nested statements,
+      # and this property is used to convey this value.
+      # Note that this value may be a bnode, since in some situations a number of nested statements
+      # are grouped together on one bnode.
+      # This means that the bnode must be set in the containing statement and passed down,
+      # and this property is used to convey this value.
       attr :parent_object, true
+      # A list of current, in-scope URI mappings.
       attr :uri_mappings, true
+      # A list of incomplete triples. A triple can be incomplete when no object resource
+      # is provided alongside a predicate that requires a resource (i.e., @rel or @rev).
+      # The triples can be completed when a resource becomes available,
+      # which will be when the next subject is specified (part of the process called chaining).
       attr :incomplete_triples, true
+      # The language. Note that there is no default language.
       attr :language, true
+      # The term mappings, a list of terms and their associated URIs.
+      # This specification does not define an initial list.
+      # Host Languages may define an initial list.
+      # If a Host Language provides an initial list, it should do so via an RDFa Profile document.
+      attr :term_mappings, true
+      # The default vocabulary, a value to use as the prefix URI when a term is used.
+      # This specification does not define an initial setting for the default vocabulary.
+      # Host Languages may define an initial setting.
+      attr :default_vocabulary, true
-      def initialize(base)
+      def initialize(base, host_defaults)
         # Initialize the evaluation context, [5.1]
         @base = base
         @parent_subject = @base
@@ -30,6 +63,8 @@ module RdfContext
         @uri_mappings = {}
         @incomplete_triples = []
         @language = nil
+        @term_mappings = host_defaults.fetch(:term_mappings, {})
+        @default_voabulary = host_defaults.fetch(:voabulary, nil)
       end
       # Copy this Evaluation Context
@@ -40,13 +75,27 @@ module RdfContext
       end
       def inspect
-        v = %w(base parent_subject parent_object language).map {|a| "#{a}='#{self.send(a).nil? ? 'nil' : self.send(a)}'"}
+        v = %w(base parent_subject parent_object language default_vocabulary).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 << "term_mappings[#{term_mappings.keys.length}]"
         v.join(",")
       end
     end
+    ##
+    # Creates a new parser for RDFa.
+    #
+    # @param [Hash] options:: Options from
+    # <em>options[:graph]</em>:: Graph to parse into, otherwise a new RdfContext::Graph instance is created
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    def initialize(options = {})
+      super
+      @@vocabulary_cache ||= {}
+    end
     # Parse XHTML+RDFa document from a string or input stream to closure or graph.
     #
     # If the parser is called with a block, triples are passed to the block rather
@@ -74,10 +123,29 @@ module RdfContext
       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
+      # Determine host language
+      # XXX - right now only XHTML defined
+      @host_language = case @doc.root.attributes["version"].to_s
+      when /XHTML+RDFa/ then :xhtml
+      end
+      # If none found, assume xhtml
+      @host_language ||= :xhtml
+      @host_defaults = case @host_language
+      when :xhtml
+        @graph.bind(XHV_NS)
+        {
+          :vocabulary => XHV_NS.uri,
+          :prefix     => XHV_NS,
+          :term_mappings => %w(
+            alternate appendix bookmark cite chapter contents copyright first glossary help icon index
+            last license meta next p3pv1 prev role section stylesheet subsection start top up
+            ).inject({}) { |hash, term| hash[term] = XHV_NS.send("#{term}_"); hash },
+        }
+      else
+        {}
+      end
       # parse
       parse_whole_document(@doc, @uri)
@@ -90,6 +158,7 @@ module RdfContext
     # Parsing an RDFa document (this is *not* the recursive method)
     def parse_whole_document(doc, base)
       # find if the document has a base element
+      # XXX - HTML specific
       base_el = doc.css('html>head>base').first
       if (base_el)
         base = base_el.attributes['href']
@@ -100,28 +169,127 @@ module RdfContext
       end
       # initialize the evaluation context with the appropriate base
-      evaluation_context= EvaluationContext.new(base)
+      evaluation_context = EvaluationContext.new(base, @host_defaults)
       traverse(doc.root, evaluation_context)
     end
     # Extract the XMLNS mappings from an element
-    def extract_mappings(element)
-      mappings = {}
+    def extract_mappings(element, uri_mappings, term_mappings)
+      # Process @profile
+      # Next the current element is parsed for any updates to the local term mappings and
+      # local list of URI mappings via @profile.
+      # If @profile is present, its value is processed as defined in RDFa Profiles.
+      element.attributes['profile'].to_s.split(/\s/).each do |profile|
+        # Don't try to open ourselves!
+        if @uri == profile
+          add_debug(element, "extract_mappings: skip recursive profile <#{profile}>")
+          @@vocabulary_cache[profile]
+        elsif @@vocabulary_cache.has_key?(profile)
+          add_debug(element, "extract_mappings: skip previously parsed profile <#{profile}>")
+        else
+          begin
+            add_debug(element, "extract_mappings: parse profile <#{profile}>")
+            @@vocabulary_cache[profile] = {
+              :uri_mappings => {},
+              :term_mappings => {}
+            }
+            um = @@vocabulary_cache[profile][:uri_mappings]
+            tm = @@vocabulary_cache[profile][:term_mappings]
+            add_debug(element, "extract_mappings: profile open <#{profile}>")
+            require 'patron' unless defined?(Patron)
+            sess = Patron::Session.new
+            sess.timeout = 10
+            resp = sess.get(profile)
+            raise RuntimeError, "HTTP returned status #{resp.status} when reading #{profile}" if resp.status >= 400
+            # Parse profile, and extract mappings from graph
+            old_debug, old_verbose, = $DEBUG, $verbose
+            $DEBUG, $verbose = false, false
+            p_graph = Parser.parse(resp.body, profile)
+            ttl = p_graph.serialize(:format => :ttl) if @debug || $DEBUG
+            $DEBUG, $verbose = old_debug, old_verbose
+            add_debug(element, ttl) if ttl
+            p_graph.subjects.each do |subject|
+              props = p_graph.properties(subject)
+              #puts props.inspect
+              # If one of the objects is not a Literal or if there are additional rdfa:uri or rdfa:term
+              # predicates sharing the same subject, no mapping is created.
+              uri = props[RDFA_NS.uri_.to_s]
+              term = props[RDFA_NS.term_.to_s]
+              prefix = props[RDFA_NS.prefix_.to_s]
+              add_debug(element, "extract_mappings: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}")
+              next if !uri || (!term && !prefix)
+              raise ParserException, "multi-valued rdf:uri" if uri.length != 1
+              raise ParserException, "multi-valued rdf:term." if term && term.length != 1
+              raise ParserException, "multi-valued rdf:prefix" if prefix && prefix.length != 1
+              uri = uri.first
+              term = term.first if term
+              prefix = prefix.first if prefix
+              raise ParserException, "rdf:uri must be a Literal" unless uri.is_a?(Literal)
+              raise ParserException, "rdf:term must be a Literal" unless term.nil? || term.is_a?(Literal)
+              raise ParserException, "rdf:prefix must be a Literal" unless prefix.nil? || prefix.is_a?(Literal)
+              # For every extracted triple that is the common subject of an rdfa:prefix and an rdfa:uri
+              # predicate, create a mapping from the object literal of the rdfa:prefix predicate to the
+              # object literal of the rdfa:uri predicate. Add or update this mapping in the local list of
+              # URI mappings after transforming the 'prefix' component to lower-case.
+              # For every extracted
+              um[prefix.to_s.downcase] = @graph.bind(Namespace.new(uri.to_s, prefix.to_s.downcase)) if prefix
+              # triple that is the common subject of an rdfa:term and an rdfa:uri predicate, create a
+              # mapping from the object literal of the rdfa:term predicate to the object literal of the
+              # rdfa:uri predicate. Add or update this mapping in the local term mappings.
+              tm[term.to_s] = URIRef.new(uri.to_s) if term
+            end
+          rescue ParserException
+            add_debug(element, "extract_mappings: profile subject #{subject.to_s}: #{e.message}")
+            raise if @strict
+          rescue RuntimeError => e
+            add_debug(element, "extract_mappings: profile: #{e.message}")
+            raise if @strict
+          end
+        end
+        # Merge mappings from this vocabulary
+        uri_mappings.merge!(@@vocabulary_cache[profile][:uri_mappings])
+        term_mappings.merge!(@@vocabulary_cache[profile][:term_mappings])
+      end
       # look for xmlns
-      element.namespaces.each do |attr_name,attr_value|
+      # (note, this may be dependent on @host_language)
+      # Regardless of how the mapping is declared, the value to be mapped must be converted to lower case,
+      # 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.
+      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"
+          abbr, prefix = attr_name.split(":")
+          uri_mappings[prefix.to_s.downcase] = @graph.bind(Namespace.new(attr_value, prefix.to_s.downcase)) if abbr.downcase == "xmlns" && prefix
         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
+      # Set mappings from @prefix
+      # prefix is a whitespace separated list of prefix-name URI pairs of the form
+      #   NCName ':' ' '+ xs:anyURI
+      # SPEC Confusion: prefix is forced to lower-case in @profile, but not specified here.
+      mappings = element.attributes["prefix"].to_s.split(/\s+/)
+      while mappings.length > 0 do
+        prefix, uri = mappings.shift.downcase, mappings.shift
+        #puts "uri_mappings prefix #{prefix} <#{uri}>"
+        next unless prefix.match(/:$/)
+        prefix.chop!
+        uri_mappings[prefix] = @graph.bind(Namespace.new(uri, prefix))
+      end
+      add_debug(element, "uri_mappings: #{uri_mappings.values.map{|ns|ns.to_s}.join(", ")}")
+      add_debug(element, "term_mappings: #{term_mappings.keys.join(", ")}")
     end
     # The recursive helper function
@@ -132,6 +300,8 @@ module RdfContext
         return nil
       end
+      add_debug(element, "traverse, ec: #{evaluation_context.inspect}")
       # local variables [5.5 Step 1]
       recurse = true
       skip = false
@@ -140,6 +310,10 @@ module RdfContext
       uri_mappings = evaluation_context.uri_mappings.clone
       incomplete_triples = []
       language = evaluation_context.language
+      term_mappings = evaluation_context.term_mappings.clone
+      default_vocabulary = evaluation_context.default_vocabulary
+      current_object_literal = nil  # XXX Not explicit
       # shortcut
       attrs = element.attributes
@@ -148,6 +322,7 @@ module RdfContext
       src = attrs['src']
       resource = attrs['resource']
       href = attrs['href']
+      vocab = attrs['vocab']
       # Pull out the attributes needed for the skip test.
       property = attrs['property'].to_s if attrs['property']
@@ -157,42 +332,73 @@ module RdfContext
       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))
+      # Default vocabulary [7.5 Step 2]
+      # First 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?
+          # Set default_vocabulary to host language default
+          @host_defaults.fetch(:voabulary, nil)
+        else
+          vocab.to_s
+        end
+        add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
+      end
+      # Local term mappings [7.5 Steps 3 & 4]
+      # Next the current element is parsed for any updates to the local term mappings and local list of URI mappings via @profile.
+      # If @profile is present, its value is processed as defined in RDFa Profiles.
+      extract_mappings(element, uri_mappings, term_mappings)
-      # Language information [5.5 Step 3]
-      add_debug(element, "traverse, lang: #{attrs['lang']}") if attrs['lang']
-      language = attrs['lang'] || language
+      # Language information [7.5 Step 5]
+      # 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 element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s)
+        element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s).to_s
+      when element.at_xpath("lang")
+        element.at_xpath("lang").to_s
+      else
+        language
+      end
+      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if attrs['lang']
       # 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?)
+      rels = process_uris(element, rel, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+      revs = process_uris(element, rev, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
-      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 !(rel || rev)
+        # Establishing a new subject if no rel/rev [7.5 Step 6]
+        # May not be valid, but can exist
         if about
-          new_subject = uri_or_safe_curie(about, evaluation_context, uri_mappings)
+          new_subject = process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
         elsif src
-          new_subject = URIRef.new(src, evaluation_context.base)
+          new_subject = process_uri(element, src, evaluation_context)
         elsif resource
-          new_subject =  uri_or_safe_curie(resource, evaluation_context, uri_mappings)
+          new_subject =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
         elsif href
-          new_subject = URIRef.new(href, evaluation_context.base)
+          new_subject = process_uri(element, href, evaluation_context)
         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 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';
         if new_subject.nil?
-          if element.name =~ /^(head|body)$/ && evaluation_context.base
+          if @host_language == :xhtml && element.name =~ /^(head|body)$/ && evaluation_context.base
+            # 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.
             new_subject = URIRef.new(evaluation_context.base)
           elsif element.attributes['typeof']
             new_subject = BNode.new
@@ -202,19 +408,23 @@ module RdfContext
             skip = true unless property
           end
         end
-        add_debug(element, "new_subject: #{new_subject}, skip = #{skip}")
+        add_debug(element, "[Step 6] new_subject: #{new_subject}, skip = #{skip}")
       else
-        # Establish both new subject and current object resource [5.5 Step 5]
+        # [7.5 Step 7]
+        # 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:
         if about
-          new_subject =  uri_or_safe_curie(about, evaluation_context, uri_mappings)
+          new_subject =  process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
         elsif src
-          new_subject =  uri_or_safe_curie(src, evaluation_context, uri_mappings)
+          new_subject =  process_uri(element, src, evaluation_context, :uri_mappings => 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)$/
+          if @host_language == :xhtml && 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.
             new_subject = URIRef.new(evaluation_context.base)
           elsif element.attributes['typeof']
             new_subject = BNode.new
@@ -225,90 +435,85 @@ module RdfContext
           end
         end
+        # Then the current object resource is set to the URI obtained from the first match from the following rules:
         if resource
-          current_object_resource =  uri_or_safe_curie(resource, evaluation_context, uri_mappings)
+          current_object_resource =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
         elsif href
-          current_object_resource = URIRef.new(href, evaluation_context.base)
+          current_object_resource = process_uri(element, href, evaluation_context)
         end
-        add_debug(element, "new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
+        add_debug(element, "[Step 7] 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]
+      # Process @typeof if there is a subject [Step 8]
       if new_subject and typeof
-        types = parse_curies(typeof, uri_mappings, evaluation_context.base, false)
+        # Typeof is TERMorCURIEorURIs
+        types = process_uris(element, typeof, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
         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]
+      # Generate triples with given object [Step 9]
       if current_object_resource
-        rels.each do |rel|
-          add_triple(element, new_subject, rel, current_object_resource)
+        rels.each do |r|
+          add_triple(element, new_subject, r, current_object_resource)
         end
-        revs.each do |rev|
-          add_triple(element, current_object_resource, rev, new_subject)
+        revs.each do |r|
+          add_triple(element, current_object_resource, r, 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
+      elsif rel || rev
+        # Incomplete triples and bnode creation [Step 10]
+        add_debug(element, "[Step 10] incompletes: rels: #{rels}, revs: #{revs}")
+        current_object_resource = BNode.new
-        rels.each do |rel|
-          # SPEC CONFUSION: we don't store the subject here?
-          incomplete_triples << {:predicate => rel, :direction => :forward}
+        rels.each do |r|
+          incomplete_triples << {:predicate => r, :direction => :forward}
         end
-        revs.each do |rev|
-          # SPEC CONFUSION: we don't store the object here?
-          incomplete_triples << {:predicate => rev, :direction => :reverse}
+        revs.each do |r|
+          incomplete_triples << {:predicate => r, :direction => :reverse}
         end
       end
-      # Establish current object literal [Step 9]
+      # Establish current object literal [Step 11]
       if property
-        properties = parse_curies(property, uri_mappings, evaluation_context.base, false)
+        properties = process_uris(element, property, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
         # 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
+        type_resource = process_uri(element, type, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary) if type
         if type and !type.empty? and (type_resource.to_s != XML_LITERAL.to_s)
           # typed literal
-          add_debug(element, "typed literal")
+          add_debug(element, "[Step 11] 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")
+          add_debug(element, "[Step 11] 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}")
+          add_debug(element, "[Step 11] 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)
+        properties.each do |p|
+          add_triple(element, new_subject, p, 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
+      if not skip and new_subject && !evaluation_context.incomplete_triples.empty?
+        # Complete the incomplete triples from the evaluation context [Step 12]
+        add_debug(element, "[Step 12] complete incomplete triples: new_subject=#{new_subject}, completes=#{evaluation_context.incomplete_triples.inspect}")
         evaluation_context.incomplete_triples.each do |trip|
           if trip[:direction] == :forward
             add_triple(element, evaluation_context.parent_subject, trip[:predicate], new_subject)
@@ -317,26 +522,35 @@ module RdfContext
           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?
+      # Create a new evaluation context and proceed recursively [Step 13]
+      if recurse
         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}")
+          if language == evaluation_context.language &&
+              uri_mappings == evaluation_context.uri_mappings &&
+              term_mappings == evaluation_context.term_mappings &&
+              default_vocabulary == evaluation_context.default_vocabulary &&
+            new_ec = evaluation_context
+            add_debug(element, "[Step 13] skip: reused ec")
+          else
+            new_ec = evaluation_context.clone
+            new_ec.language = language
+            new_ec.uri_mappings = uri_mappings
+            new_ec.term_mappings = term_mappings
+            new_ec.default_vocabulary = default_vocabulary
+            add_debug(element, "[Step 13] skip: cloned ec")
+          end
         else
           # create a new evaluation context
-          new_ec = EvaluationContext.new(evaluation_context.base)
+          new_ec = EvaluationContext.new(evaluation_context.base, @host_defaults)
           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}")
+          new_ec.term_mappings = term_mappings
+          new_ec.default_vocabulary = default_vocabulary
+          add_debug(element, "[Step 13] new ec")
         end
         element.children.each do |child|
@@ -345,57 +559,97 @@ module RdfContext
         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
+    # space-separated TERMorCURIEorURI
+    def process_uris(element, value, evaluation_context, options)
+      return [] if value.to_s.empty?
+      add_debug(element, "process_uris: #{value}")
+      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, options)}.compact
+    end
+    def process_uri(element, value, evaluation_context, options = {})
+      #return if value.to_s.empty?
+      #add_debug(element, "process_uri: #{value}")
+      options = {:uri_mappings => {}}.merge(options)
+      if !options[:term_mappings] && options[:uri_mappings] && value.to_s.match(/^\[(.*)\]$/)
+        # SafeCURIEorCURIEorURI
+        # When the value is surrounded by square brackets, then the content within the brackets is
+        # evaluated as a CURIE according to the CURIE Syntax definition. If it is not a valid CURIE, the
+        # value must be ignored.
+        uri = curie_to_resource_or_bnode(element, $1, options[:uri_mappings], evaluation_context.parent_subject)
+        add_debug(element, "process_uri: #{value} => safeCURIE => <#{uri}>")
+        uri
+      elsif options[:term_mappings] && NC_REGEXP.match(value.to_s)
+        # TERMorCURIEorURI
+        # If the value is an NCName, then it is evaluated as a term according to General Use of Terms in
+        # Attributes. Note that this step may mean that the value is to be ignored.
+        uri = process_term(value.to_s, options)
+        add_debug(element, "process_uri: #{value} => term => <#{uri}>")
+        uri
+      else
+        # SafeCURIEorCURIEorURI or TERMorCURIEorURI
+        # Otherwise, the value is evaluated as a CURIE.
+        # If it is a valid CURIE, the resulting URI is used; otherwise, the value will be processed as a URI.
+        uri = curie_to_resource_or_bnode(element, value, options[:uri_mappings], evaluation_context.parent_subject)
+        if uri
+          add_debug(element, "process_uri: #{value} => CURIE => <#{uri}>")
+        else
+          uri = URIRef.new(value, evaluation_context.base)
+          add_debug(element, "process_uri: #{value} => URI => <#{uri}>")
         end
+        uri
+      end
+    end
+    # [7.4.3] General Use of Terms in Attributes
+    #
+    # @param [String] term:: term
+    # @param [Hash] options:: Parser options, one of
+    # <em>options[:term_mappings]</em>:: Term mappings
+    # <em>options[:vocab]</em>:: Default vocabulary
+    def process_term(value, options)
+      case
+      when options[:term_mappings].is_a?(Hash) && options[:term_mappings].has_key?(value.to_s.downcase)
+        # If the term is in the local term mappings, use the associated URI.
+        # XXX Spec Confusion: are terms always downcased? Or only for XHTML Vocab?
+        options[:term_mappings][value.to_s.downcase]
+      when options[:vocab]
+        # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
+        options[:vocab] + value
+      else
+        # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
+        nil
       end
-      resource_array
     end
-    def curie_to_resource_or_bnode(curie, uri_mappings, subject)
+    # From section 6. CURIE Syntax Definition
+    def curie_to_resource_or_bnode(element, 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(":")
+      prefix, reference = 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 #{subject}")
-        # Empty curie resolves to current subject (No, an empty curie should be ignored)
-#        URIRef.new(subject)
+        BNode.new(reference || "", @named_bnodes)
+      elsif curie.to_s.match(/^:/)
+        # Default prefix
+        if uri_mappings[""]
+          uri_mappings[""].send("#{reference}_")
+        elsif @host_defaults[:prefix]
+          @host_defaults[:prefix].send("#{reference}_")
+        end
+      elsif !curie.to_s.match(/:/)
+        # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
         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
+        # XXX Spec Confusion, are prefixes always downcased?
+        ns = uri_mappings[prefix.to_s.downcase]
+        if ns
+          ns + reference
+        else
+          add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix.downcase}")
+          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