rdf_context 0.5.6 → 0.5.7

data/lib/rdf_context/literal.rb

@@ -277,6 +277,7 @@ module RdfContext
       end
     end
 
+    # @private
     class Language
       attr_accessor :value
       def initialize(string)
@@ -302,10 +303,25 @@ module RdfContext
       def to_s; @value; end
     end
 
-    attr_accessor :contents, :encoding, :lang
+    # Contents of Literal
+    attr_accessor :contents
+    
+    # Encoding defined for literal
+    # @return [Literal::Encoding]
+    attr_accessor :encoding
+    
+    # Language associated with literal
+    # @return [String]
+    attr_accessor :lang
     
     # Create a new Literal. Optinally pass a namespaces hash
     # for use in applying to rdf::XMLLiteral values.
+    # @param [Object] contents
+    # @param [Encoding] encoding
+    # @option options [String] :language
+    # @option options [Hash{String => Namespace}] :namespaces
+    # @return [Literal]
+    # @raise [TypeError]
     def initialize(contents, encoding, options = {})
       unless encoding.is_a?(Encoding)
         raise TypeError, "#{encoding.inspect} should be an instance of Encoding"
@@ -319,6 +335,11 @@ module RdfContext
     end
     
     # Create literal from a string that is already N3 encoded.
+    # @param [Object] contents
+    # @param [String] language
+    # @param [Encoding] encoding (nil)
+    # @return [Literal]
+    # @raise [TypeError]
     def self.n3_encoded(contents, language, encoding = nil)
       encoding = encoding.nil? ? Encoding.the_null_encoding : Encoding.coerce(encoding)
       options = {}
@@ -330,6 +351,10 @@ module RdfContext
     end
     
     # Create an un-typed literal with a language
+    # @param [Object] contents
+    # @param [String] language (nil)
+    # @return [Literal]
+    # @raise [TypeError]
     def self.untyped(contents, language = nil)
       options = {}
       options[:language] = language if language
@@ -337,19 +362,27 @@ module RdfContext
     end
     
     # Create a typed literal
-    # Options include:
-    # _namespaces_:: A hash of namespace entries (for XMLLiteral)
+    # @param [Object] contents
+    # @param [Encoding] encoding (nil)
+    # @option options [Hash{String => Namespace}] :namespaces
+    # @return [Literal]
+    # @raise [TypeError]
     def self.typed(contents, encoding, options = {})
       encoding = Encoding.coerce(encoding)
       new(contents, encoding, options)
     end
     
     # Create a literal appropriate for type of object by datatype introspection
+    # @param [Object] contents
+    # @return [Literal]
+    # @raise [TypeError]
     def self.build_from(object)
       new(object.to_s, infer_encoding_for(object))
     end
 
     # Infer the proper XML datatype for the given object
+    # @param [Object] contents
+    # @return [Encoding]
     def self.infer_encoding_for(object)
       case object
       when TrueClass  then Encoding.boolean

data/lib/rdf_context/n3parser.rb

@@ -15,13 +15,13 @@ module RdfContext
     #
     # @param [String] n3_str:: the Notation3/Turtle string
     # @param [String] uri:: the URI of the document
-    # @param [Hash] options:: Options include the following
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:strict]</em>:: Abort or proceed on error
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     # @return [Graph]
-    # @raise RdfContext::RdfException or subclass
+    # @raise RdfException or subclass
     #
     # @author Patrick Sinclair (metade)
+    # @author Gregg Kellogg
     def parse(stream, uri = nil, options = {}, &block) # :yields: triple
       super
 

data/lib/rdf_context/namespace.rb

@@ -10,10 +10,10 @@ module RdfContext
     # ==== Example
     #   Namespace.new("http://xmlns.com/foaf/0.1/", "foaf") # => returns a new Foaf namespace
     #
