rdf-rdfa 0.3.1.2 → 0.3.3

data/example-files/payswarm.n3

@@ -0,0 +1,86 @@
+@base <http://recipes.payswarm.com/?p=10185> .
+@prefix bibo: <http://purl.org/ontology/bibo/> .
+@prefix cal: <http://www.w3.org/2002/12/cal/ical#> .
+@prefix cc: <http://creativecommons.org/ns#> .
+@prefix com: <http://purl.org/commerce#> .
+@prefix dbp: <http://dbpedia.org/property/> .
+@prefix dbp-owl: <http://dbpedia.org/ontology/> .
+@prefix dbr: <http://dbpedia.org/resource/> .
+@prefix dc: <http://purl.org/dc/terms/> .
+@prefix dcterms: <http://purl.org/dc/terms/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> .
+@prefix gr: <http://purl.org/goodrelations/v1#> .
+@prefix grddl: <http://www.w3.org/2003/g/data-view#> .
+@prefix og: <http://ogp.me/ns#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix ps: <http://purl.org/payswarm#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfa: <http://www.w3.org/ns/rdfa#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rif: <http://www.w3.org/2007/rif#> .
+@prefix rss: <http://purl.org/rss/1.0/> .
+@prefix sd: <http://www.w3.org/ns/sparql-service-description#> .
+@prefix sig: <http://purl.org/signature#> .
+@prefix sioc: <http://rdfs.org/sioc/ns#> .
+@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#> .
+@prefix v: <http://rdf.data-vocabulary.org/#> .
+@prefix vcard: <http://www.w3.org/2006/vcard/ns#> .
+@prefix void: <http://rdfs.org/ns/void#> .
+@prefix wdr: <http://www.w3.org/2007/05/powder#> .
+@prefix wdrs: <http://www.w3.org/2007/05/powder-s#> .
+@prefix xhv: <http://www.w3.org/1999/xhtml/vocab#> .
+@prefix xml: <http://www.w3.org/XML/1998/namespace> .
+@prefix xmlns: <http://www.w3.org/2000/xmlns/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+<#listing> com:payee <#listing-payee>;
+   com:payeeRule [ com:destinationOwnerType ps:Authority;
+     com:maximumRate "11.45"@en-US;
+     com:rateContext com:Inclusive,
+     com:Tax,
+     com:TaxExempt;
+     com:rateType com:Percentage;
+     a com:PayeeRule];
+   ps:asset <#asset>;
+   ps:assetHash "025b9b9f1eea31a9431f0c181a22df8a8257fc49"@en-US;
+   ps:license <http://purl.org/payswarm/licenses/blogging>;
+   ps:licenseHash "b94ba441c42432e82b6e3a076f4c614f83cac6ef"@en-US;
+   ps:validFrom "2011-04-18T00:00:00+0000"^^xsd:dateTime;
+   ps:validUntil "2011-04-19T00:00:00+0000"^^xsd:dateTime;
+   sig:signature [ dc:created "2011-04-18T00:00:00Z"^^xsd:dateTime;
+     dc:creator <https://payswarm.com/i/devuser/keys/4>;
+     sig:signatureValue "MqF1r37JSev+2uUKdr1ZOWVfNbTx8YdBZUMW4hlgeQyIiYxfbHF+eYhU+NLFrclTjj3i7qnwREIIBP0O0BFk72JIBl3JcCDKpfbA7pqiFuaGvxr9+Ba7o0pYojo0A6Mc/+0UD5rjdJc+qAH9hnMOzKpjyeMxUcR1Z6w0XXKXc8A="@en-US;
+     a sig:JsonldSignature];
+   a gr:Offering,
+   ps:Listing .
+<> xhv:alternate <https://recipes.payswarm.com/?feed=comments-rss2>,
+   <https://recipes.payswarm.com/?feed=rss2>,
+   <https://recipes.payswarm.com/?feed=rss2&p=10185>;
+   xhv:bookmark <https://recipes.payswarm.com/?p=10185>;
+   xhv:index <https://recipes.payswarm.com>;
+   xhv:next <https://recipes.payswarm.com/?p=10186>;
+   xhv:prev <https://recipes.payswarm.com/?p=10184>;
+   xhv:start <https://recipes.payswarm.com/?p=1>;
+   xhv:stylesheet <https://recipes.payswarm.com/wp-content/plugins/payswarm/payswarm.css?ver=3.1>,
+   <https://recipes.payswarm.com/wp-content/themes/twentyten/style.css> .
+<#asset> dc:creator [ foaf:name "chef"@en-US];
+   dc:title "Soft Breadsticks"@en-US;
+   ps:assetProvider <https://dev.payswarm.com:19100/i/devuser>;
+   ps:authority <https://payswarm.dev:19100/client-config>;
+   ps:contentUrl <>;
+   sig:signature [ dc:created "2011-04-18T00:00:00Z"^^xsd:dateTime;
+     dc:creator <https://payswarm.com/i/devuser/keys/4>;
+     sig:signatureValue "GYQHOxTJeyfky4NkxTm/IEcVGKYq7omDXPwdX+CYlJD9ur6RX35jM/RS3SeB7teGlJs1KtAx+l4ZUsAZa4sINYkr9fKh0k0K7TCbXp2X5sJ4ZCE3AvxZfc4IQEMuiiq+C8LHJv6g6tVmdl25UIbfroEBd/Hv+ID995VgapsSmQo="@en-US;
+     a sig:JsonldSignature];
+   a ps:Asset,
+   ps:WebPage .
+<#listing-payee> com:currency "USD"@en-US;
+   com:destination <https://dev.payswarm.com:19100/i/devuser/accounts/primary>;
+   com:payeePosition "0"^^xsd:integer;
+   com:rate "0.04597"@en-US;
+   com:rateType com:FlatAmount;
+   a com:Payee;
+   rdfs:comment "Payment for Soft Breadsticks by chef."@en-US .

