RubyGems - rdf-rdfa - Versions diffs - 0.0.1 - Mend

rdf-rdfa 0.0.1

Files changed (128) hide show

data/History.txt +2 -0
data/README.rdoc +59 -0
data/Rakefile +46 -0
data/VERSION +1 -0
data/example.rb +27 -0
data/lib/rdfa/format.rb +19 -0
data/lib/rdfa/reader.rb +798 -0
data/lib/rdfa/reader/exceptions.rb +14 -0
data/lib/rdfa/reader/namespace.rb +72 -0
data/lib/rdfa/reader/version.rb +23 -0
data/spec/namespaces_spec.rb +112 -0
data/spec/rdfa-triples/0001.nt +1 -0
data/spec/rdfa-triples/0006.nt +2 -0
data/spec/rdfa-triples/0007.nt +3 -0
data/spec/rdfa-triples/0008.nt +1 -0
data/spec/rdfa-triples/0009.nt +1 -0
data/spec/rdfa-triples/0010.nt +2 -0
data/spec/rdfa-triples/0011.nt +3 -0
data/spec/rdfa-triples/0012.nt +1 -0
data/spec/rdfa-triples/0013.nt +1 -0
data/spec/rdfa-triples/0014.nt +1 -0
data/spec/rdfa-triples/0015.nt +2 -0
data/spec/rdfa-triples/0017.nt +3 -0
data/spec/rdfa-triples/0018.nt +1 -0
data/spec/rdfa-triples/0019.nt +1 -0
data/spec/rdfa-triples/0020.nt +1 -0
data/spec/rdfa-triples/0021.nt +1 -0
data/spec/rdfa-triples/0023.nt +1 -0
data/spec/rdfa-triples/0025.nt +2 -0
data/spec/rdfa-triples/0026.nt +1 -0
data/spec/rdfa-triples/0027.nt +1 -0
data/spec/rdfa-triples/0029.nt +1 -0
data/spec/rdfa-triples/0030.nt +1 -0
data/spec/rdfa-triples/0031.nt +1 -0
data/spec/rdfa-triples/0032.nt +1 -0
data/spec/rdfa-triples/0033.nt +2 -0
data/spec/rdfa-triples/0034.nt +1 -0
data/spec/rdfa-triples/0035.nt +1 -0
data/spec/rdfa-triples/0036.nt +1 -0
data/spec/rdfa-triples/0037.nt +1 -0
data/spec/rdfa-triples/0038.nt +1 -0
data/spec/rdfa-triples/0039.nt +1 -0
data/spec/rdfa-triples/0040.nt +1 -0
data/spec/rdfa-triples/0041.nt +1 -0
data/spec/rdfa-triples/0042.nt +0 -0
data/spec/rdfa-triples/0046.nt +3 -0
data/spec/rdfa-triples/0047.nt +3 -0
data/spec/rdfa-triples/0048.nt +3 -0
data/spec/rdfa-triples/0049.nt +2 -0
data/spec/rdfa-triples/0050.nt +2 -0
data/spec/rdfa-triples/0051.nt +2 -0
data/spec/rdfa-triples/0052.nt +1 -0
data/spec/rdfa-triples/0053.nt +2 -0
data/spec/rdfa-triples/0054.nt +2 -0
data/spec/rdfa-triples/0055.nt +2 -0
data/spec/rdfa-triples/0056.nt +3 -0
data/spec/rdfa-triples/0057.nt +4 -0
data/spec/rdfa-triples/0058.nt +6 -0
data/spec/rdfa-triples/0059.nt +6 -0
data/spec/rdfa-triples/0060.nt +2 -0
data/spec/rdfa-triples/0061.nt +1 -0
data/spec/rdfa-triples/0062.nt +1 -0
data/spec/rdfa-triples/0063.nt +1 -0
data/spec/rdfa-triples/0064.nt +1 -0
data/spec/rdfa-triples/0065.nt +3 -0
data/spec/rdfa-triples/0066.nt +1 -0
data/spec/rdfa-triples/0067.nt +1 -0
data/spec/rdfa-triples/0068.nt +1 -0
data/spec/rdfa-triples/0069.nt +1 -0
data/spec/rdfa-triples/0070.nt +1 -0
data/spec/rdfa-triples/0071.nt +1 -0
data/spec/rdfa-triples/0072.nt +1 -0
data/spec/rdfa-triples/0073.nt +1 -0
data/spec/rdfa-triples/0074.nt +1 -0
data/spec/rdfa-triples/0075.nt +1 -0
data/spec/rdfa-triples/0076.nt +23 -0
data/spec/rdfa-triples/0077.nt +23 -0
data/spec/rdfa-triples/0078.nt +6 -0
data/spec/rdfa-triples/0079.nt +3 -0
data/spec/rdfa-triples/0080.nt +1 -0
data/spec/rdfa-triples/0081.nt +6 -0
data/spec/rdfa-triples/0082.nt +8 -0
data/spec/rdfa-triples/0083.nt +6 -0
data/spec/rdfa-triples/0084.nt +8 -0
data/spec/rdfa-triples/0085.nt +4 -0
data/spec/rdfa-triples/0086.nt +0 -0
data/spec/rdfa-triples/0087.nt +23 -0
data/spec/rdfa-triples/0088.nt +3 -0
data/spec/rdfa-triples/0089.nt +1 -0
data/spec/rdfa-triples/0090.nt +1 -0
data/spec/rdfa-triples/0091.nt +3 -0
data/spec/rdfa-triples/0092.nt +3 -0
data/spec/rdfa-triples/0093.nt +2 -0
data/spec/rdfa-triples/0094.nt +3 -0
data/spec/rdfa-triples/0099.nt +1 -0
data/spec/rdfa-triples/0100.nt +3 -0
data/spec/rdfa-triples/0101.nt +3 -0
data/spec/rdfa-triples/0102.nt +1 -0
data/spec/rdfa-triples/0103.nt +1 -0
data/spec/rdfa-triples/0104.nt +3 -0
data/spec/rdfa-triples/0105.nt +1 -0
data/spec/rdfa-triples/0106.nt +1 -0
data/spec/rdfa-triples/0107.nt +0 -0
data/spec/rdfa-triples/0108.nt +1 -0
data/spec/rdfa-triples/0109.nt +1 -0
data/spec/rdfa-triples/0110.nt +1 -0
data/spec/rdfa-triples/0111.nt +2 -0
data/spec/rdfa-triples/0112.nt +1 -0
data/spec/rdfa-triples/0113.nt +2 -0
data/spec/rdfa-triples/0114.nt +3 -0
data/spec/rdfa-triples/0115.nt +4 -0
data/spec/rdfa-triples/0116.nt +2 -0
data/spec/rdfa-triples/0117.nt +2 -0
data/spec/rdfa-triples/0118.nt +1 -0
data/spec/rdfa-triples/0119.nt +1 -0
data/spec/rdfa-triples/0120.nt +1 -0
data/spec/rdfa-triples/0121.nt +2 -0
data/spec/rdfa-triples/0122.nt +1 -0
data/spec/rdfa-triples/0123.nt +3 -0
data/spec/rdfa-triples/0124.nt +4 -0
data/spec/rdfa-triples/0125.nt +1 -0
data/spec/rdfa-triples/0126.nt +3 -0
data/spec/rdfa-triples/1001.nt +6 -0
data/spec/rdfa_helper.rb +188 -0
data/spec/rdfa_parser_spec.rb +146 -0
data/spec/spec.opts +1 -0
data/spec/spec_helper.rb +8 -0
metadata +246 -0