-    # @param [String] uri:: the URI of the namespace
-    # @param [String] prefix:: the prefix of the namespace
-    # @return [Namespace]:: The newly created namespace.
-    # @raise [Error]:: Checks validity of the desired prefix and raises if it is incorrect.
+    # @param [#to_s] uri the URI of the namespace
+    # @param [#to_s] prefix the prefix of the namespace
+    # @return [Namespace] The newly created namespace.
+    # @raise [ParserException] Checks validity of the desired prefix and raises if it is incorrect.
     #
     # @author Tom Morris, Pius Uzamere
     def initialize(uri, prefix)
@@ -28,15 +28,18 @@ module RdfContext
     ## 
     # Allows the construction of arbitrary URIs on the namespace.
     #
-    # ==== Example
+    # @example
     #   foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf"); foaf.knows # => returns a new URIRef with URI "http://xmlns.com/foaf/0.1/knows"
     #   foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf", true); foaf.knows # => returns a new URIRef with URI "http://xmlns.com/foaf/0.1/#knows"
     #
     # To avoid naming problems, a suffix may have an appended '_', which will be removed when the URI is generated.
     #
-    # @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
+    # @param [#to_s] methodname to append to NS URI to create a new URI
+    # @param [Array] args Ignored arguments
+    # @return [URIRef] The newly created URI.
+    # @raise [Error] Checks validity of the desired prefix and raises if it is incorrect.
+    # @author Tom Morris
+    # @author Pius Uzamere
     def method_missing(methodname, *args)
       self + methodname
     end
@@ -44,6 +47,8 @@ module RdfContext
     # Construct a URIRef from a namespace as in method_missing, but without method collision issues.
     # 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