data/lib/rdf/rdfa.rb

@@ -27,10 +27,15 @@ module RDF
     require 'rdf/rdfa/vocab'
     require 'rdf/rdfa/patches/literal_hacks'
     require 'rdf/rdfa/patches/nokogiri_hacks'
+    require 'rdf/rdfa/patches/string_hacks'
     autoload :Profile,  'rdf/rdfa/profile'
     autoload :Reader,  'rdf/rdfa/reader'
+    autoload :Writer,  'rdf/rdfa/writer'
     autoload :VERSION, 'rdf/rdfa/version'
     
+    XML_RDFA_PROFILE    = "http://www.w3.org/profile/rdfa-1.1"
+    XHTML_RDFA_PROFILE  = "http://www.w3.org/profile/html-rdfa-1.1"
+    
     def self.debug?; @debug; end
     def self.debug=(value); @debug = value; end
   end

data/lib/rdf/rdfa/format.rb

@@ -18,12 +18,10 @@ module RDF::RDFa
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
-    content_type     'text/html', :extension => :html
-    content_type     'application/xhtml+xml', :extension => :xhtml
-    content_type     'image/svg+xml', :extension => :svg
     content_encoding 'utf-8'
-
+    content_type     'text/html', :extension => :html
     reader { RDF::RDFa::Reader }
+    writer { RDF::RDFa::Writer }
     XMLNS = 'http://www.w3.org/1999/xhtml'  # FIXME: This or XHV or none at all?
   end
 
@@ -36,6 +34,8 @@ module RDF::RDFa
   #   RDF::Format.for(:html).reader  # RDF::RDFa::Reader
   #   RDF::Format.for(:html).writer  # RDF::RDFa::Writer
   class HTML < RDF::Format
+    content_encoding 'utf-8'
+    content_type     'text/html', :extension => :html
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
   end
@@ -49,6 +49,8 @@ module RDF::RDFa
   #   RDF::Format.for(:xhtml).reader  # RDF::RDFa::Reader
   #   RDF::Format.for(:xhtml).writer  # RDF::RDFa::Writer
   class XHTML < RDF::Format
+    content_encoding 'utf-8'
+    content_type     'application/xhtml+xml', :extension => :xhtml
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
   end
@@ -62,6 +64,8 @@ module RDF::RDFa
   #   RDF::Format.for(:svg).reader  # RDF::RDFa::Reader
   #   RDF::Format.for(:svg).writer  # RDF::RDFa::Writer
   class SVG < RDF::Format
+    content_encoding 'utf-8'
+    content_type     'image/svg+xml', :extension => :svg
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
   end

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

@@ -0,0 +1,34 @@
+module RDF
+  class Graph
+    # Resource properties
+    #
+    # Properties arranged as a hash with the predicate Term as index to an array of resources or literals
+    #
+    # Example:
+    #   graph.load(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+    #   graph.resources(URI.new("http://example.com/subject")) =>
+    #   {
+    #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+    #     "http://example.com/#label"                       => ["An example"]
+    #   }
+    def properties(subject, recalc = false)
+      @properties ||= {}
+      @properties.delete(subject.to_s) if recalc
+      @properties[subject.to_s] ||= begin
+        hash = Hash.new
+        self.query(:subject => subject) do |statement|
+          pred = statement.predicate.to_s
+
+          hash[pred] ||= []
+          hash[pred] << statement.object
+        end
+        hash
+      end
+    end
+
+    # Get type(s) of subject, returns a list of symbols
+    def type_of(subject)
+      query(:subject => subject, :predicate => RDF.type).map {|st| st.object}
+    end
+  end
+end

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

