rdf-rdfa 0.2.2 → 0.3.0

data/.gitignore

@@ -1,2 +1,4 @@
 /.DS_Store
 /pkg
+/doc/
+/.yardoc/

data/.yardopts

@@ -1,4 +1,4 @@
---title "RDF::RDFa - XHTML+RDFa Support for RDF.rb"
+--title "RDFa parser for RDF.rb."
 --output-dir doc/yard
 --protected
 --no-private
@@ -6,6 +6,8 @@
 --markup rdoc
 --readme README.rdoc
 -
+READEME.rdoc
 AUTHORS
+History.rdoc
 CONTRIBUTORS
 VERSION

data/History.rdoc

@@ -0,0 +1,52 @@
+=== 0.3.0
+* RDF.rb 0.3.0 compatibility updates
+  * Remove literal_normalization and qname_hacks, add back uri_hacks (until 0.3.0)
+  * URI canonicalization and validation.
+  * Added :canonicalize, and :intern options.
+  * Change :strict option to :validate.
+  * Add check to ensure that predicates are not literals, it's not legal in any RDF variant.
+  * Collect prefixes when extracting mappings.
+* Added :profile_repository option to RDF::RDFa::Reader.initialize. This MUST be an RDF::Repository and will be used to save profiles that are encountered.
+  * Fixme, for now, retrieval should include HTTP headers and perform appropriate HTTP cache control and check for potential updates.
+* Update to 2010-10-26 LC version of RDFa Core 1.1
+  * Deep processing of XMLLiterals
+  * Case sensitive Terms
+  * Updated processor graph vocabulary
+  * Upgrade for changes to RDFa 1.1 test suite
+  * Allow use of xml:base for non-HTML languages
+  * XHTML has no default vocabulary.
+  * No longer pass vocabularies, prefixes or terms when creating XMLLiterals. Only namespaces derived via xmlns are passed to Literal#typed.
+* Literal::XML
+  * Add all in-scope namespaces, not just those that seem to be used.
+* RSpec 2 compatibility.
+
+=== 0.2.2
+* Ruby 1.9.2 compatibility
+* Added script/parse as command-line option for parsing files.
+* Add back support for RDFa 1.0 as well as RDFa 1.1. Parser checks @version to determine which
+* Update RDFa processing to WD-rdfa-core-20100803 semantics
+  * Added Processor Graph and required output
+  * Reverse order of processing profiles
+  * Don't process element if any profile fails
+  * XMLLiterals must be explicitly specified as @datatype
+  * TERMorCURIEorAbsURI requires an absolute URI, not document relative
+  * Extract a new default vocabulary from @profile.
+
+=== 0.2.1
+* Update for RDF 0.2.1
+
+=== 0.2.0
+* Updates for RDF 0.2.0
+  * Use URI#intern instead of URI#new
+  * Change use of Graph#predicates and Graph#objects to use as enumerables
+
+=== 0.0.3
+* Removed internal graph in Reader and implement each_triple & each_statement to perform parsing
+
+=== 0.0.2
+* Remove dependency on Namespace
+* Changed to RDF::RDFa, and moved files accordingly.
+* Added vocab definitions for RDA, XHV, XML, XSI and OWL
+
+=== 0.0.1
+* First port from RdfContext version 0.5.4

data/README.rdoc

@@ -25,7 +25,7 @@ Instantiate a parser and parse source, specifying type and base-URL
   end
 
 == Dependencies
-  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.0)
   * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
 
 == TODO