+    # @param [#to_s] methodname to append to NS URI to create a new URI
+    # @return [URIRef] The newly created URI.
     def +(suffix)
       prefix = @uri
       suffix = suffix.to_s.sub(/^\#/, "") if prefix.index("#")
@@ -52,31 +57,39 @@ module RdfContext
     end
 
     # Make sure to attach fragment
+    # @return [URIRef] The newly created URI.
     def uri
       self + ""
     end
     
     # Bind this namespace to a Graph
+    # @param [Graph] graph
+    # @return [Namespace] The newly created URI.
     def bind(graph)
       graph.bind(self)
     end
 
     # Compare namespaces
+    # @param [Namespace] other
+    # @return [Boolean]
     def eql?(other)
       self.uri == other.uri
     end
     alias_method :==, :eql?
 
     # Output xmlns attribute name
+    # @return [String]
     def xmlns_attr
       prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
     end
     
     # Output namespace definition as a hash
+    # @return [Hash{String => String}]
     def xmlns_hash
       {xmlns_attr => @uri.to_s}
     end
     
+    # @return [String]
     def to_s
       "#{prefix}: #{@uri}"
     end

data/lib/rdf_context/parser.rb

@@ -9,11 +9,10 @@ module RdfContext
     ## 
     # 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
-    # <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
+    # @option options [Graph] :graph (nil) Graph to parse into, otherwise a new RdfContext::Graph instance is created
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [:rdfxml, :html, :n3] :type (nil)
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     def initialize(options = {})
       # initialize the triplestore
       @graph = options[:graph]
@@ -24,12 +23,15 @@ module RdfContext
     
     # Instantiate Parser and parse document
     #
-    # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
-    # @param [String] uri:: the URI of the document
-    # @param [Hash] options::  Options from
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_ (among others)
-    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @param  [#read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri (nil) the URI of the document
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [:rdfxml, :html, :n3] :type (nil)
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph] Returns the graph containing parsed triples
+    # @yield  [triple]
+    # @yieldparam [Triple] triple
+    # @raise [Error]:: Raises RdfError if _strict_
     # @return [Graph]:: Returns the graph containing parsed triples
     # @raise [Error]:: Raises RdfError if _strict_
     def self.parse(stream, uri = nil, options = {}, &block) # :yields: triple
@@ -44,11 +46,15 @@ module RdfContext
     #
     # Virtual Class, prototype for Parser subclass.
     #
-    # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
-    # @param [String] uri:: the URI of the document
-    # @param [Hash] options::  Options from
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @param  [#read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri (nil) the URI of the document
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [:rdfxml, :html, :n3] :type (nil)
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph] Returns the graph containing parsed triples
+    # @yield  [triple]
+    # @yieldparam [Triple] triple
+    # @raise [Error]:: Raises RdfError if _strict_
     # @return [Graph]:: Returns the graph containing parsed triples
     # @raise [Error]:: Raises RdfError if _strict_
     def parse(stream, uri = nil, options = {}, &block) # :yields: triple
@@ -81,17 +87,26 @@ module RdfContext
     end
     
     
+    # @return [Graph]
     def graph; @delegate ? @delegate.graph : (@graph || Graph.new); end
+    
+    # @return [Array<String>]
     def debug; @delegate ? @delegate.debug : @debug; end
 
     # Return N3 Parser instance
+    # @return [N3Parser]
     def self.n3_parser(options = {}); N3Parser.new(options); end
     # Return RDF/XML Parser instance
+    # @return [RdfXmlParser]
     def self.rdfxml_parser(options = {}); RdfXmlParser.new(options); end
     # Return Rdfa Parser instance
+    # @return [RdfaParser]
     def self.rdfa_parser(options = {}); RdfaParser.new(options); end
 
     # Heuristically detect the format of the uri
+    # @param [#read, #to_s] stream
+    # @param [#to_s] uri (nil)
+    # @return [:rdfxml, :rdfa, :n3]
     def detect_format(stream, uri = nil)
       uri ||= stream.path if stream.respond_to?(:path)
       format = case uri.to_s

data/lib/rdf_context/quoted_graph.rb

@@ -14,15 +14,15 @@ module RdfContext
     ## 
     # Adds one or more extant triples to a graph. Delegates to Store.
     #
-    # ==== Example
+    # @example
     #   g = Graph.new;
     #   t1 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
     #   t2 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
     #   g.add(t1, t2, ...)
     #
-    # @param [Triple] triples:: one or more triples. Last element may be a hash for options
-    # <em>options[:context]</em>:: Graph context in which to deposit triples, defaults to default_context or self
-    # @return [Graph]:: Returns the graph
+    # @param [Array<Triple>] triples one or more triples. Last element may be a hash for options
+    # @option [Resource] :context Graph context in which to deposit triples, defaults to default_context or self
+    # @return [Graph] Returns the graph
     def add(*triples)
       options = triples.last.is_a?(Hash) ? triples.pop : {}
       ctx = options[:context] || @default_context || self
@@ -31,6 +31,7 @@ module RdfContext
     end
     
     # Return an n3 identifier for the Graph
+    # @return [String]
     def n3
       "{#{self.identifier.to_n3}}"
     end

data/lib/rdf_context/rdfaparser.rb

@@ -5,56 +5,88 @@ module RdfContext
   # An RDFa parser in Ruby
   #
   # Based on processing rules described here:
-  #   file:///Users/gregg/Projects/rdf_context/RDFa%20Core%201.1.html#sequence
+  # @see http://www.w3.org/TR/rdfa-syntax/#s_model RDFa 1.0
+  # @see http://www.w3.org/2010/02/rdfa/drafts/2010/ED-rdfa-core-20100705/ RDFa 1.1
   #
-  # Ben Adida
-  # 2008-05-07
-  # Gregg Kellogg
-  # 2009-08-04
+  # @author Ben Adida
+  # @author Gregg Kellogg
   class RdfaParser < Parser
-    # Host language, One of:
-    #   :xhtml_rdfa_1_0
-    #   :xhtml_rdfa_1_1
+    # Host language
+    # @return [:xhtml]
     attr_reader :host_language
+
+    # Version
+    # @return [:rdfa_1_0, :rdfa_1_1]
+    attr_reader :version
     
     # The Recursive Baggage
+    # @private
     class EvaluationContext # :nodoc:
-      # The base. This will usually be the URL of the document being processed,
+      # 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.
+      #
+      # @return [URIRef]
       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.
+      #
+      # @return [URIRef]
       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.
+      #
+      # @return URIRef
       attr :parent_object, true
       # A list of current, in-scope URI mappings.
+      #
+      # @return [Hash{String => Namespace}]
       attr :uri_mappings, true
-      # A list of incomplete triples. A triple can be incomplete when no object resource
+      # 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).
+      #
+      # @return [Array<Array<URIRef, Resource>>]
       attr :incomplete_triples, true
       # The language. Note that there is no default language.
+      #
+      # @return [String]
       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.
+      #
+      # @return [Hash{String => URIRef}]
       attr :term_mappings, true
-      # The default vocabulary, a value to use as the prefix URI when a term is used.
+      # 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.
+      #
+      # @return [URIRef]
       attr :default_vocabulary, true
 
+      # @param [String] base
+      # @param [Hash] host_defaults
+      # @option host_defaults [Hash{String => URIRef}] :term_mappings Hash of NCName => URIRef
+      # @option host_defaults [Hash{String => Namespace}] :vocabulary Hash of prefix => URIRef
       def initialize(base, host_defaults)
         # Initialize the evaluation context, [5.1]
         @base = base
@@ -64,10 +96,12 @@ module RdfContext
         @incomplete_triples = []
         @language = nil
         @term_mappings = host_defaults.fetch(:term_mappings, {})
-        @default_voabulary = host_defaults.fetch(:voabulary, nil)
+        @default_vocabulary = host_defaults.fetch(:vocabulary, nil)
       end
 
       # Copy this Evaluation Context
+      #
+      # @param [EvaluationContext] from
       def initialize_copy(from)
           # clone the evaluation context correctly
           @uri_mappings = from.uri_mappings.clone
@@ -86,11 +120,10 @@ module RdfContext
     ## 
     # 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
+    # @option options [Graph] :graph (nil) Graph to parse into, otherwise a new RdfContext::Graph instance is created
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [:rdfxml, :html, :n3] :type (nil)
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     def initialize(options = {})
       super
       @@vocabulary_cache ||= {}
@@ -104,12 +137,13 @@ module RdfContext
     # Optionally, the stream may be a Nokogiri::HTML::Document or Nokogiri::XML::Document
     # With a block, yeilds each statement with URIRef, BNode or Literal elements
     #
-    # @param  [IO] stream:: the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
-    # @param [String] uri:: the URI of the document
-    # @param [Hash] options:: Parser options, one of
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
-    # @return [Graph]:: Returns the graph containing parsed triples
+    # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, #read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri (nil) the URI of the document
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph] Returns the graph containing parsed triples
+    # @yield  [triple]
+    # @yieldparam [Triple] triple
     # @raise [Error]:: Raises RdfError if _strict_
     def parse(stream, uri = nil, options = {}, &block) # :yields: triple
       super