@@ -14,3 +14,9 @@ class Nokogiri::XML::Node
     end
   end
 end
+
+class Nokogiri::XML::Document
+  def doctype
+    self.children.first rescue false
+  end
+end

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

@@ -0,0 +1,9 @@
+class ::String
+  # Trim beginning of each line by the amount of indentation in the first line
+  def align_left
+    str = self.sub(/^\s*$/, '')  # Remove leading newline
+    str = str[1..-1] if str[0,1] == "\n"
+    ws = str.match(/^(\s*)\S/m) ? $1 : ''
+    str.gsub(/^#{ws}/m, '')
+  end
+end

data/lib/rdf/rdfa/profile.rb

@@ -30,45 +30,18 @@ module RDF::RDFa
     # 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)
+    # @yield [profile]
+    # @yieldparam [RDF::RDFa::Profile] profile
+    # @yieldreturn [void] ignored
+    # @return [RDF::RDFa::Profile]
+    def initialize(uri, options = {}, &block)
       @uri = RDF::URI.intern(uri)
-      @prefixes = {}
-      @terms = {}
-      @vocabulary = nil
+      @prefixes = options.fetch(:prefixes, {})
+      @terms = options.fetch(:terms, {})
+      @vocabulary = options[:vocabulary]
       
-      Profile.load(@uri)
-
-      resource_info = {}
-      repository.query(:context => uri).each do |statement|
-        res = resource_info[statement.subject] ||= {}
-        next 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
+      yield(self) if block_given?
+      self
     end
     
     ##
@@ -76,7 +49,9 @@ module RDF::RDFa
     # @private
     def self.cache
       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
-      @cache ||= RDF::Util::Cache.new(-1)
+      @cache ||= begin
+        RDF::Util::Cache.new(-1)
+      end
     end
 
     ##
@@ -107,9 +82,13 @@ module RDF::RDFa
       # Return something to make the caller happy if we're re-entered
       cache[uri] = Struct.new(:prefixes, :terms, :vocabulary).new({}, {}, nil)
       # Now do the actual load
-      cache[uri] = new(uri)
+      cache[uri] = new(uri) do |profile|
+        STDERR.puts("process_profile: retrieve profile <#{uri}>") if RDF::RDFa.debug?
+        Profile.load(uri)
+        profile.parse(repository.query(:context => uri))
+      end
     rescue Exception => e
-      raise ProfileError, "Error reading profile #{uri.inspect}: #{e.message}"
+      raise ProfileError, "Profile #{uri}: #{e.message}"
     end
 
     # Load profile into repository
@@ -166,10 +145,55 @@ module RDF::RDFa
       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
+    
+    ##
+    # Extract vocabulary, prefix mappings and terms from a enumerable object into an instance
+    #
+    # @param [RDF::Enumerable, Enumerator] queryable
+    # @return [void] ignored
+    def parse(enumerable)
+      STDERR.puts("process_profile: parse profile <#{uri}>") if RDF::RDFa.debug?
+      resource_info = {}
+      enumerable.each do |statement|
+        res = resource_info[statement.subject] ||= {}
+        next unless statement.object.is_a?(RDF::Literal)
+        STDERR.puts("process_profile: statement=#{statement.inspect}") if RDF::RDFa.debug?
+        %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"]
+        STDERR.puts("process_profile: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}") if RDF::RDFa.debug?
+
+        @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
   end
 
   ##
   # The base class for RDF profile errors.
   class ProfileError < IOError
   end # ProfileError
-end
+end
+
+# Load cooked profiles
+Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'profile', '*')).each {|f| load f}

data/lib/rdf/rdfa/profile/xhtml.rb