@@ -37,7 +37,7 @@ Instantiate a parser and parse source, specifying type and base-URL
 == Resources:
 * RDF.rb[http://rdf.rubyforge.org/]   
 * Distiller[http://kellogg-assoc/distiller]
-* RDoc[http://rdoc.info/projects/gkellogg/rdf-rdfa]
+* RDoc[http://rdoc.info/github/gkellogg/rdf-rdfa]
 * History[http://github.com/gkellogg/rdf-rdfa/blob/master/History.txt]
 * "RDFa 1.1 Core"[http://www.w3.org/TR/2010/WD-rdfa-core-20100422/]
 * "XHTML+RDFa 1.1 Core"[http://www.w3.org/TR/2010/WD-xhtml-rdfa-20100422/]

data/Rakefile

@@ -13,39 +13,32 @@ begin
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfa"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.2.1')
+    gemspec.add_dependency('rdf', '>= 0.3.0')
     gemspec.add_dependency('nokogiri', '>= 1.3.3')
-    gemspec.add_development_dependency('rspec')
+    gemspec.add_development_dependency('rspec', '>= 2.1.0')
     gemspec.add_development_dependency('rdf-spec', '>= 0.2.1')
     gemspec.add_development_dependency('rdf-rdfxml', '>= 0.2.1')
     gemspec.add_development_dependency('rdf-isomorphic')
     gemspec.add_development_dependency('yard')
-    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS CONTRIBUTORS)
+    gemspec.extra_rdoc_files     = %w(README.rdoc History.rdoc AUTHORS CONTRIBUTORS)
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/*_spec.rb']
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
 desc "Run specs through RCov"
-Spec::Rake::SpecTask.new("spec:rcov") do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/*_spec.rb'
+RSpec::Core::RakeTask.new("spec:rcov") do |spec|
   spec.rcov = true
-  spec.rcov_opts = ['-x', '/Library', '-x', '/System/Library', '-x', 'spec']
+  spec.rcov_opts =  %q[--exclude "spec"]
 end
 
 desc "Generate HTML report specs"
-Spec::Rake::SpecTask.new("doc:spec") do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/*_spec.rb']
-  spec.spec_opts = ["--format", "html:doc/spec.html"]
+RSpec::Core::RakeTask.new("doc:spec") do |spec|
+  spec.rspec_opts = ["--format", "html", "-o", "doc/spec.html"]
 end
 
 YARD::Rake::YardocTask.new do |t|
@@ -60,10 +53,12 @@ namespace :spec do
     require 'spec/rdfa_helper'
     require 'fileutils'
 
-    %w(xhtml xhtml11 html4 html5).each do |suite|
+    %w(xhtml html4 html5 svgtiny).each do |suite|
       yaml = manifest_file = File.join(File.dirname(__FILE__), "spec", "#{suite}-manifest.yml")
       FileUtils.rm_f(yaml)
+      #RDF::RDFa.debug = true
       RdfaHelper::TestCase.to_yaml(suite, yaml)
+      #RDF::RDFa.debug = false
     end
   end
 end

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/rdf/.gitignore

@@ -0,0 +1,2 @@
+/rdfxml
+/rdfxml.rb

data/lib/rdf/rdfa.rb

@@ -27,7 +27,7 @@ module RDF
     require 'rdf/rdfa/vocab'
     require 'rdf/rdfa/patches/literal_hacks'
     require 'rdf/rdfa/patches/nokogiri_hacks'
-    require 'rdf/rdfa/patches/uri_hacks'
+    autoload :Profile,  'rdf/rdfa/profile'
     autoload :Reader,  'rdf/rdfa/reader'
     autoload :VERSION, 'rdf/rdfa/version'
     

data/lib/rdf/rdfa/patches/literal_hacks.rb

@@ -20,7 +20,7 @@ module RDF; class Literal
     ##
     # @param  [Object] value
     # @option options [String] :lexical (nil)
-    # @option options [Hash] :namespaces ({}) Use :__default__ or "" to declare default namespace
+    # @option options [Hash] :namespaces ({}) Use "" to declare default namespace
     # @option options [Symbol] :language (nil)
     # @option options [:nokogiri, :libxml, or :rexml] :library
     def initialize(value, options = {})
@@ -68,17 +68,15 @@ module RDF; class Literal
     def parse_value(value, options)
       ns_hash = {}
       options[:namespaces].each_pair do |prefix, uri|
-        prefix = prefix == :__default__ ? "" : prefix.to_s
+        prefix = prefix.to_s
         attr = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
         ns_hash[attr] = uri.to_s
       end
-      ns_strs = []
-      ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
 
       case @library
-      when :nokogiri  then parse_value_nokogiri(value, ns_strs, options[:language])
-      when :libxml    then parse_value_libxml(value, ns_strs, options[:language])
-      when :rexml     then parse_value_rexml(value, ns_strs, options[:language])
+      when :nokogiri  then parse_value_nokogiri(value, ns_hash, options)
+      when :libxml    then parse_value_libxml(value, ns_hash, options)
+      when :rexml     then parse_value_rexml(value, ns_hash, options)
       else                 value.to_s
       end
     end
@@ -99,10 +97,12 @@ module RDF; class Literal
       # to the required element, and does not properly order either namespaces or attributes.
       #
       # An open-issue in Nokogiri is to add support for C14N from the underlying libxml2 libraries.
-      def parse_value_nokogiri(value, ns_strs, language)
+      def parse_value_nokogiri(value, ns_hash, options)
         elements = if value.is_a?(Nokogiri::XML::NodeSet)
           value
         else
+          ns_strs = []
+          ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
           # Add inherited namespaces to created root element so that they're inherited to sub-elements
           Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
         end
@@ -110,17 +110,15 @@ module RDF; class Literal
         elements.map do |c|
           if c.is_a?(Nokogiri::XML::Element)
             c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).root
-            # Gather namespaces from self and decendant nodes
-            c.traverse do |n|
-              ns = n.namespace
-              next unless ns
-              prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
-              c[prefix] = ns.href.to_s unless c.namespaces[prefix]
-            end
 
+            # Apply defined namespaces
+            ns_hash.each_pair do |prefix, href|
+              c[prefix] = href unless c.namespaces[prefix]
+            end
+            
             # Add language
-            if language && c["lang"].to_s.empty?
-              c["xml:lang"] = language.to_s
+            if options[:language] && c["lang"].to_s.empty?
+              c["xml:lang"] = options[:language].to_s
             end
           end
           c

data/lib/rdf/rdfa/profile.rb

@@ -0,0 +1,167 @@
+module RDF::RDFa
+  ##
+  # Profile representation existing of a hash of terms, prefixes, a default vocabulary and a URI.
+  #
+  # Profiles are used for storing RDFa profile representations. A representation is created
+  # by serializing a profile graph (typically also in RDFa, but may be in other representations).
+  #
+  # The class may be backed by an RDF::Repository, which will be used to retrieve a profile graph
+  # or to load into, if no such graph exists
+  class Profile
+    # Prefix mappings defined in this profile
+    # @return [Hash{Symbol => RDF::URI}]
+    attr_reader :prefixes
+
+    # Term mappings defined in this profile
+    # @return [Hash{Symbol => RDF::URI}]
+    attr_reader :terms
+    
+    # Default URI defined for this vocabulary
+    # @return [RDF::URI]
+    attr_reader :vocabulary
+
+    # URI defining this profile
+    # @return [RDF::URI]
+    attr_reader :uri
+    
+    ##
+    # Initialize a new profile from the given URI.
+    #
+    # Parses the profile and places it in the repository and cache
+    #
+    # @param [RDF::URI, #to_s] uri URI of profile to be represented
+    def initialize(uri)
+      @uri = RDF::URI.intern(uri)
+      @prefixes = {}
+      @terms = {}
+      @vocabulary = nil
+      
+      Profile.load(@uri)
+
+      resource_info = {}
+      repository.query(:context => uri).each do |statement|
+        res = resource_info[statement.subject] ||= {}
+        raise RDF::ProfileError, "#{statement.object.inspect} must be a Literal" unless statement.object.is_a?(RDF::Literal)
+        %w(uri term prefix vocabulary).each do |term|
+          res[term] ||= statement.object.value if statement.predicate == RDF::RDFA[term]
+        end
+      end
+
+      resource_info.values.each do |res|
+        # 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 = res["uri"]
+        term = res["term"]
+        prefix = res["prefix"]
+        vocab = res["vocabulary"]
+
+        @vocabulary = vocab if vocab
+        
+        # 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
+        prefix(prefix.downcase, uri) if uri && prefix && 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.
+        term(term, uri) if term && uri
+      end
+    end
+    
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
+      @cache ||= RDF::Util::Cache.new(-1)
+    end
+
+    ##
+    # Repository used for saving profiles
+    # @return [RDF::Repository]
+    # @raise [RDF::RDFa::ProfileError] if profile does not support contexts
+    def self.repository
+      @repository ||= RDF::Repository.new(:title => "RDFa Profiles")
+    end
+    
+    ##
+    # Set repository used for saving profiles
+    # @param [RDF::Repository] repo
+    # @return [RDF::Repository]
+    def self.repository=(repo)
+      raise ProfileError, "Profile Repository must support context" unless repo.supports?(:context)
+      @repository = repo
+    end
+    
+    # Return a profile faulting through the cache
+    # @return [RDF::RDFa::Profile]
+    def self.find(uri)
+      uri = RDF::URI.intern(uri)
+      
+      cache[uri] ||= new(uri)
+    end
+
+    # Load profile into repository
+    def self.load(uri)
+      uri = RDF::URI.intern(uri)
+      repository.load(uri.to_s, :base_uri => uri, :context => uri) unless repository.has_context?(uri)
+    end
+    
+    # @return [RDF::Repository]
+    def repository
+      Profile.repository
+    end
+    
+    ##
+    # Defines the given named URI prefix for this profile.
+    #
+    # @example Defining a URI prefix
+    #   profile.prefix :dc, RDF::URI('http://purl.org/dc/terms/')
+    #
+    # @example Returning a URI prefix
+    #   profile.prefix(:dc)    #=> RDF::URI('http://purl.org/dc/terms/')
+    #
+    # @overload prefix(name, uri)
+    #   @param  [Symbol, #to_s]   name
+    #   @param  [RDF::URI, #to_s] uri
+    #
+    # @overload prefix(name)
+    #   @param  [Symbol, #to_s]   name
+    #
+    # @return [RDF::URI]
+    def prefix(name, uri = nil)
+      name = name.to_s.empty? ? nil : (name.respond_to?(:to_sym) ? name.to_sym : name.to_s.to_sym)
+      uri.nil? ? prefixes[name] : prefixes[name] = uri
+    end
+
+    ##
+    # Defines the given named URI term for this profile.
+    #
+    # @example Defining a URI term
+    #   profile.term :title, RDF::URI('http://purl.org/dc/terms/title')
+    #
+    # @example Returning a URI profile
+    #   profile.term(:title)    #=> RDF::URI('http://purl.org/dc/terms/TITLE')
+    #
+    # @overload term(name, uri)
+    #   @param  [Symbol, #to_s]   name
+    #   @param  [RDF::URI, #to_s] uri
+    #
+    # @overload term(name)
+    #   @param  [Symbol, #to_s]   name
+    #
+    # @return [RDF::URI]
+    def term(name, uri = nil)
+      name = name.to_s.empty? ? nil : (name.respond_to?(:to_sym) ? name.to_sym : name.to_s.to_sym)
+      uri.nil? ? terms[name] : terms[name] = uri
+    end
+  end
+
+  ##
+  # The base class for RDF profile errors.
+  class ProfileError < IOError
+  end # ProfileError
+end

data/lib/rdf/rdfa/reader.rb

@@ -6,7 +6,7 @@ module RDF::RDFa
   #
   # Based on processing rules described here:
   # @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-20100803/ RDFa 1.1
+  # @see http://www.w3.org/2010/02/rdfa/drafts/2010/WD-rdfa-core-20101026/ RDFa 1.1
   #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
@@ -39,9 +39,13 @@ module RDF::RDFa
       Regexp::EXTENDED)
   
     # Host language
-    # @return [:xhtml]
+    # @return [:xhtml, :svg]
     attr_reader :host_language
     
+    # Version
+    # @return [:rdfa_1_0, :rdfa_1_1]
+    attr_reader :version
+    
     # The Recursive Baggage
     # @private
     class EvaluationContext # :nodoc:
@@ -76,6 +80,11 @@ module RDF::RDFa
       #
       # @return [Hash{Symbol => String}]
       attr :uri_mappings, true
+      # A list of current, in-scope Namespaces. This is the subset of uri_mappings
+      # which are defined using xmlns.
+      #
+      # @return [Hash{String => Namespace}]
+      attr :namespaces, true
       # A list of incomplete triples.
       #
       # A triple can be incomplete when no object resource
@@ -115,6 +124,7 @@ module RDF::RDFa
         @base = base
         @parent_subject = @base
         @parent_object = nil
+        @namespaces = {}
         @incomplete_triples = []
         @language = nil
         @uri_mappings = host_defaults.fetch(:uri_mappings, {})
@@ -129,6 +139,7 @@ module RDF::RDFa
         # clone the evaluation context correctly
         @uri_mappings = from.uri_mappings.clone
         @incomplete_triples = from.incomplete_triples.clone
+        @namespaces = from.namespaces.clone
       end
       
       def inspect
@@ -143,26 +154,44 @@ module RDF::RDFa
     ##
     # Initializes the RDFa reader instance.
     #
-    # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, #read, #to_s]       input
-    # @option options [Array] :debug (nil) Array to place debug messages
-    # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
-    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
-    # @option options [Boolean] :base_uri (nil) Base URI to use for relative URIs.
-    # @option options [:rdfa_1_0, :rdfa_1_1] :version (:rdfa_1_1) Parser version information
-    # @option options [:xhtml] :host_language (:xhtml) Host Language
+    # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, 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
+    # @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 [:xhtml] :host_language (:xhtml)
+    #   Host Language
+    # @option options [:rdfa_1_0, :rdfa_1_1] :version (:rdfa_1_1)
+    #   Parser version information
+    # @option options [Graph]    :processor_graph (nil)
+    #   Graph to record information, warnings and errors.
+    # @option options [Repository] :profile_repository (nil)
+    #   Repository to save profile graphs.
+    # @option options [Array] :debug
+    #   Array to place debug messages
     # @return [reader]
-    # @yield  [reader]
-    # @yieldparam [RDF::Reader] reader
-    # @raise [RDF::ReaderError]:: Raises RDF::ReaderError if _strict_
+    # @yield  [reader] `self`
+    # @yieldparam  [RDF::Reader] reader
+    # @yieldreturn [void] ignored
+    # @raise [Error]:: Raises RDF::ReaderError if _validate_
     def initialize(input = $stdin, options = {}, &block)
       super do
         @debug = options[:debug]
-        @strict = options[:strict]
-        @base_uri = RDF::URI.intern(options[:base_uri])
-        @@vocabulary_cache ||= {}
+        @base_uri = uri(options[:base_uri])
 
         @version = options[:version] ? options[:version].to_sym : :rdfa_1_1
-        @host_language = options[:host_language] || :xhtml
+        @processor_graph = options[:processor_graph]
 
         @doc = case input
         when Nokogiri::HTML::Document then input
@@ -170,13 +199,32 @@ module RDF::RDFa
         else   Nokogiri::XML.parse(input, @base_uri.to_s)
         end
         
-        add_error(nil, "Empty document", RDF::RDFA.HostLanguageMarkupError) if (@doc.nil? || @doc.root.nil?)
-        add_warning(nil, "Synax errors:\n#{@doc.errors}", RDF::RDFA.HostLanguageMarkupError) unless @doc.errors.empty?
+        @host_language = options[:host_language] || case @doc.root.name.downcase.to_sym
+        when :html  then :xhtml
+        when :svg   then :svg
+        else             :xhtml
+        end
+
+        add_error(nil, "Empty document", RDF::RDFA.DocumentError) if (@doc.nil? || @doc.root.nil?)
+        add_warning(nil, "Synax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
+        add_error("Empty document") if (@doc.nil? || @doc.root.nil?) && validate?
 
         block.call(self) if block_given?
       end
+      self.profile_repository = options[:profile_repository] if options[:profile_repository]
     end
 
+    # @return [RDF::Repository]
+    def profile_repository
+      Profile.repository
+    end
+    
+    # @param [RDF::Repository] repo
+    # @return [RDF::Repository]
+    def profile_repository=(repo)
+      Profile.repository = repo
+    end
+    
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -194,20 +242,25 @@ module RDF::RDFa
       @host_defaults = case @host_language
       when :xhtml
         {
-          :vocabulary => RDF::XHV.to_s,
+          :vocabulary => nil,
           :prefix     => "xhv",
           :uri_mappings => {"xhv" => RDF::XHV.to_s}, # 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
-            ).inject({}) { |hash, term| hash[term] = RDF::XHV[term]; hash },
+            ).inject({}) { |hash, term| hash[term.to_sym] = RDF::XHV[term].to_s; hash },
         }
       else
-        {}
+        {
+          :uri_mappings => {},
+        }
       end
       
-      @host_defaults.delete(:vocabulary) if @version == :rdfa_1_0
-      
+      # Add prefix definitions from host defaults
+      @host_defaults[:uri_mappings].each_pair do |prefix, value|
+        prefix(prefix, value)
+      end
+
       add_debug(@doc, "version = #{@version},  host_language = #{@host_language}")
 
       # parse
@@ -249,35 +302,39 @@ module RDF::RDFa
     # @param [XML Node, any] node:: XML Node or string for showing context
     # @param [String] message::
     def add_debug(node, message)
-      add_processor_message(node, message, RDF::RDFA.InformationalMessage)
+      add_processor_message(node, message, RDF::RDFA.Info)
     end
 
-    def add_info(node, message, process_class = RDF::RDFA.InformationalMessage)
-       add_processor_message(node, message, process_class)
-     end
-
-     def add_warning(node, message, process_class = RDF::RDFA.MiscellaneousWarning)
-       add_processor_message(node, message, process_class)
-     end
-
-     def add_error(node, message, process_class = RDF::RDFA.MiscellaneousError)
-       add_processor_message(node, message, process_class)
-       raise ParserException, message if @strict
-     end
-
-     def add_processor_message(node, message, process_class)
-       puts "#{node_path(node)}: #{message}" if ::RDF::RDFa::debug?
-       @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
-       if @processor_graph
-         @processor_sequence ||= 0
-         n = RDF::Node.new
-         @processor_graph << RDF::Statement.new(n, RDF["type"], process_class)
-         @processor_graph << RDF::Statement.new(n, RDF::DC.description, message)
-         @processor_graph << RDF::Statement.new(n, RDF::DC.date, RDF::Literal::Date.new(DateTime.now.to_date))
-         @processor_graph << RDF::Statement.new(n, RDF::RDFA.sequence, RDF::Literal::Integer.new(@processor_sequence += 1))
-         @processor_graph << RDF::Statement.new(n, RDF::RDFA.source, node_path(node))
-       end
-     end
+    def add_info(node, message, process_class = RDF::RDFA.Info)
+      add_processor_message(node, message, process_class)
+    end
+    
+    def add_warning(node, message, process_class = RDF::RDFA.Warning)
+      add_processor_message(node, message, process_class)
+    end
+    
+    def add_error(node, message, process_class = RDF::RDFA.Error)
+      add_processor_message(node, message, process_class)
+      raise RDF::ReaderError, message if validate?
+    end
+    
+    def add_processor_message(node, message, process_class)
+      puts "#{node_path(node)}: #{message}" if ::RDF::RDFa::debug?
+      @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
+      if @processor_graph
+        @processor_sequence ||= 0
+        n = RDF::Node.new
+        @processor_graph << RDF::Statement.new(n, RDF["type"], process_class)
+        @processor_graph << RDF::Statement.new(n, RDF::DC.description, message)
+        @processor_graph << RDF::Statement.new(n, RDF::DC.date, RDF::Literal::Date.new(DateTime.now))
+        @processor_graph << RDF::Statement.new(n, RDF::RDFA.sequence, RDF::Literal::Integer.new(@processor_sequence += 1))
+        @processor_graph << RDF::Statement.new(n, RDF::RDFA.context, @base_uri)
+        nc = RDF::Node.new
+        @processor_graph << RDF::Statement.new(nc, RDF["type"], RDF::PTR.XPathPointer)
+        @processor_graph << RDF::Statement.new(nc, RDF::PTR.expression, node.path)
+        @processor_graph << RDF::Statement.new(n, RDF::RDFA.context, nc)
+      end
+    end
 
     # add a statement, object can be literal or URI or bnode
     #
@@ -286,10 +343,10 @@ module RDF::RDFa
     # @param [URI] predicate:: the predicate of the statement
     # @param [URI, BNode, Literal] object:: the object of the statement
     # @return [Statement]:: Added statement
-    # @raise [ReaderError]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
+    # @raise [ReaderError]:: Checks parameter types and raises if they are incorrect if parsing mode is _validate_.
     def add_triple(node, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
-      add_debug(node, "statement: #{statement.to_ntriples}")
+      add_debug(node, "statement: #{RDF::NTriples.serialize(statement)}")
       @callback.call(statement)
     end
 
@@ -297,93 +354,55 @@ 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
-      # XXX - HTML specific
-      base_el = doc.css('html>head>base').first
-      if (base_el)
-        base = base_el.attributes['href']
+      case @host_language
+      when :xhtml
+        base_el = doc.at_css("html>head>base")
+        base = base_el.attribute("href").to_s.split("#").first if base_el
+      end
+      
+      if (base)
         # Strip any fragment from base
         base = base.to_s.split("#").first
-        @base_uri = RDF::URI.intern(base)
-        add_debug(base_el, "parse_whole_doc: base='#{base}'")
+        base = uri(base)
+        add_debug("", "parse_whole_doc: base='#{base}'")
       end
 
       # initialize the evaluation context with the appropriate base
-      evaluation_context = EvaluationContext.new(@base_uri, @host_defaults)
-
+      evaluation_context = EvaluationContext.new(base, @host_defaults)
+      
       traverse(doc.root, evaluation_context)
     end
   
     # Parse and process URI mappings, Term mappings and a default vocabulary from @profile
     #
     # Yields each mapping
-    def process_profile(element)
-      element.attributes['profile'].to_s.split(/\s/).reverse.each do |profile|
+    def process_profile(element, profiles)
+      profiles.
+        reverse.
+        map {|uri| uri(uri).normalize}.
+        each do |uri|
         # Don't try to open ourselves!
-        if @uri == profile
-          add_debug(element, "process_profile: skip recursive profile <#{profile}>")
-        elsif @@vocabulary_cache.has_key?(profile)
-          add_debug(element, "process_profile: skip previously parsed profile <#{profile}>")
-        else
-          begin
-            @@vocabulary_cache[profile] = {
-              :uri_mappings => {},
-              :term_mappings => {},
-              :default_vocabulary => nil
-            }
-            um = @@vocabulary_cache[profile][:uri_mappings]
-            tm = @@vocabulary_cache[profile][:term_mappings]
-            add_debug(element, "process_profile: parse profile <#{profile}>")
-      
-            # Parse profile, and extract mappings from graph
-            old_debug, old_verbose, = ::RDF::RDFa::debug?, $verbose
-            ::RDF::RDFa::debug, $verbose = false, false
-            # Fixme, RDF isn't smart enough to figure this out from MIME-Type
-            load_opts = {:base_uri => profile}
-            load_opts[:format] = :rdfa unless RDF::Format.for(:file_name => profile)
-            p_graph = RDF::Graph.load(profile, load_opts)
-            ::RDF::RDFa::debug, $verbose = old_debug, old_verbose
-            p_graph.subjects.each do |subject|
-              # 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 = p_graph.first_object([subject, RDF::RDFA['uri'], nil])
-              term = p_graph.first_object([subject, RDF::RDFA['term'], nil])
-              prefix = p_graph.first_object([subject, RDF::RDFA['prefix'], nil])
-              vocab = p_graph.first_object([subject, RDF::RDFA['vocabulary'], nil])
-              add_debug(element, "process_profile: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}")
-
-              raise RDF::ReaderError, "rdf:uri #{uri.inspect} must be a Literal" unless uri.nil? || uri.is_a?(RDF::Literal)
-              raise RDF::ReaderError, "rdf:term #{term.inspect} must be a Literal" unless term.nil? || term.is_a?(RDF::Literal)
-              raise RDF::ReaderError, "rdf:prefix #{prefix.inspect} must be a Literal" unless prefix.nil? || prefix.is_a?(RDF::Literal)
-              raise RDF::ReaderError, "rdf:vocabulary #{vocab.inspect} must be a Literal" unless vocab.nil? || vocab.is_a?(RDF::Literal)
-
-              @@vocabulary_cache[profile][:default_vocabulary] = vocab.value if vocab
-              
-              # 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.value.downcase] = uri.value if prefix && prefix.value != "_"
-            
-              # 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.value.downcase] = RDF::URI.intern(uri.value) if term
-            end
-          rescue RDF::ReaderError => e
-            add_error(element, e.message, RDF::RDFA.ProfileReferenceError)
-            raise # Incase we're not in strict mode, we need to be sure processing stops
-          end
+        if @base_uri == uri
+          add_debug(element, "process_profile: skip recursive profile <#{uri}>")
+          next
+        end
+
+        next unless profile = Profile.find(uri)
+        # Add URI Mappings to prefixes
+        profile.prefixes.each_pair do |prefix, value|
+          prefix(prefix, value)
         end
-        profile_mappings = @@vocabulary_cache[profile]
-        yield :uri_mappings, profile_mappings[:uri_mappings] unless profile_mappings[:uri_mappings].empty?
-        yield :term_mappings, profile_mappings[:term_mappings] unless profile_mappings[:term_mappings].empty?
-        yield :default_vocabulary, profile_mappings[:default_vocabulary] if profile_mappings[:default_vocabulary]
+        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
+    rescue Exception => e
+      add_error(element, e.message, RDF::RDFA.ProfileReferenceError)
+      raise # In case we're not in strict mode, we need to be sure processing stops
     end
 
     # Extract the XMLNS mappings from an element
-    def extract_mappings(element, uri_mappings, term_mappings)
+    def extract_mappings(element, uri_mappings, namespaces)
       # look for xmlns
       # (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,
@@ -396,8 +415,12 @@ module RDF::RDFa
         # Downcase prefix for RDFa 1.1
         pfx_lc = (@version == :rdfa_1_0 || ns.prefix.nil?) ? ns.prefix : ns.prefix.to_s.downcase
         if ns.prefix
-          uri_mappings[pfx_lc] = ns.href
+          uri_mappings[pfx_lc.to_sym] = ns.href
+          namespaces[pfx_lc] ||= ns.href
+          prefix(pfx_lc, ns.href)
           add_debug(element, "extract_mappings: xmlns:#{ns.prefix} => <#{ns.href}>")
+        else
+          namespaces[""] ||= ns.href
         end
       end
 
@@ -414,7 +437,8 @@ module RDF::RDFa
         # A Conforming RDFa Processor must ignore any definition of a mapping for the '_' prefix.
         next if prefix == "_"
 
-        uri_mappings[prefix] = uri
+        uri_mappings[prefix.to_s.empty? ? nil : prefix.to_s.to_sym] = uri
+        prefix(prefix, uri)
         add_debug(element, "extract_mappings: prefix #{prefix} => <#{uri}>")
       end unless @version == :rdfa_1_0
     end
@@ -423,7 +447,7 @@ module RDF::RDFa
     def traverse(element, evaluation_context)
       if element.nil?
         add_debug(element, "traverse nil element")
-        raise RDF::ReaderError, "Can't parse nil element" if @strict
+        raise RDF::ReaderError, "Can't parse nil element" if validate?
         return nil
       end
       
@@ -435,6 +459,7 @@ module RDF::RDFa
       new_subject = nil
       current_object_resource = nil
       uri_mappings = evaluation_context.uri_mappings.clone
+      namespaces = evaluation_context.namespaces.clone
       incomplete_triples = []
       language = evaluation_context.language
       term_mappings = evaluation_context.term_mappings.clone
@@ -450,6 +475,9 @@ module RDF::RDFa
       resource = attrs['resource']
       href = attrs['href']
       vocab = attrs['vocab']
+      xml_base = element.attribute_with_ns("base", RDF::XML.to_s)
+      base = xml_base.to_s if xml_base && @host_language != :xhtml
+      base ||= evaluation_context.base
 
       # Pull out the attributes needed for the skip test.
       property = attrs['property'].to_s.strip if attrs['property']
@@ -458,13 +486,31 @@ module RDF::RDFa
       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']
+      profiles = attrs['profile'].to_s.split(/\s/)  # In-scope profiles in order for passing to XMLLiteral
+
+      attrs = {
+        :about => about,
+        :src => src,
+        :resource => resource,
+        :href => href,
+        :vocab => vocab,
+        :base => xml_base,
+        :property => property,
+        :typeof => typeof,
+        :daetatype => datatype,
+        :rel => rel,
+        :rev => rev,
+        :profiles => (profiles.empty? ? nil : profiles),
+      }.select{|k,v| v}
+      
+      add_debug(element, "traverse " + attrs.map{|a| "#{a.first}: #{a.last}"}.join(", ")) unless attrs.empty?
 
       # Local term mappings [7.5 Steps 2]
       # 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.
       unless @version == :rdfa_1_0
         begin
-          process_profile(element) do |which, value|
+          process_profile(element, profiles) do |which, value|
             add_debug(element, "[Step 2] traverse, #{which}: #{value.inspect}")
             case which
             when :uri_mappings        then uri_mappings.merge!(value)
@@ -476,7 +522,7 @@ module RDF::RDFa
           # Skip this element and all sub-elements
           # If any referenced RDFa Profile is not available, then the current element and its children must not place any
           # triples in the default graph .
-          raise if @strict
+          raise if validate?
           return
         end
       end
@@ -491,7 +537,7 @@ module RDF::RDFa
           add_debug(element, "[Step 2] traverse, reset default_vocaulary to #{@host_defaults.fetch(:vocabulary, nil).inspect}")
           @host_defaults.fetch(:vocabulary, nil)
         else
-          RDF::URI.intern(vocab)
+          uri(vocab)
         end
         add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
       end
@@ -499,7 +545,7 @@ module RDF::RDFa
       # Local term mappings [7.5 Steps 4]
       # Next, the current element is then examined for URI mapping s and these are added to the local list of URI mappings.
       # Note that a URI mapping will simply overwrite any current mapping in the list that has the same name
-      extract_mappings(element, uri_mappings, term_mappings)
+      extract_mappings(element, uri_mappings, namespaces)
     
       # Language information [7.5 Step 5]
       # From HTML5 [3.2.3.3]
@@ -516,39 +562,37 @@ module RDF::RDFa
         language
       end
       language = nil if language.to_s.empty?
-      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language || 'nil'}") if attrs['lang']
+      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language || 'nil'}") if language
     
       # rels and revs
-      rels = process_uris(element, rel, evaluation_context,
+      rels = process_uris(element, rel, evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
                           :restrictions => TERMorCURIEorAbsURI[@version])
-      revs = process_uris(element, rev, evaluation_context,
+      revs = process_uris(element, rev, evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
                           :restrictions => TERMorCURIEorAbsURI[@version])
     
-      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(" ")}")
+      add_debug(element, "traverse, rels: #{rels.join(" ")}, revs: #{revs.join(" ")}") unless (rels + revs).empty?
 
       if !(rel || rev)
         # Establishing a new subject if no rel/rev [7.5 Step 6]
         # May not be valid, but can exist
         new_subject = if about
-          process_uri(element, about, evaluation_context,
+          process_uri(element, about, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif src
-          process_uri(element, src, evaluation_context, :restrictions => [:uri])
+          process_uri(element, src, evaluation_context, base, :restrictions => [:uri])
         elsif resource
-          process_uri(element, resource, evaluation_context,
+          process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif href
-          process_uri(element, href, evaluation_context, :restrictions => [:uri])
+          process_uri(element, href, evaluation_context, base, :restrictions => [:uri])
         end
 
         # If no URI is provided by a resource attribute, then the first match from the following rules
@@ -557,11 +601,14 @@ module RDF::RDFa
         # 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 @host_language == :xhtml && element.name =~ /^(head|body)$/ && evaluation_context.base
+        new_subject ||= if @host_language == :xhtml && element.name =~ /^(head|body)$/ && 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.
-          evaluation_context.base
+          uri(base)
+        elsif @host_language != :xhtml && base
+          # XXX Spec confusion, assume that this is true
+          uri(base)
         elsif element.attributes['typeof']
           RDF::Node.new
         else
@@ -574,10 +621,10 @@ module RDF::RDFa
         # [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:
-        new_subject = process_uri(element, about, evaluation_context,
+        new_subject = process_uri(element, about, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => SafeCURIEorCURIEorURI[@version]) ||
-                      process_uri(element, src, evaluation_context,
+                      process_uri(element, src, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => [:uri])
       
@@ -586,7 +633,7 @@ module RDF::RDFa
           # 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.
-          evaluation_context.base
+          uri(base)
         elsif element.attributes['typeof']
           RDF::Node.new
         else
@@ -597,11 +644,11 @@ module RDF::RDFa
       
         # 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,
+          process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif href
-          process_uri(element, href, evaluation_context,
+          process_uri(element, href, evaluation_context, base,
                       :restrictions => [:uri])
         end
 
@@ -611,7 +658,7 @@ module RDF::RDFa
       # Process @typeof if there is a subject [Step 8]
       if new_subject and typeof
         # Typeof is TERMorCURIEorAbsURIs
-        types = process_uris(element, typeof, evaluation_context,
+        types = process_uris(element, typeof, evaluation_context, base,
                             :uri_mappings => uri_mappings,
                             :term_mappings => term_mappings,
                             :vocab => default_vocabulary,
@@ -647,7 +694,7 @@ module RDF::RDFa
     
       # Establish current object literal [Step 11]
       if property
-        properties = process_uris(element, property, evaluation_context,
+        properties = process_uris(element, property, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :term_mappings => term_mappings,
                                   :vocab => default_vocabulary,
@@ -658,7 +705,7 @@ module RDF::RDFa
             false
           else
             add_debug(element, "Illegal predicate: #{p.inspect}")
-            raise RDF::ReaderError, "predicate #{p.inspect} must be a URI" if @strict
+            raise RDF::ReaderError, "predicate #{p.inspect} must be a URI" if validate?
             true
           end
         end
@@ -667,45 +714,67 @@ module RDF::RDFa
         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,
+        datatype = process_uri(element, datatype, evaluation_context, base,
                               :uri_mappings => uri_mappings,
                               :term_mappings => term_mappings,
                               :vocab => default_vocabulary,
                               :restrictions => TERMorCURIEorAbsURI[@version]) unless datatype.to_s.empty?
-        current_object_literal = if !datatype.to_s.empty? && datatype.to_s != RDF.XMLLiteral.to_s
-          # typed literal
-          add_debug(element, "[Step 11] typed literal (#{datatype})")
-          RDF::Literal.new(content || element.inner_text.to_s, :datatype => datatype, :language => language)
-        elsif @version == :rdfa_1_1
-          if datatype.to_s == RDF.XMLLiteral.to_s
-            # XML Literal
-            add_debug(element, "[Step 11(1.1)] XML Literal: #{element.inner_html}")
-            recurse = false
-            RDF::Literal.new(element.inner_html, :datatype => RDF.XMLLiteral, :language => language, :namespaces => uri_mappings.merge("" => "http://www.w3.org/1999/xhtml"))
+        begin
+          current_object_literal = if !datatype.to_s.empty? && datatype.to_s != RDF.XMLLiteral.to_s
+            # 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?)
+          elsif @version == :rdfa_1_1
+            if datatype.to_s == RDF.XMLLiteral.to_s
+              # XML Literal
+              add_debug(element, "[Step 11(1.1)] XML Literal: #{element.inner_html}")
+
+              # In order to maintain maximum portability of this literal, any children of the current node that are
+              # elements must have the current in scope XML namespace declarations (if any) declared on the
+              # serialized element using their respective attributes. Since the child element node could also
+              # declare new XML namespaces, the RDFa Processor must be careful to merge these together when
+              # 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?)
+              rescue ArgumentError => e
+                add_error(element, e.message)
+              end
+            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?)
+            end
           else
-            # plain literal
-            add_debug(element, "[Step 11(1.1)] plain literal")
-            RDF::Literal.new(content || element.inner_text.to_s, :language => language)
-          end
-        else
-          if content || (children_node_types == [Nokogiri::XML::Text]) || (element.children.length == 0) || datatype == ""
-            # plain literal
-            add_debug(element, "[Step 11 (1.0)] plain literal")
-            RDF::Literal.new(content || element.inner_text.to_s, :language => language)
-          elsif children_node_types != [Nokogiri::XML::Text] 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 => uri_mappings.merge("" => "http://www.w3.org/1999/xhtml"))
+            if content || (children_node_types == [Nokogiri::XML::Text]) || (element.children.length == 0) || 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)
+              # 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?)
+            end
           end
+        rescue ArgumentError => e
+          add_error(element, e.message)
         end
 
       # add each property
         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
     
       if not skip and new_subject && !evaluation_context.incomplete_triples.empty?
@@ -727,22 +796,26 @@ module RDF::RDFa
               uri_mappings == evaluation_context.uri_mappings &&
               term_mappings == evaluation_context.term_mappings &&
               default_vocabulary == evaluation_context.default_vocabulary &&
+              base == evaluation_context.base
             new_ec = evaluation_context
             add_debug(element, "[Step 13] skip: reused ec")
           else
             new_ec = evaluation_context.clone
+            new_ec.base = base
             new_ec.language = language
             new_ec.uri_mappings = uri_mappings
+            new_ec.namespaces = namespaces
             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, @host_defaults)
+          new_ec = EvaluationContext.new(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.namespaces = namespaces
           new_ec.incomplete_triples = incomplete_triples
           new_ec.language = language
           new_ec.term_mappings = term_mappings
@@ -758,13 +831,13 @@ module RDF::RDFa
     end
 
     # space-separated TERMorCURIEorAbsURI or SafeCURIEorCURIEorURI
-    def process_uris(element, value, evaluation_context, options)
+    def process_uris(element, value, evaluation_context, base, 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
+      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, base, options)}.compact
     end
 
-    def process_uri(element, value, evaluation_context, options = {})
+    def process_uri(element, value, evaluation_context, base, options = {})
       return if value.nil?
       restrictions = options[:restrictions]
       add_debug(element, "process_uri: #{value}, restrictions = #{restrictions.inspect}")
@@ -797,20 +870,20 @@ module RDF::RDFa
           begin
             # AbsURI does not use xml:base
             if restrictions.include?(:absuri)
-              uri = RDF::URI.intern(value)
+              uri = uri(value)
               unless uri.absolute?
                 uri = nil
                 raise RDF::ReaderError, "Relative URI #{value}" 
               end
             else
-              uri = evaluation_context.base.join(Addressable::URI.parse(value))
+              uri = uri(base, Addressable::URI.parse(value))
             end
           rescue Addressable::URI::InvalidURIError => e
-            add_warning(element, "Malformed prefix #{value}", RDF::RDFA.UndefinedPrefixError)
+            add_warning(element, "Malformed prefix #{value}", RDF::RDFA.UnresolvedCURIE)
           rescue RDF::ReaderError => e
             add_debug(element, e.message)
             if value.to_s =~ /^\(^\w\):/
-              add_warning(element, "Undefined prefix #{$1}", RDF::RDFA.UndefinedPrefixError)
+              add_warning(element, "Undefined prefix #{$1}", RDF::RDFA.UnresolvedCURIE)
             else
               add_warning(element, "Relative URI #{value}")
             end
@@ -828,17 +901,22 @@ module RDF::RDFa
     # <em>options[:term_mappings]</em>:: Term mappings
     # <em>options[:vocab]</em>:: Default vocabulary
     def process_term(element, 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]
+      if options[:term_mappings].is_a?(Hash)
+        # If the term is in the local term mappings, use the associated URI (case sensitive).
+        return uri(options[:term_mappings][value.to_s.to_sym]) if options[:term_mappings].has_key?(value.to_s.to_sym)
+        
+        # Otherwise, check for case-insensitive match
+        options[:term_mappings].each_pair do |term, uri|
+          return uri(uri) if term.to_s.downcase == value.to_s.downcase
+        end
+      end
+      
+      if options[:vocab]
         # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
-        RDF::URI.intern(options[:vocab] + value)
+        uri(options[:vocab] + value)
       else
         # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
-        add_warning(element, "Term #{value} is not defined", RDF::RDFA.UndefinedTermError)
+        add_warning(element, "Term #{value} is not defined", RDF::RDFA.UnresolvedTerm)
         nil
       end
     end
@@ -856,12 +934,12 @@ module RDF::RDFa
       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[""]
-          RDF::URI.intern(uri_mappings[""] + reference.to_s)
+        if uri_mappings[nil]
+          uri(uri_mappings[nil] + reference.to_s)
         elsif @host_defaults[:prefix]
-          RDF::URI.intern(uri_mappings[@host_defaults[:prefix]] + reference.to_s)
+          uri(uri_mappings[@host_defaults[:prefix]] + reference.to_s)
         else
-          #add_warning(element, "Default namespace prefix is not defined", RDF::RDFA.UndefinedPrefixError)
+          #add_warning(element, "Default namespace prefix is not defined", RDF::RDFA.UnresolvedCURIE)
           nil
         end
       elsif !curie.to_s.match(/:/)
@@ -870,14 +948,24 @@ module RDF::RDFa
       else
         # Prefixes always downcased
         prefix = prefix.to_s.downcase unless @version == :rdfa_1_0
-        ns = uri_mappings[prefix.to_s]
+        add_debug(element, "curie_to_resource_or_bnode check for #{prefix.to_s.to_sym.inspect} in #{uri_mappings.inspect}")
+        ns = uri_mappings[prefix.to_s.to_sym]
         if ns
-          RDF::URI.intern(ns + reference.to_s)
+          uri(ns + reference.to_s)
         else
-          #add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix}")
+          add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix}")
           nil
         end
       end
     end
+
+    def uri(value, append = nil)
+      value = RDF::URI.new(value)
+      value = value.join(append) if append
+      value.validate! if validate?
+      value.canonicalize! if canonicalize?
+      value = RDF::URI.intern(value) if intern?
+      value
+    end
   end
 end