@@ -125,19 +159,24 @@ module RdfContext
 
       # Determine host language
       # XXX - right now only XHTML defined
-      @host_language = case @doc.root && @doc.root.attributes["version"].to_s
+      version = @doc.root.attributes["version"].to_s if @doc.root
+      
+      @host_language = case version.to_s
       when /XHTML+RDFa/ then :xhtml
       end
       
       # If none found, assume xhtml
       @host_language ||= :xhtml
       
+      @version = version.to_s.match(/RDFa 1.0/) ? :rdfa_1_0 : :rdfa_1_1
+
       @host_defaults = case @host_language
       when :xhtml
         @graph.bind(XHV_NS)
         {
           :vocabulary => XHV_NS.uri,
           :prefix     => XHV_NS,
+          :uri_mappings => {"xhv" => XHV_NS}, # RDF::XHTML is wrong
           :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
@@ -146,7 +185,10 @@ module RdfContext
       else
         {}
       end
+
+      @host_defaults.delete(:vocabulary) if @version == :rdfa_1_0
       
+      add_debug(@doc, "version = #{@version},  host_language = #{@host_language}")
       # parse
       parse_whole_document(@doc, @uri)
 
@@ -232,13 +274,13 @@ module RdfContext
               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
+              um[prefix.to_s.downcase] = @graph.bind(Namespace.new(uri.to_s, prefix.to_s.downcase)) if prefix && prefix.to_s != "_"
             
               # 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
@@ -257,7 +299,7 @@ module RdfContext
         # Merge mappings from this vocabulary
         uri_mappings.merge!(@@vocabulary_cache[profile][:uri_mappings])
         term_mappings.merge!(@@vocabulary_cache[profile][:term_mappings])
-      end
+      end unless @version == :rdfa_1_0
       
       # look for xmlns
       # (note, this may be dependent on @host_language)
@@ -267,7 +309,11 @@ module RdfContext
       element.namespaces.each do |attr_name, attr_value|
         begin
           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
+          # A Conforming RDFa Processor must ignore any definition of a mapping for the '_' prefix.
+          next if prefix == "_"
+
+          pfx_lc = @version == :rdfa_1_0 || prefix.nil? ? prefix : prefix.to_s.downcase
+          uri_mappings[pfx_lc] = @graph.bind(Namespace.new(attr_value, prefix.to_s)) if abbr.downcase == "xmlns" && prefix
         rescue RdfException => e
           add_debug(element, "extract_mappings raised #{e.class}: #{e.message}")
           raise if @strict
@@ -285,8 +331,11 @@ module RdfContext
         next unless prefix.match(/:$/)
         prefix.chop!
         
+        # A Conforming RDFa Processor must ignore any definition of a mapping for the '_' prefix.
+        next if prefix == "_"
+
         uri_mappings[prefix] = @graph.bind(Namespace.new(uri, prefix))
-      end
+      end unless @version == :rdfa_1_0
       
       add_debug(element, "uri_mappings: #{uri_mappings.values.map{|ns|ns.to_s}.join(", ")}")
       add_debug(element, "term_mappings: #{term_mappings.keys.join(", ")}")
@@ -339,9 +388,9 @@ module RdfContext
       unless vocab.nil?
         default_vocabulary = if vocab.to_s.empty?
           # Set default_vocabulary to host language default
-          @host_defaults.fetch(:voabulary, nil)
+          @host_defaults.fetch(:vocabulary, nil)
         else
-          vocab.to_s
+          URIRef.new(vocab)
         end
         add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
       end
@@ -368,8 +417,16 @@ module RdfContext
       add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if attrs['lang']
     
       # rels and revs
-      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)
+      rels = process_uris(element, rel, evaluation_context,
+                          :uri_mappings => uri_mappings,
+                          :term_mappings => term_mappings,
+                          :vocab => default_vocabulary,
+                          :r_1_0_restrictions => [:uri, :bnode, :term])
+      revs = process_uris(element, rev, evaluation_context,
+                          :uri_mappings => uri_mappings,
+                          :term_mappings => term_mappings,
+                          :vocab => default_vocabulary,
+                          :r_1_0_restrictions => [:uri, :bnode, :term])
     
       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}")