@@ -0,0 +1,36 @@
+# This file is automatically generated by script/intern_vocabulary
+# RDFa vocabulary for http://www.w3.org/profile/html-rdfa-1.1
+
+profile = RDF::RDFa::Profile.new(RDF::URI("http://www.w3.org/profile/html-rdfa-1.1"), {
+  :terms => {
+    :alternate      => "http://www.w3.org/1999/xhtml/vocab#alternate",
+    :appendix       => "http://www.w3.org/1999/xhtml/vocab#appendix",
+    :bookmark       => "http://www.w3.org/1999/xhtml/vocab#bookmark",
+    :chapter        => "http://www.w3.org/1999/xhtml/vocab#chapter",
+    :cite           => "http://www.w3.org/1999/xhtml/vocab#cite",
+    :contents       => "http://www.w3.org/1999/xhtml/vocab#contents",
+    :copyright      => "http://www.w3.org/1999/xhtml/vocab#copyright",
+    :first          => "http://www.w3.org/1999/xhtml/vocab#first",
+    :glossary       => "http://www.w3.org/1999/xhtml/vocab#glossary",
+    :help           => "http://www.w3.org/1999/xhtml/vocab#help",
+    :icon           => "http://www.w3.org/1999/xhtml/vocab#icon",
+    :index          => "http://www.w3.org/1999/xhtml/vocab#index",
+    :itsRules       => "http://www.w3.org/1999/xhtml/vocab#itsRules",
+    :last           => "http://www.w3.org/1999/xhtml/vocab#last",
+    :license        => "http://www.w3.org/1999/xhtml/vocab#license",
+    :meta           => "http://www.w3.org/1999/xhtml/vocab#meta",
+    :next           => "http://www.w3.org/1999/xhtml/vocab#next",
+    :p3pv1          => "http://www.w3.org/1999/xhtml/vocab#p3pv1",
+    :prev           => "http://www.w3.org/1999/xhtml/vocab#prev",
+    :role           => "http://www.w3.org/1999/xhtml/vocab#role",
+    :section        => "http://www.w3.org/1999/xhtml/vocab#section",
+    :start          => "http://www.w3.org/1999/xhtml/vocab#start",
+    :stylesheet     => "http://www.w3.org/1999/xhtml/vocab#stylesheet",
+    :subsection     => "http://www.w3.org/1999/xhtml/vocab#subsection",
+    :top            => "http://www.w3.org/1999/xhtml/vocab#top",
+    :transformation => "http://www.w3.org/2003/g/data-view#transformation",
+    :up             => "http://www.w3.org/1999/xhtml/vocab#up",
+  },
+})
+
+RDF::RDFa::Profile.cache[RDF::URI("http://www.w3.org/profile/html-rdfa-1.1")] = profile

data/lib/rdf/rdfa/profile/xml.rb

@@ -0,0 +1,45 @@
+# This file is automatically generated by script/intern_vocabulary
+# RDFa vocabulary for http://www.w3.org/profile/rdfa-1.1
+
+profile = RDF::RDFa::Profile.new(RDF::URI("http://www.w3.org/profile/rdfa-1.1"), {
+  :prefixes => {
+    :bibo      => "http://purl.org/ontology/bibo/",
+    :cal       => "http://www.w3.org/2002/12/cal/ical#",
+    :cc        => "http://creativecommons.org/ns#",
+    :dbp       => "http://dbpedia.org/property/",
+    :"dbp-owl" => "http://dbpedia.org/ontology/",
+    :dbr       => "http://dbpedia.org/resource/",
+    :dc        => "http://purl.org/dc/elements/1.1/",
+    :dcterms   => "http://purl.org/dc/terms/",
+    :doap      => "http://usefulinc.com/ns/doap#",
+    :foaf      => "http://xmlns.com/foaf/0.1/",
+    :geo       => "http://www.w3.org/2003/01/geo/wgs84_pos#",
+    :gr        => "http://purl.org/goodrelations/v1#",
+    :grddl     => "http://www.w3.org/2003/g/data-view#",
+    :og        => "http://ogp.me/ns#",
+    :owl       => "http://www.w3.org/2002/07/owl#",
+    :rdf       => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    :rdfa      => "http://www.w3.org/ns/rdfa#",
+    :rdfs      => "http://www.w3.org/2000/01/rdf-schema#",
+    :rif       => "http://www.w3.org/2007/rif#",
+    :rss       => "http://purl.org/rss/1.0/",
+    :sd        => "http://www.w3.org/ns/sparql-service-description#",
+    :sioc      => "http://rdfs.org/sioc/ns#",
+    :skos      => "http://www.w3.org/2004/02/skos/core#",
+    :skosxl    => "http://www.w3.org/2008/05/skos-xl#",
+    :v         => "http://rdf.data-vocabulary.org/#",
+    :vcard     => "http://www.w3.org/2006/vcard/ns#",
+    :void      => "http://rdfs.org/ns/void#",
+    :wdr       => "http://www.w3.org/2007/05/powder#",
+    :wdrs      => "http://www.w3.org/2007/05/powder-s#",
+    :xhv       => "http://www.w3.org/1999/xhtml/vocab#",
+    :xml       => "http://www.w3.org/XML/1998/namespace",
+    :xmlns     => "http://www.w3.org/2000/xmlns/",
+    :xsd       => "http://www.w3.org/2001/XMLSchema#",
+  },
+  :terms => {
+    :describedby => "http://www.w3.org/2007/05/powder-s#describedby",
+  },
+})
+
+RDF::RDFa::Profile.cache[RDF::URI("http://www.w3.org/profile/rdfa-1.1")] = profile