data/History.txt ADDED

	@@ -0,0 +1,2 @@
1	+ === 0.0.1
2	+ First port from RdfContext version 0.5.4

data/README.rdoc ADDED

@@ -0,0 +1,59 @@
+= RDF::RDFa reader/writer
+RDFa parser for RDF.rb.
+== DESCRIPTION:
+RDF::RDFa is an RDFa parser for Ruby using the RDF.rb library suite.
+== FEATURES:
+RDF::RDFa parses RDFa into a Graph object.
+* Fully compliant XHTML/RDFa 1.0 parser.
+Install with 'gem install rdf-rdfa'
+== Usage:
+Instantiate a parser and parse source, specifying type and base-URL
+  use RDF::RDFa
+  p = Parser.new
+  graph = p.parse(input, "http://example.com")
+== Resources:
+* Distiller[http://kellogg-assoc/distiller]
+* RDoc[http://rdoc.info/projects/gkellogg/rdf-rdfa]
+* History[http://github.com/gkellogg/rdf-rdfa/blob/master/History.txt]
+== LICENSE:
+(The MIT License)
+Copyright (c) 2009-2010 Gregg Kellogg
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+== FEEDBACK
+* gregg@kellogg-assoc.com
+* rubygems.org/rdf-rdfa
+* github.com/gkellogg/rdf-rdfa
+* gkellogg.lighthouseapp.com for bug reports
+* public-rdf-ruby mailing list on w3.org

data/Rakefile ADDED

@@ -0,0 +1,46 @@
+require 'rubygems'
+begin
+  gem 'jeweler'
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rdf-rdfa"
+    gemspec.summary = "RDFa parser for RDF.rb."
+    gemspec.description = <<-DESCRIPTION
+    RDF::RDFa is an RDFa parser for Ruby using the RDF.rb library suite.
+    DESCRIPTION
+    gemspec.email = "gregg@kellogg-assoc.com"
+    gemspec.homepage = "http://github.com/gkellogg/rdf-rdfa"
+    gemspec.authors = ["Gregg Kellogg", "Nicholas Humfrey"]
+    gemspec.add_dependency('nokogiri', '>= 1.3.3')
+    gemspec.add_dependency('rdf', '>= 0.1.6')
+    gemspec.add_development_dependency('rspec')
+    gemspec.add_development_dependency('activesupport', '>= 2.3.0')
+    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt)
+  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
+desc "Run specs through RCov"
+Spec::Rake::SpecTask.new("spec:rcov") do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rcov = true
+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"]
+end
+task :default => :spec

data/VERSION ADDED

	@@ -0,0 +1 @@
1	+ 0.0.1

data/example.rb ADDED

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'rubygems'
+require 'rdfa/reader'
+data = <<-EOF;
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"
+      xmlns:dc="http://purl.org/dc/elements/1.1/">
+<head>
+  <title>Test 0001</title>
+</head>
+<body>
+  <p>This photo was taken by <span class="author" about="photo1.jpg" property="dc:creator">Mark Birbeck</span>.</p>
+</body>
+</html>
+EOF
+$DEBUG = false
+reader = RDFa::Reader.new(data, :debug => false)
+reader.each_statement do |statement|
+  statement.inspect!
+end

data/lib/rdfa/format.rb ADDED

@@ -0,0 +1,19 @@
+module RDF::RDFa
+  ##
+  # N-Triples format specification.
+  #
+  # @example Obtaining an NTriples format class
+  #   RDF::Format.for(:ntriples)     #=> RDF::NTriples::Format
+  #   RDF::Format.for("etc/doap.nt")
+  #   RDF::Format.for(:file_name      => "etc/doap.nt")
+  #   RDF::Format.for(:file_extension => "nt")
+  #   RDF::Format.for(:content_type   => "text/plain")
+  #
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  class Format < RDF::Format
+    content_type     'text/html', :extension => :html
+    content_encoding 'ascii'
+    reader { RDFa::Reader }
+  end
+end

data/lib/rdfa/reader.rb ADDED

@@ -0,0 +1,798 @@
+require 'nokogiri'
+require 'rdf'
+module RDF::RDFa
+  ##
+  # An RDFa parser in Ruby
+  #
+  # Based on processing rules described here:
+  #   file:///Users/gregg/Projects/rdf_context/RDFa%20Core%201.1.html#sequence
+  #
+  # Ben Adida
+  # 2008-05-07
+  # Gregg Kellogg
+  # 2009-08-04
+  class Reader < RDF::Reader
+    autoload :Namespace, 'rdfa/reader/namespace'
+    autoload :VERSION,   'rdfa/reader/version'
+    NC_REGEXP = Regexp.new(
+      %{^
+        (?!\\\\u0301)             # &#x301; is a non-spacing acute accent.
+                                  # It is legal within an XML Name, but not as the first character.
+        (  [a-zA-Z_]
+         | \\\\u[0-9a-fA-F]
+        )
+        (  [0-9a-zA-Z_\.-]
+         | \\\\u([0-9a-fA-F]{4})
+        )*
+      $},
+      Regexp::EXTENDED)
+    #XML_LITERAL = Literal::Encoding.xmlliteral
+    XML_LITERAL = RDF['XMLLiteral']
+    # FIXME: use RDF::URI.qname instead
+    RDF_NS      = Namespace.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf")
+    RDFA_NS     = Namespace.new("http://www.w3.org/ns/rdfa#", "rdfa")
+    RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")
+    XHV_NS      = Namespace.new("http://www.w3.org/1999/xhtml/vocab#", "xhv")
+    XML_NS      = Namespace.new("http://www.w3.org/XML/1998/namespace", "xml")
+    XSD_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema#", "xsd")
+    XSI_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema-instance", "xsi")
+    XH_MAPPING  = {"" => Namespace.new("http://www.w3.org/1999/xhtml/vocab\#", nil)}
+    require 'rdfa/format'
+    format RDFa::Format
+    attr_reader :debug
+    ##
+    # @return [RDF::Graph]
+    attr_reader :graph
+    # Host language, One of:
+    #   :xhtml_rdfa_1_0
+    #   :xhtml_rdfa_1_1
+    attr_reader :host_language
+    # The Recursive Baggage
+    class EvaluationContext # :nodoc:
+      # The base. This will usually be the URL of the document being processed,
+      # but it could be some other URL, set by some other mechanism,
+      # such as the (X)HTML base element. The important thing is that it establishes
+      # a URL against which relative paths can be resolved.
+      attr :base, true
+      # The parent subject.
+      # The initial value will be the same as the initial value of base,
+      # but it will usually change during the course of processing.
+      attr :parent_subject, true
+      # The parent object.
+      # In some situations the object of a statement becomes the subject of any nested statements,
+      # and this property is used to convey this value.
+      # Note that this value may be a bnode, since in some situations a number of nested statements
+      # are grouped together on one bnode.
+      # This means that the bnode must be set in the containing statement and passed down,
+      # and this property is used to convey this value.
+      attr :parent_object, true
+      # A list of current, in-scope URI mappings.
+      attr :uri_mappings, true
+      # A list of incomplete triples. A triple can be incomplete when no object resource
+      # is provided alongside a predicate that requires a resource (i.e., @rel or @rev).
+      # The triples can be completed when a resource becomes available,
+      # which will be when the next subject is specified (part of the process called chaining).
+      attr :incomplete_triples, true
+      # The language. Note that there is no default language.
+      attr :language, true
+      # The term mappings, a list of terms and their associated URIs.
+      # This specification does not define an initial list.
+      # Host Languages may define an initial list.
+      # If a Host Language provides an initial list, it should do so via an RDFa Profile document.
+      attr :term_mappings, true
+      # The default vocabulary, a value to use as the prefix URI when a term is used.
+      # This specification does not define an initial setting for the default vocabulary.
+      # Host Languages may define an initial setting.
+      attr :default_vocabulary, true
+      def initialize(base, host_defaults)
+        # Initialize the evaluation context, [5.1]
+        @base = base
+        @parent_subject = @base
+        @parent_object = nil
+        @uri_mappings = {}
+        @incomplete_triples = []
+        @language = nil
+        @term_mappings = host_defaults.fetch(:term_mappings, {})
+        @default_voabulary = host_defaults.fetch(:voabulary, nil)
+      end
+      # Copy this Evaluation Context
+      def initialize_copy(from)
+          # clone the evaluation context correctly
+          @uri_mappings = from.uri_mappings.clone
+          @incomplete_triples = from.incomplete_triples.clone
+      end
+      def inspect
+        v = %w(base parent_subject parent_object language default_vocabulary).map {|a| "#{a}='#{self.send(a).nil? ? '<nil>' : self.send(a)}'"}
+        v << "uri_mappings[#{uri_mappings.keys.length}]"
+        v << "incomplete_triples[#{incomplete_triples.length}]"
+        v << "term_mappings[#{term_mappings.keys.length}]"
+        v.join(",")
+      end
+    end
+    # Parse XHTML+RDFa document from a string or input stream to closure or graph.
+    #
+    # If the parser is called with a block, triples are passed to the block rather
+    # than added to the graph.
+    #
+    # Optionally, the stream may be a Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # With a block, yeilds each statement with URI, BNode or Literal elements
+    #
+    # @param  [IO] stream:: the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options:: Parser options, one of
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    # @raise [Error]:: Raises RdfError if _strict_
+    ##
+    # Initializes the RDFa reader instance.
+    #
+    # @param  [IO, File, String]       input
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [reader]
+    # @yieldparam [Reader] reader
+    def initialize(input = $stdin, options = {}, &block)
+      super
+        @graph = RDF::Graph.new
+        @debug = options[:debug]
+        @strict = options[:strict]
+        @base_uri = options[:base_uri]
+        @base_uri = RDF::URI.parse(@base_uri) if @base_uri.is_a?(String)
+        @named_bnodes = {}
+        @@vocabulary_cache ||= {}
+        @nsbinding = {}
+        @uri_binding = {}
+        @doc = case input
+        when Nokogiri::HTML::Document then input
+        when Nokogiri::XML::Document then input
+        else   Nokogiri::XML.parse(input, @base_uri.to_s)
+        end
+        raise ParserException, "Empty document" if @doc.nil? && @strict
+        @callback = block
+        # Determine host language
+        # XXX - right now only XHTML defined
+        @host_language = case @doc.root.attributes["version"].to_s
+        when /XHTML+RDFa/ then :xhtml
+        end
+        # If none found, assume xhtml
+        @host_language ||= :xhtml
+        @host_defaults = {}
+        @host_defaults = case @host_language
+        when :xhtml
+          bind(XHV_NS)
+          {
+            :vocabulary => XHV_NS.uri,
+            :prefix     => XHV_NS,
+            :term_mappings => %w(
+              alternate appendix bookmark cite chapter contents copyright first glossary help icon index
+              last license meta next p3pv1 prev role section stylesheet subsection start top up
+              ).inject({}) { |hash, term| hash[term] = XHV_NS.send("#{term}_"); hash },
+          }
+        else
+          {}
+        end
+        # parse
+        parse_whole_document(@doc, @base_uri)
+        block.call(self) if block_given?
+    end
+    ##
+    # Iterates the given block for each RDF statement in the input.
+    #
+    # @yield  [statement]
+    # @yieldparam [RDF::Statement] statement
+    # @return [void]
+    def each_statement(&block)
+      @graph.each_statement(&block)
+    end
+    ##
+    # Iterates the given block for each RDF triple in the input.
+    #
+    # @yield  [subject, predicate, object]
+    # @yieldparam [RDF::Resource] subject
+    # @yieldparam [RDF::URI]      predicate
+    # @yieldparam [RDF::Value]    object
+    # @return [void]
+    def each_triple(&block)
+      @graph.each_triple(&block)
+    end
+    # Bind namespace to store, returns bound namespace
+    def bind(namespace)
+      # Over-write an empty prefix
+      uri = namespace.uri.to_s
+      @uri_binding.delete(uri)
+      @nsbinding.delete_if {|prefix, ns| namespace.prefix == prefix}
+      @uri_binding[uri] = namespace
+      @nsbinding[namespace.prefix.to_s] = namespace
+    end
+    # Namespace for prefix
+    def namespace(prefix)
+      @nsbinding[prefix.to_s]
+    end
+    # Prefix for namespace
+    def prefix(namespace)
+      namespace.is_a?(Namespace) ? @uri_binding[namespace.uri.to_s].prefix : @uri_binding[namespace].prefix
+    end
+    private
+    # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
+    def node_path(node)
+      case node
+      when Nokogiri::XML::Element, Nokogiri::XML::Attr then "#{node_path(node.parent)}/#{node.name}"
+      when String then node
+      else ""
+      end
+    end
+    # Add debug event to debug array, if specified
+    #
+    # @param [XML Node, any] node:: XML Node or string for showing context
+    # @param [String] message::
+    def add_debug(node, message)
+      puts "#{node_path(node)}: #{message}" if $DEBUG
+      @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
+    end
+    # add a triple, object can be literal or URI or bnode
+    #
+    # If the parser is called with a block, triples are passed to the block rather
+    # than added to the graph.
+    #
+    # @param [Nokogiri::XML::Node, any] node:: XML Node or string for showing context
+    # @param [URI, BNode] subject:: the subject of the triple
+    # @param [URI] predicate:: the predicate of the triple
+    # @param [URI, BNode, Literal] object:: the object of the triple
+    # @return [Array]:: An array of the triples (leaky abstraction? consider returning the graph instead)
+    # @raise [Error]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
+    def add_triple(node, subject, predicate, object)
+      triple = RDF::Statement.new(subject, predicate, object)
+      add_debug(node, "triple: #{triple}")
+      if @callback
+        @callback.call(triple)  # Perform yield to saved block
+      else
+        @graph << triple
+      end
+      triple
+    # FIXME: rescue RdfException => e
+    rescue Exception => e
+      add_debug(node, "add_triple raised #{e.class}: #{e.message}")
+      puts e.backtrace if $DEBUG
+      raise if @strict
+    end
+    # 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']
+        # Strip any fragment from base
+        base = base.to_s.split("#").first
+        @base_uri = RDF::URI.new(base)
+        add_debug(base_el, "parse_whole_doc: base='#{base}'")
+      end
+      # initialize the evaluation context with the appropriate base
+      evaluation_context = EvaluationContext.new(base, @host_defaults)
+      traverse(doc.root, evaluation_context)
+    end
+    # Extract the XMLNS mappings from an element
+    def extract_mappings(element, uri_mappings, term_mappings)
+      # Process @profile
+      # Next the current element is parsed for any updates to the local term mappings and
+      # local list of URI mappings via @profile.
+      # If @profile is present, its value is processed as defined in RDFa Profiles.
+      element.attributes['profile'].to_s.split(/\s/).each do |profile|
+        # Don't try to open ourselves!
+        if @base_uri == profile
+          add_debug(element, "extract_mappings: skip recursive profile <#{profile}>")
+          @@vocabulary_cache[profile]
+        elsif @@vocabulary_cache.has_key?(profile)
+          add_debug(element, "extract_mappings: skip previously parsed profile <#{profile}>")
+        else
+          begin
+            add_debug(element, "extract_mappings: parse profile <#{profile}>")
+            @@vocabulary_cache[profile] = {
+              :uri_mappings => {},
+              :term_mappings => {}
+            }
+            um = @@vocabulary_cache[profile][:uri_mappings]
+            tm = @@vocabulary_cache[profile][:term_mappings]
+            add_debug(element, "extract_mappings: profile open <#{profile}>")
+            require 'patron' unless defined?(Patron)
+            sess = Patron::Session.new
+            sess.timeout = 10
+            resp = sess.get(profile)
+            raise RuntimeError, "HTTP returned status #{resp.status} when reading #{profile}" if resp.status >= 400
+            # Parse profile, and extract mappings from graph
+            old_debug, old_verbose, = $DEBUG, $verbose
+            $DEBUG, $verbose = false, false
+            p_graph = Parser.parse(resp.body, profile)
+            ttl = p_graph.serialize(:format => :ttl) if @debug || $DEBUG
+            $DEBUG, $verbose = old_debug, old_verbose
+            add_debug(element, ttl) if ttl
+            p_graph.subjects.each do |subject|
+              props = p_graph.properties(subject)
+              #puts props.inspect
+              # If one of the objects is not a Literal or if there are additional rdfa:uri or rdfa:term
+              # predicates sharing the same subject, no mapping is created.
+              uri = props[RDFA_NS.uri.to_s]
+              term = props[RDFA_NS.term_.to_s]
+              prefix = props[RDFA_NS.prefix_.to_s]
+              add_debug(element, "extract_mappings: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}")
+              next if !uri || (!term && !prefix)
+              raise ParserException, "multi-valued rdf:uri" if uri.length != 1
+              raise ParserException, "multi-valued rdf:term." if term && term.length != 1
+              raise ParserException, "multi-valued rdf:prefix" if prefix && prefix.length != 1
+              uri = uri.first
+              term = term.first if term
+              prefix = prefix.first if prefix
+              raise ParserException, "rdf:uri must be a Literal" unless uri.is_a?(Literal)
+              raise ParserException, "rdf:term must be a Literal" unless term.nil? || term.is_a?(Literal)
+              raise ParserException, "rdf:prefix must be a Literal" unless prefix.nil? || prefix.is_a?(Literal)
+              # For every extracted triple that is the common subject of an rdfa:prefix and an rdfa:uri
+              # predicate, create a mapping from the object literal of the rdfa:prefix predicate to the
+              # object literal of the rdfa:uri predicate. Add or update this mapping in the local list of
+              # URI mappings after transforming the 'prefix' component to lower-case.
+              # For every extracted
+              um[prefix.to_s.downcase] = bind(Namespace.new(uri.to_s, prefix.to_s.downcase)) if prefix
+              # triple that is the common subject of an rdfa:term and an rdfa:uri predicate, create a
+              # mapping from the object literal of the rdfa:term predicate to the object literal of the
+              # rdfa:uri predicate. Add or update this mapping in the local term mappings.
+              tm[term.to_s] = RDF::URI.new(uri.to_s) if term
+            end
+          rescue ParserException
+            add_debug(element, "extract_mappings: profile subject #{subject.to_s}: #{e.message}")
+            raise if @strict
+          rescue RuntimeError => e
+            add_debug(element, "extract_mappings: profile: #{e.message}")
+            raise if @strict
+          end
+        end
+        # Merge mappings from this vocabulary
+        uri_mappings.merge!(@@vocabulary_cache[profile][:uri_mappings])
+        term_mappings.merge!(@@vocabulary_cache[profile][:term_mappings])
+      end
+      # look for xmlns
+      # (note, this may be dependent on @host_language)
+      # Regardless of how the mapping is declared, the value to be mapped must be converted to lower case,
+      # and the URI is not processed in any way; in particular if it is a relative path it is
+      # not resolved against the current base.
+      element.namespaces.each do |attr_name, attr_value|
+        begin
+          abbr, prefix = attr_name.split(":")
+          uri_mappings[prefix.to_s.downcase] = bind(Namespace.new(attr_value, prefix.to_s.downcase)) if abbr.downcase == "xmlns" && prefix
+        # FIXME: rescue RdfException => e
+        rescue Exception => e
+          add_debug(element, "extract_mappings raised #{e.class}: #{e.message}")
+          raise if @strict
+        end
+      end
+      # Set mappings from @prefix
+      # prefix is a whitespace separated list of prefix-name URI pairs of the form
+      #   NCName ':' ' '+ xs:anyURI
+      # SPEC Confusion: prefix is forced to lower-case in @profile, but not specified here.
+      mappings = element.attributes["prefix"].to_s.split(/\s+/)
+      while mappings.length > 0 do
+        prefix, uri = mappings.shift.downcase, mappings.shift
+        #puts "uri_mappings prefix #{prefix} <#{uri}>"
+        next unless prefix.match(/:$/)
+        prefix.chop!
+        uri_mappings[prefix] = bind(Namespace.new(uri, prefix))
+      end
+      add_debug(element, "uri_mappings: #{uri_mappings.values.map{|ns|ns.to_s}.join(", ")}")
+      add_debug(element, "term_mappings: #{term_mappings.keys.join(", ")}")
+    end
+    # The recursive helper function
+    def traverse(element, evaluation_context)
+      if element.nil?
+        add_debug(element, "traverse nil element")
+        raise ParserException, "Can't parse nil element" if @strict
+        return nil
+      end
+      add_debug(element, "traverse, ec: #{evaluation_context.inspect}")
+      # local variables [5.5 Step 1]
+      recurse = true
+      skip = false
+      new_subject = nil
+      current_object_resource = nil
+      uri_mappings = evaluation_context.uri_mappings.clone
+      incomplete_triples = []
+      language = evaluation_context.language
+      term_mappings = evaluation_context.term_mappings.clone
+      default_vocabulary = evaluation_context.default_vocabulary
+      current_object_literal = nil  # XXX Not explicit
+      # shortcut
+      attrs = element.attributes
+      about = attrs['about']
+      src = attrs['src']
+      resource = attrs['resource']
+      href = attrs['href']
+      vocab = attrs['vocab']
+      # Pull out the attributes needed for the skip test.
+      property = attrs['property'].to_s if attrs['property']
+      typeof = attrs['typeof'].to_s if attrs['typeof']
+      datatype = attrs['datatype'].to_s if attrs['datatype']
+      content = attrs['content'].to_s if attrs['content']
+      rel = attrs['rel'].to_s if attrs['rel']
+      rev = attrs['rev'].to_s if attrs['rev']
+      # Default vocabulary [7.5 Step 2]
+      # First the current element is examined for any change to the default vocabulary via @vocab.
+      # If @vocab is present and contains a value, its value updates the local default vocabulary.
+      # If the value is empty, then the local default vocabulary must be reset to the Host Language defined default.
+      unless vocab.nil?
+        default_vocabulary = if vocab.to_s.empty?
+          # Set default_vocabulary to host language default
+          @host_defaults.fetch(:voabulary, nil)
+        else
+          vocab.to_s
+        end
+        add_debug(element, "[Step 2] traverse, default_vocaulary: #{default_vocabulary.inspect}")
+      end
+      # Local term mappings [7.5 Steps 3 & 4]
+      # Next the current element is parsed for any updates to the local term mappings and local list of URI mappings via @profile.
+      # If @profile is present, its value is processed as defined in RDFa Profiles.
+      extract_mappings(element, uri_mappings, term_mappings)
+      # Language information [7.5 Step 5]
+      # From HTML5 [3.2.3.3]
+      #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
+      #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
+      #   attribute in no namespace must be ignored for the purposes of determining the element's
+      #   language.
+      language = case
+      when element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s)
+        element.at_xpath("@xml:lang", "xml" => XML_NS.uri.to_s).to_s
+      when element.at_xpath("lang")
+        element.at_xpath("lang").to_s
+      else
+        language
+      end
+      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if attrs['lang']
+      # rels and revs
+      rels = process_uris(element, rel, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+      revs = process_uris(element, rev, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+      add_debug(element, "traverse, about: #{about.nil? ? 'nil' : about}, src: #{src.nil? ? 'nil' : src}, resource: #{resource.nil? ? 'nil' : resource}, href: #{href.nil? ? 'nil' : href}")
+      add_debug(element, "traverse, property: #{property.nil? ? 'nil' : property}, typeof: #{typeof.nil? ? 'nil' : typeof}, datatype: #{datatype.nil? ? 'nil' : datatype}, content: #{content.nil? ? 'nil' : content}")
+      add_debug(element, "traverse, rels: #{rels.join(" ")}, revs: #{revs.join(" ")}")
+      if !(rel || rev)
+        # Establishing a new subject if no rel/rev [7.5 Step 6]
+        # May not be valid, but can exist
+        if about
+          new_subject = process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
+        elsif src
+          new_subject = process_uri(element, src, evaluation_context)
+        elsif resource
+          new_subject =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
+        elsif href
+          new_subject = process_uri(element, href, evaluation_context)
+        end
+        # If no URI is provided by a resource attribute, then the first match from the following rules
+        # will apply:
+        #   if @typeof is present, then new subject is set to be a newly created bnode.
+        # otherwise,
+        #   if parent object is present, new subject is set to the value of parent object.
+        # Additionally, if @property is not present then the skip element flag is set to 'true';
+        if new_subject.nil?
+          if @host_language == :xhtml && element.name =~ /^(head|body)$/ && evaluation_context.base
+            # From XHTML+RDFa 1.1:
+            # if no URI is provided, then first check to see if the element is the head or body element.
+            # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
+            new_subject = RDF::URI.new(evaluation_context.base)
+          elsif element.attributes['typeof']
+            new_subject = RDF::Node.new
+          else
+            # if it's null, it's null and nothing changes
+            new_subject = evaluation_context.parent_object
+            skip = true unless property
+          end
+        end
+        add_debug(element, "[Step 6] new_subject: #{new_subject}, skip = #{skip}")
+      else
+        # [7.5 Step 7]
+        # If the current element does contain a @rel or @rev attribute, then the next step is to
+        # establish both a value for new subject and a value for current object resource:
+        if about
+          new_subject =  process_uri(element, about, evaluation_context, :uri_mappings => uri_mappings)
+        elsif src
+          new_subject =  process_uri(element, src, evaluation_context, :uri_mappings => uri_mappings)
+        end
+        # If no URI is provided then the first match from the following rules will apply
+        if new_subject.nil?
+          if @host_language == :xhtml && element.name =~ /^(head|body)$/
+            # From XHTML+RDFa 1.1:
+            # if no URI is provided, then first check to see if the element is the head or body element.
+            # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
+            new_subject = RDF::URI.new(evaluation_context.base)
+          elsif element.attributes['typeof']
+            new_subject = RDF::Node.new
+          else
+            # if it's null, it's null and nothing changes
+            new_subject = evaluation_context.parent_object
+            # no skip flag set this time
+          end
+        end
+        # Then the current object resource is set to the URI obtained from the first match from the following rules:
+        if resource
+          current_object_resource =  process_uri(element, resource, evaluation_context, :uri_mappings => uri_mappings)
+        elsif href
+          current_object_resource = process_uri(element, href, evaluation_context)
+        end
+        add_debug(element, "[Step 7] new_subject: #{new_subject}, current_object_resource = #{current_object_resource.nil? ? 'nil' : current_object_resource}")
+      end
+      # Process @typeof if there is a subject [Step 8]
+      if new_subject and typeof
+        # Typeof is TERMorCURIEorURIs
+        types = process_uris(element, typeof, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+        add_debug(element, "typeof: #{typeof}")
+        types.each do |one_type|
+          add_triple(element, new_subject, RDF_TYPE, one_type)
+        end
+      end
+      # Generate triples with given object [Step 9]
+      if current_object_resource
+        rels.each do |r|
+          add_triple(element, new_subject, r, current_object_resource)
+        end
+        revs.each do |r|
+          add_triple(element, current_object_resource, r, new_subject)
+        end
+      elsif rel || rev
+        # Incomplete triples and bnode creation [Step 10]
+        add_debug(element, "[Step 10] incompletes: rels: #{rels}, revs: #{revs}")
+        current_object_resource = RDF::Node.new
+        rels.each do |r|
+          incomplete_triples << {:predicate => r, :direction => :forward}
+        end
+        revs.each do |r|
+          incomplete_triples << {:predicate => r, :direction => :reverse}
+        end
+      end
+      # Establish current object literal [Step 11]
+      if property
+        properties = process_uris(element, property, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
+        # get the literal datatype
+        type = datatype
+        children_node_types = element.children.collect{|c| c.class}.uniq
+        # the following 3 IF clauses should be mutually exclusive. Written as is to prevent extensive indentation.
+        type_resource = process_uri(element, type, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary) if type
+        if type and !type.empty? and (type_resource.to_s != XML_LITERAL.to_s)
+          # typed literal
+          add_debug(element, "[Step 11] typed literal")
+          current_object_literal = RDF::Literal.new(content || element.inner_text, :datatype => type_resource, :language => language)
+        elsif content or (children_node_types == [Nokogiri::XML::Text]) or (element.children.length == 0) or (type == '')
+          # plain literal
+          add_debug(element, "[Step 11] plain literal")
+          current_object_literal = RDF::Literal.new(content || element.inner_text, :language => language)
+        elsif children_node_types != [Nokogiri::XML::Text] and (type == nil or type_resource.to_s == XML_LITERAL.to_s)
+          # XML Literal
+          add_debug(element, "[Step 11] XML Literal: #{element.inner_html}")
+          current_object_literal = RDF::Literal.new(element.inner_html, :datatype => XML_LITERAL, :language => language, :namespaces => uri_mappings)
+          recurse = false
+        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?
+        # Complete the incomplete triples from the evaluation context [Step 12]
+        add_debug(element, "[Step 12] complete incomplete triples: new_subject=#{new_subject}, completes=#{evaluation_context.incomplete_triples.inspect}")
+        evaluation_context.incomplete_triples.each do |trip|
+          if trip[:direction] == :forward
+            add_triple(element, evaluation_context.parent_subject, trip[:predicate], new_subject)
+          elsif trip[:direction] == :reverse
+            add_triple(element, new_subject, trip[:predicate], evaluation_context.parent_subject)
+          end
+        end
+      end
+      # Create a new evaluation context and proceed recursively [Step 13]
+      if recurse
+        if skip
+          if language == evaluation_context.language &&
+              uri_mappings == evaluation_context.uri_mappings &&
+              term_mappings == evaluation_context.term_mappings &&
+              default_vocabulary == evaluation_context.default_vocabulary &&
+            new_ec = evaluation_context
+            add_debug(element, "[Step 13] skip: reused ec")
+          else
+            new_ec = evaluation_context.clone
+            new_ec.language = language
+            new_ec.uri_mappings = uri_mappings
+            new_ec.term_mappings = term_mappings
+            new_ec.default_vocabulary = default_vocabulary
+            add_debug(element, "[Step 13] skip: cloned ec")
+          end
+        else
+          # create a new evaluation context
+          new_ec = EvaluationContext.new(evaluation_context.base, @host_defaults)
+          new_ec.parent_subject = new_subject || evaluation_context.parent_subject
+          new_ec.parent_object = current_object_resource || new_subject || evaluation_context.parent_subject
+          new_ec.uri_mappings = uri_mappings
+          new_ec.incomplete_triples = incomplete_triples
+          new_ec.language = language
+          new_ec.term_mappings = term_mappings
+          new_ec.default_vocabulary = default_vocabulary
+          add_debug(element, "[Step 13] new ec")
+        end
+        element.children.each do |child|
+          # recurse only if it's an element
+          traverse(child, new_ec) if child.class == Nokogiri::XML::Element
+        end
+      end
+    end
+    # space-separated TERMorCURIEorURI
+    def process_uris(element, value, evaluation_context, options)
+      return [] if value.to_s.empty?
+      add_debug(element, "process_uris: #{value}")
+      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, options)}.compact
+    end
+    def process_uri(element, value, evaluation_context, options = {})
+      #return if value.to_s.empty?
+      #add_debug(element, "process_uri: #{value}")
+      options = {:uri_mappings => {}}.merge(options)
+      if !options[:term_mappings] && options[:uri_mappings] && value.to_s.match(/^\[(.*)\]$/)
+        # SafeCURIEorCURIEorURI
+        # When the value is surrounded by square brackets, then the content within the brackets is
+        # evaluated as a CURIE according to the CURIE Syntax definition. If it is not a valid CURIE, the
+        # value must be ignored.
+        uri = curie_to_resource_or_bnode(element, $1, options[:uri_mappings], evaluation_context.parent_subject)
+        add_debug(element, "process_uri: #{value} => safeCURIE => <#{uri}>")
+        uri
+      elsif options[:term_mappings] && NC_REGEXP.match(value.to_s)
+        # TERMorCURIEorURI
+        # If the value is an NCName, then it is evaluated as a term according to General Use of Terms in
+        # Attributes. Note that this step may mean that the value is to be ignored.
+        uri = process_term(value.to_s, options)
+        add_debug(element, "process_uri: #{value} => term => <#{uri}>")
+        uri
+      else
+        # SafeCURIEorCURIEorURI or TERMorCURIEorURI
+        # Otherwise, the value is evaluated as a CURIE.
+        # If it is a valid CURIE, the resulting URI is used; otherwise, the value will be processed as a URI.
+        uri = curie_to_resource_or_bnode(element, value, options[:uri_mappings], evaluation_context.parent_subject)
+        if uri
+          add_debug(element, "process_uri: #{value} => CURIE => <#{uri}>")
+        else
+          #FIXME: uri = URIRef.new(value, evaluation_context.base)
+          uri = RDF::URI.new(value)
+          add_debug(element, "process_uri: #{value} => URI => <#{uri}>")
+        end
+        uri
+      end
+    end
+    # [7.4.3] General Use of Terms in Attributes
+    #
+    # @param [String] term:: term
+    # @param [Hash] options:: Parser options, one of
+    # <em>options[:term_mappings]</em>:: Term mappings
+    # <em>options[:vocab]</em>:: Default vocabulary
+    def process_term(value, options)
+      case
+      when options[:term_mappings].is_a?(Hash) && options[:term_mappings].has_key?(value.to_s.downcase)
+        # If the term is in the local term mappings, use the associated URI.
+        # XXX Spec Confusion: are terms always downcased? Or only for XHTML Vocab?
+        options[:term_mappings][value.to_s.downcase]
+      when options[:vocab]
+        # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
+        options[:vocab] + value
+      else
+        # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
+        nil
+      end
+    end
+    # From section 6. CURIE Syntax Definition
+    def curie_to_resource_or_bnode(element, curie, uri_mappings, subject)
+      # URI mappings for CURIEs default to XH_MAPPING, rather than the default doc namespace
+      prefix, reference = curie.to_s.split(":")
+      # consider the bnode situation
+      if prefix == "_"
+        # we force a non-nil name, otherwise it generates a new name
+        # FIXME: BNode.new(reference || "", @named_bnodes)
+        RDF::Node.new(reference || nil)
+      elsif curie.to_s.match(/^:/)
+        # Default prefix
+        if uri_mappings[""]
+          uri_mappings[""].send("#{reference}_")
+        elsif @host_defaults[:prefix]
+          @host_defaults[:prefix].send("#{reference}_")
+        end
+      elsif !curie.to_s.match(/:/)
+        # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
+        nil
+      else
+        # XXX Spec Confusion, are prefixes always downcased?
+        ns = uri_mappings[prefix.to_s.downcase]
+        if ns
+          ns + reference
+        else
+          add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix.downcase}")
+          nil
+        end
+      end
+    end
+  end
+end