@@ -378,14 +435,18 @@ module RdfContext
       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 = process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
+        new_subject = if about
+          process_uri(element, about, evaluation_context,
+                      :uri_mappings => uri_mappings,
+                      :r_1_0_restrictions => [:uri, :safe_curie, :bnode])
         elsif src
-          new_subject = process_uri(element, src, evaluation_context)
+          process_uri(element, src, evaluation_context, :r_1_0_restrictions => [:uri])
         elsif resource
-          new_subject =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
+          process_uri(element, resource, evaluation_context,
+                      :uri_mappings => uri_mappings,
+                      :r_1_0_restrictions => [:uri, :safe_curie, :bnode])
         elsif href
-          new_subject = process_uri(element, href, evaluation_context)
+          process_uri(element, href, evaluation_context, :r_1_0_restrictions => [:uri])
         end
 
         # If no URI is provided by a resource attribute, then the first match from the following rules
@@ -394,52 +455,49 @@ module RdfContext
         # 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 @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, :normalize => false)
-          elsif element.attributes['typeof']
-            new_subject = BNode.new
-          else
-            # if it's null, it's null and nothing changes
-            new_subject = evaluation_context.parent_object
-            skip = true unless property
-          end
+        new_subject ||= 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.
+          URIRef.new(evaluation_context.base, :normalize => false)
+        elsif element.attributes['typeof']
+          BNode.new
+        else
+          skip = true unless property
+          # if it's null, it's null and nothing changes
+          evaluation_context.parent_object
         end
         add_debug(element, "[Step 6] new_subject: #{new_subject}, skip = #{skip}")
       else
         # [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 =  process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