data/lib/rdf/rdfa/reader.rb

@@ -6,23 +6,24 @@ 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/WD-rdfa-core-20101026/ RDFa 1.1
+  # @see http://www.w3.org/TR/2010/WD-rdfa-core-20100422/ RDFa Core 1.1
+  # @see http://www.w3.org/TR/2010/WD-xhtml-rdfa-20100422/ XHTML+RDFa 1.1
   #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Reader < RDF::Reader
     format Format
     
     SafeCURIEorCURIEorURI = {
-      :rdfa_1_0 => [:term, :safe_curie, :uri, :bnode],
-      :rdfa_1_1 => [:safe_curie, :curie, :term, :uri, :bnode],
+      :"rdfa1.0" => [:term, :safe_curie, :uri, :bnode],
+      :"rdfa1.1" => [:safe_curie, :curie, :term, :uri, :bnode],
     }
     TERMorCURIEorAbsURI = {
-      :rdfa_1_0 => [:term, :curie],
-      :rdfa_1_1 => [:term, :curie, :absuri],
+      :"rdfa1.0" => [:term, :curie],
+      :"rdfa1.1" => [:term, :curie, :absuri],
     }
     TERMorCURIEorAbsURIprop = {
-      :rdfa_1_0 => [:curie],
-      :rdfa_1_1 => [:term, :curie, :absuri],
+      :"rdfa1.0" => [:curie],
+      :"rdfa1.1" => [:term, :curie, :absuri],
     }
 
     NC_REGEXP = Regexp.new(
@@ -39,11 +40,11 @@ module RDF::RDFa
       Regexp::EXTENDED)
   
     # Host language
-    # @return [:xhtml, :svg]
+    # @return [:xml1, :xhtml1, :xhtml5, :html4, :html5, :svg]
     attr_reader :host_language
     
     # Version
-    # @return [:rdfa_1_0, :rdfa_1_1]
+    # @return [:"rdfa1.0", :"rdfa1.1"]
     attr_reader :version
     
     # The Recursive Baggage
@@ -147,7 +148,7 @@ module RDF::RDFa
         v << "uri_mappings[#{uri_mappings.keys.length}]"
         v << "incomplete_triples[#{incomplete_triples.length}]"
         v << "term_mappings[#{term_mappings.keys.length}]"
-        v.join(",")
+        v.join(", ")
       end
     end
 
@@ -170,9 +171,9 @@ module RDF::RDFa
     #   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)
+    # @option options [:xml1, :xhtml1, :xhtml5, :html4, :html5, :svg] :host_language (:xhtml1)
     #   Host Language
-    # @option options [:rdfa_1_0, :rdfa_1_1] :version (:rdfa_1_1)
+    # @option options [:"rdfa1.0", :"rdfa1.1"] :version (:"rdfa1.1")
     #   Parser version information
     # @option options [Graph]    :processor_graph (nil)
     #   Graph to record information, warnings and errors.
@@ -190,24 +191,93 @@ module RDF::RDFa
         @debug = options[:debug]
         @base_uri = uri(options[:base_uri])
 
-        @version = options[:version] ? options[:version].to_sym : :rdfa_1_1
+        @host_language = options[:host_language]
         @processor_graph = options[:processor_graph]
 
         @doc = case input
-        when Nokogiri::HTML::Document then input
-        when Nokogiri::XML::Document then input
-        else   Nokogiri::XML.parse(input, @base_uri.to_s)
+        when Nokogiri::HTML::Document
+          @host_language ||= :xhtml1
+        when Nokogiri::XML::Document
+          input
+        else
+          # Intuit from content type
+          @host_language ||= case input.respond_to?(:content_type) && input.content_type
+          when "text/xml", "application/xml"
+            :xml1
+          when "text/html", "application/xhtml+xml"
+            :xhtml1
+          when "image/svg+xml"
+            :svg
+          end
+          
+          # Intuit from file extension
+          @host_language ||= case input.respond_to?(:path) && File.extname(input.path.to_s)
+          when ".html"  then :html5
+          when ".xhtml" then :xhtml1
+          when ".svg"   then :svg
+          end
+ 
+          Nokogiri::XML.parse(input, @base_uri.to_s)
         end
         
-        @host_language = options[:host_language] || case @doc.root.name.downcase.to_sym
-        when :html  then :xhtml
+        if (@doc.nil? || @doc.root.nil?)
+          add_error(nil, "Empty document", RDF::RDFA.DocumentError)
+          raise RDF::ReaderError, "Empty Document"
+        end
+        add_warning(nil, "Synax errors:\n#{@doc.errors}", RDF::RDFA.DocumentError) if !@doc.errors.empty? && validate?
+
+        @version = options[:version] ? options[:version].to_sym : nil
+        
+        # Check for version of the processor to use:
+        # * Check document type for "XHTML+RDFa 1.0"
+        # * Check @version attribute on the html element for the value "XHTML+RDFa 1.0"
+        @version ||= :"rdfa1.0" if @doc.doctype.to_s =~ /RDFa 1\.0/
+        @version ||= :"rdfa1.0" if @doc.root && @doc.root.attribute("version").to_s =~ /RDFa 1\.0/
+        @version ||= :"rdfa1.1" if @doc.root && @doc.root.attribute("version").to_s =~ /RDFa 1\.1/
+        @version ||= :"rdfa1.1"
+
+        # Intuit host_language from doctype
+        @host_language ||= case @doc.doctype.to_s
+        when /html 4/i      then :html4
+        when /xhtml\+rdfa/i then :xhtml1
+        when /html/         then :html5
+        end
+        
+        # Determine host language from element name
+        @host_language ||= case @doc.root.name.downcase.to_sym
+        when :html  then :xhtml1
         when :svg   then :svg
-        else             :xhtml
+        else             :xml
         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?
+        # Otherwise, treat it as XML
+        @host_language ||= :xml1
+
+        # Section 4.2 RDFa Host Language Conformance
+        #
+        # The Host Language may require the automatic inclusion of one or more default RDFa Profiles.
+        @host_defaults = {
+          :vocabulary   => nil,
+          :uri_mappings => {},
+          :profiles     => [],
+        }
+
+        if @version == :"rdfa1.0"
+          # Add default term mappings
+          @host_defaults[: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 }
+        end
+
+        case @host_language
+        when :xml1, :svg
+          @host_defaults[:profiles] = [XML_RDFA_PROFILE]
+        when :xhtml1, :xhtml5, :html4, :html5
+          @host_defaults[:profiles] = [XML_RDFA_PROFILE, XHTML_RDFA_PROFILE]
+        end
+
+        add_info(@doc, "version = #{@version},  host_language = #{@host_language}")
 
         block.call(self) if block_given?
       end
@@ -234,35 +304,11 @@ module RDF::RDFa
     def each_statement(&block)
       @callback = block
 
-      # Section 4.2 RDFa Host Language Conformance
-      #
-      # The Host Language may define a default RDFa Profile. If it does, the RDFa Profile triples that establish term or
-      # URI mappings associated with that profile must not change without changing the profile URI. RDFa Processors may
-      # embed, cache, or retrieve the RDFa Profile triples associated with that profile.
-      @host_defaults = case @host_language
-      when :xhtml
-        {
-          :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.to_sym] = RDF::XHV[term].to_s; hash },
-        }
-      else
-        {
-          :uri_mappings => {},
-        }
-      end
-      
       # Add prefix definitions from host defaults
       @host_defaults[:uri_mappings].each_pair do |prefix, value|
         prefix(prefix, value)
       end
 
-      add_info(@doc, "version = #{@version},  host_language = #{@host_language}")
-
       # parse
       parse_whole_document(@doc, @base_uri)
     end
@@ -319,19 +365,17 @@ module RDF::RDFa
     end
     
     def add_processor_message(node, message, process_class)
-      puts "#{node_path(node)}: #{message}" if ::RDF::RDFa::debug?
+      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(nc, RDF::PTR.expression, node.path) if node.respond_to?(:path)
         @processor_graph << RDF::Statement.new(n, RDF::RDFA.context, nc)
       end
     end
@@ -355,9 +399,12 @@ module RDF::RDFa
     def parse_whole_document(doc, base)
       # find if the document has a base element
       case @host_language
-      when :xhtml
+      when :xhtml1, :xhtml5, :html4, :html5
         base_el = doc.at_css("html>head>base")
         base = base_el.attribute("href").to_s.split("#").first if base_el
+      else
+        xml_base = doc.root.attribute_with_ns("base", RDF::XML.to_s)
+        base = xml_base if xml_base
       end
       
       if (base)
@@ -370,6 +417,18 @@ module RDF::RDFa
       # initialize the evaluation context with the appropriate base
       evaluation_context = EvaluationContext.new(base, @host_defaults)
       