-        elsif src
-          new_subject =  process_uri(element, src, evaluation_context, :uri_mappings => uri_mappings)
-        end
+        new_subject = process_uri(element, about || src, evaluation_context,
+                                  :uri_mappings => uri_mappings,
+                                  :r_1_0_restrictions => [:uri, :safe_curie, :bnode])
       
         # If no URI is provided then the first match from the following rules will apply
-        if new_subject.nil?
-          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, :normalize => false)
-          elsif element.attributes['typeof']
-            new_subject = BNode.new
-          else
-            # if it's null, it's null and nothing changes
-            new_subject = evaluation_context.parent_object
-            # no skip flag set this time
-          end
+        new_subject ||= 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.
+          URIRef.new(evaluation_context.base, :normalize => false)
+        elsif element.attributes['typeof']
+          BNode.new
+        else
+          # if it's null, it's null and nothing changes
+          evaluation_context.parent_object
+          # no skip flag set this time
         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 =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
+        current_object_resource = if resource
+          process_uri(element, resource, evaluation_context,
+                      :uri_mappings => uri_mappings,
+                      :r_1_0_restrictions => [:uri, :safe_curie, :bnode])
         elsif href
-          current_object_resource = process_uri(element, href, evaluation_context)
+          process_uri(element, href, evaluation_context,
+                      :r_1_0_restrictions => [:uri])
         end
 
         add_debug(element, "[Step 7] new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
@@ -448,7 +506,11 @@ module RdfContext
       # Process @typeof if there is a subject [Step 8]
       if new_subject and typeof
         # Typeof is TERMorCURIEorURIs
-        types = process_uris(element, typeof, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+        types = process_uris(element, typeof, evaluation_context,
+                            :uri_mappings => uri_mappings,
+                            :term_mappings => term_mappings,
+                            :vocab => default_vocabulary,
+                            :r_1_0_restrictions => [:curie, :bnode])
         add_debug(element, "typeof: #{typeof}")
         types.each do |one_type|
           add_triple(element, new_subject, RDF_TYPE, one_type)
@@ -480,27 +542,45 @@ module RdfContext
     
       # Establish current object literal [Step 11]
       if property
-        properties = process_uris(element, property, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+        properties = process_uris(element, property, evaluation_context,
+                                  :uri_mappings => uri_mappings,
+                                  :term_mappings => term_mappings,
+                                  :vocab => default_vocabulary,
+                                  :r_1_0_restrictions => [:curie, :bnode])
+
+        properties.reject! do |p|
+          if p.is_a?(URIRef)
+            false
+          else
+            add_debug(element, "Illegal predicate: #{p.inspect}")
+            raise InvalidPredicate, "predicate #{p.inspect} must be a URI" if @strict
+            true
+          end
+        end
 
         # 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.
-        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)
+        type_resource = process_uri(element, type, evaluation_context,
+                                    :uri_mappings => uri_mappings,
+                                    :term_mappings => term_mappings,
+                                    :vocab => default_vocabulary,
+                                    :r_1_0_restrictions => [:curie, :bnode]) if type
+        current_object_literal = if type and !type.empty? and (type_resource.to_s != XML_LITERAL.to_s)
           # typed literal
           add_debug(element, "[Step 11] typed literal")
-          current_object_literal = Literal.typed(content || element.inner_text, type_resource, :language => language)
+          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, "[Step 11] plain literal")
-          current_object_literal = Literal.untyped(content || element.inner_text, language)
+          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, "[Step 11] XML Literal: #{element.inner_html}")
-          current_object_literal = Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => uri_mappings)
           recurse = false