+      if @version != :"rdfa1.0"
+        # Process default vocabularies
+        process_profile(doc.root, @host_defaults[:profiles]) do |which, value|
+          add_debug(doc.root, "parse_whole_document, #{which}: #{value.inspect}")
+          case which
+          when :uri_mappings        then evaluation_context.uri_mappings.merge!(value)
+          when :term_mappings       then evaluation_context.term_mappings.merge!(value)
+          when :default_vocabulary  then evaluation_context.default_vocabulary = value
+          end
+        end
+      end
+      
       traverse(doc.root, evaluation_context)
       add_debug("", "parse_whole_doc: traversal complete'")
     end
@@ -379,7 +438,6 @@ module RDF::RDFa
     # Yields each mapping
     def process_profile(element, profiles)
       profiles.
-        reverse.
         map {|uri| uri(uri).normalize}.
         each do |uri|
         # Don't try to open ourselves!
@@ -389,10 +447,18 @@ module RDF::RDFa
         end
 
         old_debug = RDF::RDFa.debug?
-        #RDF::RDFa.debug = false
-        add_info(element, "process_profile: load <#{uri}>")
-        next unless profile = Profile.find(uri)
-        RDF::RDFa.debug = old_debug
+        begin
+          add_info(element, "process_profile: load <#{uri}>")
+          RDF::RDFa.debug = false
+          profile = Profile.find(uri)
+        rescue Exception => e
+          RDF::RDFa.debug = old_debug
+          add_error(element, e.message, RDF::RDFA.ProfileReferenceError)
+          raise # In case we're not in strict mode, we need to be sure processing stops
+        ensure
+          RDF::RDFa.debug = old_debug
+        end
+
         # Add URI Mappings to prefixes
         profile.prefixes.each_pair do |prefix, value|
           prefix(prefix, value)
@@ -401,9 +467,6 @@ module RDF::RDFa
         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
@@ -418,7 +481,7 @@ module RDF::RDFa
         next if ns.prefix == "_"
 
         # Downcase prefix for RDFa 1.1
-        pfx_lc = (@version == :rdfa_1_0 || ns.prefix.nil?) ? ns.prefix : ns.prefix.to_s.downcase
+        pfx_lc = (@version == :"rdfa1.0" || ns.prefix.nil?) ? ns.prefix : ns.prefix.to_s.downcase
         if ns.prefix
           uri_mappings[pfx_lc.to_sym] = ns.href
           namespaces[pfx_lc] ||= ns.href
@@ -432,20 +495,25 @@ module RDF::RDFa
       # Set mappings from @prefix
       # prefix is a whitespace separated list of prefix-name URI pairs of the form
       #   NCName ':' ' '+ xs:anyURI
-      mappings = element.attributes["prefix"].to_s.split(/\s+/)
+      mappings = element.attribute("prefix").to_s.strip.split(/\s+/)
       while mappings.length > 0 do
         prefix, uri = mappings.shift.downcase, mappings.shift
         #puts "uri_mappings prefix #{prefix} <#{uri}>"
         next unless prefix.match(/:$/)
         prefix.chop!
         
+        unless prefix.match(NC_REGEXP)
+          add_error(element, "extract_mappings: Prefix #{prefix.inspect} does not match NCName production")
+          next
+        end
+
         # A Conforming RDFa Processor must ignore any definition of a mapping for the '_' prefix.
         next if prefix == "_"
 
         uri_mappings[prefix.to_s.empty? ? nil : prefix.to_s.to_sym] = uri
         prefix(prefix, uri)
         add_info(element, "extract_mappings: prefix #{prefix} => <#{uri}>")
-      end unless @version == :rdfa_1_0
+      end unless @version == :"rdfa1.0"
     end
 
     # The recursive helper function
@@ -480,7 +548,7 @@ module RDF::RDFa
       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 = xml_base.to_s if xml_base && ![:xhtml1, :xhtml5, :html4, :html5].include?(@host_language)
       base ||= evaluation_context.base
 
       # Pull out the attributes needed for the skip test.
@@ -512,14 +580,29 @@ module RDF::RDFa
       # 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
+      unless @version == :"rdfa1.0"
         begin
           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)
-            when :term_mappings       then term_mappings.merge!(value)
-            when :default_vocabulary  then default_vocabulary = value
+            when :uri_mappings
+              value.each do |k, v|
+                if k.to_s.match(NC_REGEXP)
+                  uri_mappings[k] = v
+                else
+                  add_error(element, "[Step 2] traverse: Prefix #{k.to_s.inspect} does not match NCName production")
+                end
+              end
+            when :term_mappings
+              value.each do |k, v|
+                if k.to_s.match(NC_REGEXP)
+                  term_mappings[k] = v
+                else
+                  add_error(element, "[Step 2] traverse: Term #{k.to_s.inspect} does not match NCName production")
+                end
+              end
+            when :default_vocabulary
+              default_vocabulary = value
             end
           end 
         rescue