+          Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => uri_mappings)
         end
       
         # add each property
@@ -568,18 +648,19 @@ module RdfContext
     end
 
     def process_uri(element, value, evaluation_context, options = {})
-      #return if value.to_s.empty?
-      #add_debug(element, "process_uri: #{value}")
+      return if value.nil?
+      restrictions = @version == :rdfa_1_0 ? options[:r_1_0_restrictions] : [:uri, :bnode, :curie, :safe_curie, :term]
+      add_debug(element, "process_uri: restrictions = #{restrictions.inspect}")
       options = {:uri_mappings => {}}.merge(options)
-      if !options[:term_mappings] && options[:uri_mappings] && value.to_s.match(/^\[(.*)\]$/)
+      if !options[:term_mappings] && options[:uri_mappings] && value.to_s.match(/^\[(.*)\]$/) && restrictions.include?(:safe_curie)
         # 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)
+        uri = curie_to_resource_or_bnode(element, $1, options[:uri_mappings], evaluation_context.parent_subject, restrictions)
         add_debug(element, "process_uri: #{value} => safeCURIE => <#{uri}>")
         uri
-      elsif options[:term_mappings] && NC_REGEXP.match(value.to_s)
+      elsif options[:term_mappings] && NC_REGEXP.match(value.to_s) && restrictions.include?(:term)
         # 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.
@@ -590,9 +671,11 @@ module RdfContext
         # 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)
+        uri = curie_to_resource_or_bnode(element, value, options[:uri_mappings], evaluation_context.parent_subject, restrictions)
         if uri
           add_debug(element, "process_uri: #{value} => CURIE => <#{uri}>")
+        elsif @version == :rdfa_1_0 && value.to_s.match(/^xml/)
+          # Special case to not allow anything starting with XML to be treated as a URI
         else
           uri = URIRef.new(value, evaluation_context.base, :normalize => false)
           add_debug(element, "process_uri: #{value} => URI => <#{uri}>")
@@ -615,7 +698,7 @@ module RdfContext
         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
+        URIRef.new(options[:vocab].to_s + value)
       else
         # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
         nil
@@ -623,15 +706,16 @@ module RdfContext
     end
 
     # From section 6. CURIE Syntax Definition
-    def curie_to_resource_or_bnode(element, curie, uri_mappings, subject)
+    def curie_to_resource_or_bnode(element, curie, uri_mappings, subject, restrictions)
       # URI mappings for CURIEs default to XH_MAPPING, rather than the default doc namespace
       prefix, reference = curie.to_s.split(":")
 
       # consider the bnode situation
-      if prefix == "_"
+      if prefix == "_" && restrictions.include?(:bnode)
         # we force a non-nil name, otherwise it generates a new name
         BNode.new(reference || "", @named_bnodes)
       elsif curie.to_s.match(/^:/)
+        add_debug(element, "curie_to_resource_or_bnode: default prefix: defined? #{!!uri_mappings[""]}, defaults: #{@host_defaults[:prefix]}")
         # Default prefix
         if uri_mappings[""]
           uri_mappings[""].send("#{reference}_")
@@ -642,12 +726,13 @@ module RdfContext
         # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
         nil
       else
-        # XXX Spec Confusion, are prefixes always downcased?
-        ns = uri_mappings[prefix.to_s.downcase]
+        # Prefixes always downcased
+        prefix = prefix.to_s.downcase unless @version == :rdfa_1_0
+        ns = uri_mappings[prefix.to_s]
         if ns
           ns + reference
         else
-          add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix.downcase}")
+          add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix}")
           nil
         end
       end