@@ -538,12 +621,12 @@ module RDF::RDFa
       unless vocab.nil?
         default_vocabulary = if vocab.to_s.empty?
           # Set default_vocabulary to host language default
-          add_debug(element, "[Step 2] traverse, reset default_vocaulary to #{@host_defaults.fetch(:vocabulary, nil).inspect}")
+          add_debug(element, "[Step 3] traverse, reset default_vocaulary to #{@host_defaults.fetch(:vocabulary, nil).inspect}")
           @host_defaults.fetch(:vocabulary, nil)
         else
           uri(vocab)
         end
-        add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
+        add_debug(element, "[Step 3] traverse, default_vocaulary: #{default_vocabulary.inspect}")
       end
       
       # Local term mappings [7.5 Steps 4]
@@ -560,8 +643,8 @@ module RDF::RDFa
       language = case
       when element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s)
         element.at_xpath("@xml:lang", "xml" => RDF::XML["uri"].to_s).to_s
-      when element.at_xpath("lang")
-        element.at_xpath("lang").to_s
+      when element.at_xpath("@lang")
+        element.at_xpath("@lang").to_s
       else
         language
       end
@@ -605,15 +688,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)$/ && base
+        new_subject ||= if element == @doc.root && base
+          uri(base)
+        elsif [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
           # From XHTML+RDFa 1.1:
           # if no URI is provided, then first check to see if the element is the head or body element.
           # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
           uri(base)
-        elsif @host_language != :xhtml && base
-          # XXX Spec confusion, assume that this is true
-          uri(base)
-        elsif element.attributes['typeof']
+        elsif typeof
           RDF::Node.new
         else
           # if it's null, it's null and nothing changes
@@ -633,7 +715,9 @@ module RDF::RDFa
                                   :restrictions => [:uri])
       
         # If no URI is provided then the first match from the following rules will apply
-        new_subject ||= if @host_language == :xhtml && element.name =~ /^(head|body)$/
+        new_subject ||= if element == @doc.root && base
+          uri(base)
+        elsif [:xhtml1, :xhtml5, :html4, :html5].include?(@host_language) && element.name =~ /^(head|body)$/
           # From XHTML+RDFa 1.1:
           # if no URI is provided, then first check to see if the element is the head or body element.
           # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
@@ -674,7 +758,7 @@ module RDF::RDFa
       end
     
       # Generate triples with given object [Step 9]
-      if current_object_resource
+      if new_subject and current_object_resource
         rels.each do |r|
           add_triple(element, new_subject, r, current_object_resource)
         end
@@ -727,7 +811,7 @@ module RDF::RDFa
             # 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
+          elsif @version == :"rdfa1.1"
             if datatype.to_s == RDF.XMLLiteral.to_s
               # XML Literal
               add_debug(element, "[Step 11(1.1)] XML Literal: #{element.inner_html}")
@@ -774,9 +858,9 @@ module RDF::RDFa
           add_error(element, e.message)
         end
 
-      # add each property
+        # add each property
         properties.each do |p|
-          add_triple(element, new_subject, p, current_object_literal)
+          add_triple(element, new_subject, p, current_object_literal) if new_subject
         end
       end
     
@@ -867,7 +951,7 @@ module RDF::RDFa
         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/i)
+        elsif @version == :"rdfa1.0" && value.to_s.match(/^xml/i)
           # Special case to not allow anything starting with XML to be treated as a URI
         elsif restrictions.include?(:absuri) || restrictions.include?(:uri)
           begin
@@ -935,22 +1019,14 @@ module RDF::RDFa
         # As a special case, _: is also a valid reference for one specific bnode.
         bnode(reference)
       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[nil]
-          uri(uri_mappings[nil] + reference.to_s)
-        elsif @host_defaults[:prefix]
-          uri(uri_mappings[@host_defaults[:prefix]] + reference.to_s)
-        else
-          #add_warning(element, "Default namespace prefix is not defined", RDF::RDFA.UnresolvedCURIE)
-          nil
-        end
+        RDF::XHV[reference.to_s]
       elsif !curie.to_s.match(/:/)
         # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
         nil
       else
         # Prefixes always downcased
-        prefix = prefix.to_s.downcase unless @version == :rdfa_1_0
+        prefix = prefix.to_s.downcase unless @version == :"rdfa1.0"
         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