rdf-rdfa 0.0.2 → 0.0.3

data/lib/rdf/rdfa/version.rb

@@ -1,23 +1,21 @@
-module RDFa
-  module VERSION
-    MAJOR = 0
-    MINOR = 0
-    TINY  = 2
-    EXTRA = nil
+module RDF::RDFa::VERSION
+  MAJOR = 0
+  MINOR = 0
+  TINY  = 3
+  EXTRA = nil
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
-    STRING << "-#{EXTRA}" if EXTRA
+  STRING = [MAJOR, MINOR, TINY].join('.')
+  STRING << "-#{EXTRA}" if EXTRA
 
-    ##
-    # @return [String]
-    def self.to_s()   STRING end
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
 
-    ##
-    # @return [String]
-    def self.to_str() STRING end
+  ##
+  # @return [String]
+  def self.to_str() STRING end
 
-    ##
-    # @return [Array(Integer, Integer, Integer)]
-    def self.to_a() [MAJOR, MINOR, TINY] end
-  end
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() [MAJOR, MINOR, TINY] end
 end

data/lib/rdf/rdfa/vocab.rb

@@ -3,5 +3,4 @@ module RDF
   class XHV < Vocabulary("http://www.w3.org/1999/xhtml/vocab#"); end
   class XML < Vocabulary("http://www.w3.org/XML/1998/namespace"); end
   class XSI < Vocabulary("http://www.w3.org/2001/XMLSchema-instance"); end
-  class OWL < Vocabulary("http://www.w3.org/2002/07/owl#"); end
 end

data/rdf-rdfa.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-rdfa}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Gregg Kellogg", "Nicholas Humfrey"]
-  s.date = %q{2010-06-03}
-  s.description = %q{    RDF::RDFa is an RDFa parser for Ruby using the RDF.rb library suite.
+  s.authors = ["Gregg Kellogg"]
+  s.date = %q{2010-06-10}
+  s.description = %q{    RDF::RDFa is an RDFa reader for Ruby using the RDF.rb library suite.
 }
   s.email = %q{gregg@kellogg-assoc.com}
   s.extra_rdoc_files = [
@@ -19,23 +19,27 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    "AUTHORS",
+    ".gitignore",
+     ".yardopts",
+     "AUTHORS",
+     "CONTRIBUTORS",
      "History.txt",
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "etc/basic.html",
      "etc/foaf.html",
      "etc/xhv.html",
      "example.rb",
      "lib/rdf/rdfa.rb",
      "lib/rdf/rdfa/format.rb",
      "lib/rdf/rdfa/reader.rb",
-     "lib/rdf/rdfa/reader/exceptions.rb",
      "lib/rdf/rdfa/version.rb",
      "lib/rdf/rdfa/vocab.rb",
      "pkg/.gitignore",
      "rdf-rdfa.gemspec",
      "script/console",
+     "spec/matchers.rb",
      "spec/rdfa-triples/0001.nt",
      "spec/rdfa-triples/0006.nt",
      "spec/rdfa-triples/0007.nt",
@@ -157,9 +161,10 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
-  s.summary = %q{RDFa parser for RDF.rb.}
+  s.summary = %q{RDFa reader for RDF.rb.}
   s.test_files = [
-    "spec/rdfa_helper.rb",
+    "spec/matchers.rb",
+     "spec/rdfa_helper.rb",
      "spec/rdfa_reader_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -171,14 +176,12 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rdf>, [">= 0.1.6"])
       s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.3"])
-      s.add_runtime_dependency(%q<patron>, [">= 0.4.6"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<rdf-spec>, [">= 0"])
       s.add_development_dependency(%q<activesupport>, [">= 2.3.0"])
     else
       s.add_dependency(%q<rdf>, [">= 0.1.6"])
       s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
-      s.add_dependency(%q<patron>, [">= 0.4.6"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<rdf-spec>, [">= 0"])
       s.add_dependency(%q<activesupport>, [">= 2.3.0"])
@@ -186,7 +189,6 @@ Gem::Specification.new do |s|
   else
     s.add_dependency(%q<rdf>, [">= 0.1.6"])
     s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
-    s.add_dependency(%q<patron>, [">= 0.4.6"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<rdf-spec>, [">= 0"])
     s.add_dependency(%q<activesupport>, [">= 2.3.0"])

data/spec/matchers.rb

@@ -0,0 +1,205 @@
+module Matchers
+  class BeEquivalentGraph
+    Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
+    def normalize(graph)
+      case @info.compare
+      when :array
+        array = case graph
+        when Graph, Parser
+          graph = graph.graph if graph.respond_to?(:graph)
+          anon = "a"
+          anon_ctx = {}
+          graph.triples.collect {|triple| triple.to_ntriples }.each do |t|
+            t.gsub(/_:nbn\d+[a-z]+N/, "_:").
+            gsub!(/_:bn\d+[a-z]+/) do |bn|
+              # Normalize anon BNodes
+              if anon_ctx[bn]
+                anon_ctx[bn]
+              else
+                anon_ctx[bn] = anon
+                anon = anon.succ
+              end
+              "_:#{anon_ctx[bn]}"
+            end
+          end.sort
+        when Array
+          graph.sort
+        else
+          graph.to_s.split("\n").
+            map {|t| t.gsub(/^\s*(.*)\s*$/, '\1')}.
+            reject {|t2| t2.match(/^\s*$/)}.
+            compact.
+            sort.
+            uniq
+        end
+        
+        # Implement to_ntriples on array, to simplify logic later
+        def array.to_ntriples; self.join("\n") + "\n"; end
+        array
+      else
+        case graph
+        when Graph then graph
+        when Parser then graph.graph
+        when IO, StringIO
+          Parser.parse(graph, @info.about)
+        else
+          parser = Parser.new(:struct => true)
+          fmt = parser.detect_format(graph.to_s)
+          parser.parse(graph.to_s, @info.about, :type => fmt)
+        end
+      end
+    end
+    
+    def initialize(expected, info)
+      @info = if info.respond_to?(:about)
+        info
+      elsif info.is_a?(Hash)
+        identifier = info[:identifier] || expected.is_a?(Graph) ? expected.identifier : info[:about]
+        Info.new(identifier, info[:information] || "", info[:trace], info[:compare])
+      else
+        Info.new(expected.is_a?(Graph) ? expected.identifier : info, info.to_s)
+      end
+      @expected = normalize(expected)
+    end
+
+    def matches?(actual)
+      @actual = normalize(actual)
+      @actual == @expected
+    end
+
+    def failure_message_for_should
+      info = @info.respond_to?(:information) ? @info.information : ""
+      if @expected.is_a?(Graph) && @actual.size != @expected.size
+        "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+      elsif @expected.is_a?(Array) && @actual.size != @expected.length
+        "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+      elsif @expected.is_a?(Graph) && @actual.identifier != @expected.identifier
+        "Graph identifiers differ:\nexpected: #{@expected.identifier}\nactual:   #{@actual.identifier}"
+      else
+        "Graph differs#{@info.compare == :array ? '(array)' : ''}\n"
+      end +
+      "\n#{info + "\n" unless info.empty?}" +
+      (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+      (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
+      "Unsorted Expected:\n#{@expected.to_ntriples}" +
+      "Unsorted Results:\n#{@actual.to_ntriples}" +
+      (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
+    end
+    def negative_failure_message
+      "Graphs do not differ\n"
+    end
+  end
+  
+  def be_equivalent_graph(expected, info = nil)
+    BeEquivalentGraph.new(expected, info)
+  end
+
+  # Run expected SPARQL query against actual
+  if $redland_enabled
+    class PassQuery
+      def initialize(expected, info)
+        @expected = expected
+        @query = Redland::Query.new(expected)
+        @info = info
+      end
+      def matches?(actual)
+        @actual = actual
+        @expected_results = @info.respond_to?(:expectedResults) ? @info.expectedResults : true
+        model = Redland::Model.new
+        ntriples_parser = Redland::Parser.ntriples
+        ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
+
+        @results = @query.execute(model)
+        #puts "Redland query results: #{@results.inspect}"
+        if @expected_results
+          @results.is_boolean? && @results.get_boolean?
+        else
+          @results.nil? || @results.is_boolean? && !@results.get_boolean?
+        end
+      end
+      def failure_message_for_should
+        info = @info.respond_to?(:information) ? @info.information : ""
+        "#{info + "\n" unless info.empty?}" +
+        if @results.nil?
+          "Query failed to return results"
+        elsif !@results.is_boolean?
+          "Query returned non-boolean results"
+        elsif @expected_results
+          "Query returned false"
+        else
+          "Query returned true (expected false)"
+        end +
+        "\n#{@expected}" +
+        "\n#{@info.input}" +
+        "\nResults:\n#{@actual.to_ntriples}" +
+        "\nDebug:\n#{@info.trace}"
+      end
+    end
+
+    def pass_query(expected, info = "")
+      PassQuery.new(expected, info)
+    end
+  else
+    def pass_query(expect, info = ""); false; end
+  end
+
+  class BeValidXML
+    def initialize(info)
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      @doc = Nokogiri::XML.parse(actual)
+      @results = @doc.validate
+      @results.nil?
+    rescue
+      false
+    end
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      if @doc.nil?
+        "did not parse"
+      else
+        "\n#{@results}" +
+        "\nParsed:\n#{@doc}"
+      end   +
+        "\nActual:\n#{@actual}"
+    end
+  end
+  
+  def be_valid_xml(info = "")
+    BeValidXML.new(info)
+  end
+
+  class BeEquivalentXML
+    def initialize(expected, info)
+      @expected = expected
+      @info = info
+    end
+    
+    def matches?(actual)
+      @actual = actual
+
+      a = @actual.index("<") == 0 ? @actual : "<foo>#{@actual}</foo>"
+      e = @expected.index("<") == 0 ? @expected : "<foo>#{@expected}</foo>"
+      a_hash = ActiveSupport::XmlMini.parse(a)
+      e_hash = ActiveSupport::XmlMini.parse(e)
+      a_hash == e_hash
+    rescue
+      puts $!
+      @fault = $!.message
+      false
+    end
+
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      "Fault: #{@fault + "\n" if @fault}" +
+      "Expected:#{@expected}\n" +
+      "Actual:#{@actual}"
+    end
+  end
+  
+  def be_equivalent_xml(expected, info = "")
+    BeEquivalentXML.new(expected, info)
+  end
+end

data/spec/rdfa_reader_spec.rb

@@ -16,158 +16,467 @@ describe RDF::RDFa::Format do
 end
 
 describe "RDF::RDFa::Reader" do
-  it "should be discoverable" do
-    readers = [
-      RDF::Reader.for(:rdfa),
-      RDF::Reader.for("etc/foaf.html"),
-      RDF::Reader.for(:file_name      => "etc/foaf.html"),
-      RDF::Reader.for(:file_extension => "html"),
-      RDF::Reader.for(:file_extension => "xhtml"),
-      RDF::Reader.for(:content_type   => "text/html"),
-      RDF::Reader.for(:content_type   => "application/xhtml+xml"),
-    ]
-    readers.each { |reader| reader.should == RDF::RDFa::Reader }
+  context "discovery" do
+    {
+      "html" => RDF::Reader.for(:rdfa),
+      "etc/foaf.html" => RDF::Reader.for("etc/foaf.html"),
+      "foaf.html" => RDF::Reader.for(:file_name      => "foaf.html"),
+      ".html" => RDF::Reader.for(:file_extension => "html"),
+      "application/xhtml+xml" => RDF::Reader.for(:content_type   => "application/xhtml+xml"),
+    }.each_pair do |label, format|
+      it "should discover '#{label}'" do
+        format.should == RDF::RDFa::Reader
+      end
+    end
+  end
+
+  context :interface do
+    before(:each) do
+      @sampledoc = <<-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
+    end
+
+    it "should yield reader" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(RDF::RDFa::Reader)
+      RDF::RDFa::Reader.new(@sampledoc) do |reader|
+        inner.called(reader.class)
+      end
+    end
+
+    it "should return reader" do
+      RDF::RDFa::Reader.new(@sampledoc).should be_a(RDF::RDFa::Reader)
+    end
+
+    it "should yield statements" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(RDF::Statement)
+      RDF::RDFa::Reader.new(@sampledoc).each_statement do |statement|
+        inner.called(statement.class)
+      end
+    end
+
+    it "should yield triples" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(RDF::URI, RDF::URI, RDF::Literal)
+      RDF::RDFa::Reader.new(@sampledoc).each_triple do |subject, predicate, object|
+        inner.called(subject.class, predicate.class, object.class)
+      end
+    end
+  end
+
+  context "paring a simple doc" do
+    before :each do
+      sampledoc = <<-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
+
+      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0001.xhtml", :strict => true)
+      @statement = @graph.statements.first
+    end
+
+    it "should return 1 triple" do
+      @graph.size.should == 1
+    end
+
+    it "should have a subject with an expanded URI" do
+      @statement.subject.should == RDF::URI('http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/photo1.jpg')
+    end
+
+    it "should have a predicate of dc:creator" do
+      @statement.predicate.should == RDF::DC11.creator
+    end
+
+    it "should have an object of type literal and value 'Mark Birkbeck'" do
+      @statement.object.should == RDF::Literal("Mark Birbeck")
+    end
+  end
+
+  context "parsing a simple doc without a base URI" do
+    before :each do
+      sampledoc = <<-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/">
+<body>
+  <p>This photo was taken by <span class="author" about="_:photo" property="dc:creator">Mark Birbeck</span>.</p>
+</body>
+</html>
+EOF
+
+      @graph = parse(sampledoc, :strict => true)
+      @statement = @graph.statements.first
+    end
+
+    it "should return 1 triple" do
+      @graph.size.should == 1
+    end
+
+    it "should have a Blank Node named 'photo' as the subject of the triple" do
+      @statement.subject.should == RDF::Node('photo')
+    end
+
+    it "should have a predicate of dc:creator" do
+      @statement.predicate.should == RDF::DC11.creator
+    end
+
+    it "should have an object of type literal and value 'Mark Birkbeck'" do
+      @statement.object.should == RDF::Literal("Mark Birbeck")
+    end
+  end
+
+  context "parsing a document containing an XML Literal" do
+    before :each do
+      sampledoc = <<-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 0011</title>
+  </head>
+  <body>
+    <div about="">
+      Author: <span property="dc:creator">Albert Einstein</span>
+      <h2 property="dc:title">E = mc<sup>2</sup>: The Most Urgent Problem of Our Time</h2>
+  </div>
+  </body>
+</html>
+EOF
+
+      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml", :strict => true)
+    end
+
+    it "should return 2 triples" do
+      @graph.size.should == 2
+    end
+
+    it "should have a triple for the dc:creator of the document" do
+      @graph.should have_triple([
+        RDF::URI('http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml'),
+        RDF::DC11.creator,
+        "Albert Einstein"
+      ])
+    end
+
+    it "should have an XML Literal for the dc:title of the document" do
+      @graph.should have_triple([
+        RDF::URI('http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml'),
+        RDF::DC11.title,
+        RDF::Literal("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time", :datatype => RDF.XMLLiteral)
+      ])
+    end
+  end
+
+  context "parsing a document containing sereral bnodes" do
+    before :each do
+      sampledoc = <<-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" version="XHTML+RDFa 1.0"
+      xmlns:foaf="http://xmlns.com/foaf/0.1/">
+  <head>
+  <title>Test 0017</title>
+  </head>
+  <body>
+     <p>
+          <span about="[_:a]" property="foaf:name">Manu Sporny</span>
+           <span about="[_:a]" rel="foaf:knows" resource="[_:b]">knows</span>
+           <span about="[_:b]" property="foaf:name">Ralph Swick</span>.
+        </p>
+  </body>
+</html>
+EOF
+
+      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0017.xhtml", :strict => true)
+    end
+
+    it "should return 3 triples" do
+      @graph.size.should == 3
+    end
+
+    it "should have a triple for the foaf:name of BNode A" do
+      @graph.should have_triple([
+        RDF::Node('a'),
+        RDF::FOAF.name,
+        "Manu Sporny"
+      ])
+    end
+
+    it "should have a triple for the foaf:name of BNode B" do
+      @graph.should have_triple([
+        RDF::Node('b'),
+        RDF::FOAF.name,
+        "Ralph Swick"
+      ])
+    end
+
+    it "should have a triple for BNode A knows BNode B" do
+      @graph.should have_triple([
+        RDF::Node('a'),
+        RDF::FOAF.knows,
+        RDF::Node('b'),
+      ])
+    end
   end
 
-   it "should parse simple doc" do
-    sampledoc = <<-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
-
-    reader = RDF::RDFa::Reader.new(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0001.xhtml", :strict => true)
-    reader.graph.size.should == 1
-    reader.graph.should have_object("Mark Birbeck")
+  context "parsing a document that uses the typeof attribute" do
+    before :each do
+      sampledoc = <<-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" version="XHTML+RDFa 1.0"
+      xmlns:foaf="http://xmlns.com/foaf/0.1/">
+  <head>
+    <title>Test 0049</title>
+  </head>
+  <body>
+    <div about="http://www.example.org/#me" typeof="foaf:Person">
+      <p property="foaf:name">John Doe</p>
+    </div>
+  </body>
+</html>
+EOF
+
+      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0049.xhtml", :strict => true)
+    end
+
+    it "should return 2 triples" do
+      @graph.size.should == 2
+    end
+
+    it "should have a triple stating that #me is of type foaf:Person" do
+      @graph.should have_triple([
+        RDF::URI('http://www.example.org/#me'),
+        RDF.type,
+        RDF::FOAF.Person
+      ])
+    end
+
+    it "should have a triple stating that #me has name 'John Doe'" do
+      @graph.should have_triple([
+        RDF::URI('http://www.example.org/#me'),
+        RDF::FOAF.name,
+        RDF::Literal("John Doe")
+      ])
+    end
   end
 
-  it "should parse simple doc without a base URI" do
-    sampledoc = <<-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/">
-    <body>
-    	<p>This photo was taken by <span class="author" about="_:photo" property="dc:creator">Mark Birbeck</span>.</p>
-    </body>
-    </html>
-    EOF
-
-    reader = RDF::RDFa::Reader.new(sampledoc, :strict => true)
-    reader.graph.size.should == 1
-    reader.graph.should have_triple([RDF::Node('photo'), RDF::DC11.creator, "Mark Birbeck"])
+  context "parsing a document with a <base> tag in the <head>" do
+    before :each do
+      sampledoc = <<-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" version="XHTML+RDFa 1.0"
+    xmlns:dc="http://purl.org/dc/elements/1.1/">
+ <head>
+    <base href="http://www.example.org/"></base>
+    <title>Test 0072</title>
+ </head>
+ <body>
+    <p about="faq">
+       Learn more by reading the example.org
+       <span property="dc:title">Example FAQ</span>.
+    </p>
+ </body>
+</html>
+EOF
+
+      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0072.xhtml", :strict => true)
+    end
+
+    it "should return 1 triple" do
+      @graph.size.should == 1
+    end
+
+    it "should have the subject of the triple relative to the URI in base" do
+      @graph.should have_subject RDF::URI('http://www.example.org/faq')
+    end
   end
 
-  it "should parse an XML Literal" do
-    sampledoc = <<-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 0011</title>
-    	</head>
-      <body>
-      	<div about="">
-          Author: <span property="dc:creator">Albert Einstein</span>
-          <h2 property="dc:title">E = mc<sup>2</sup>: The Most Urgent Problem of Our Time</h2>
-    	</div>
-      </body>
-    </html>
-    EOF
-
-    reader = RDF::RDFa::Reader.new(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml", :strict => true)
-    reader.graph.size.should == 2
-
-    reader.graph.should have_object("Albert Einstein")
-    reader.graph.should have_object(
-      RDF::Literal("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time",
-        :datatype => RDF.XMLLiteral)
-    )
+  context "parsing a document with a profile containing a prefix mapping" do
+    before :each do
+      sampledoc = <<-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" version="XHTML+RDFa 1.0">
+  <head>
+    <title>Test</title>
+    <base href="http://example.org/"/>
+  </head>
+  <body profile="http://www.w3.org/2007/08/pyRdfa/profiles/basic">
+  <div about="#me">
+    <p>
+      <span property="foaf:name">Ivan Herman</span>
+    </p>
+  </div>
+  </body>
+</html>
+EOF
+      
+      basic = File.open(File.join(File.dirname(__FILE__), "..", "etc", "basic.html"))
+      basic_graph = RDF::Graph.new
+      RDF::RDFa::Reader.new(basic,
+                  :base_uri => "http://www.w3.org/2007/08/pyRdfa/profiles/basic").each do |statement|
+        basic_graph << statement
+      end
+      
+      RDF::Graph.stub!(:load).with("http://www.w3.org/2007/08/pyRdfa/profiles/basic",
+                      :base_uri => "http://www.w3.org/2007/08/pyRdfa/profiles/basic",
+                      :format => :rdfa).and_return(basic_graph)
+
+      @graph = parse(sampledoc, :strict => true)
+      @statement = @graph.statements.first
+    end
+
+    it "should return 1 triple" do
+      @graph.size.should == 1
+    end
+
+    it "should have a subject of http://example.org/#me" do
+      @statement.subject.should == RDF::URI('http://example.org/#me')
+    end
+
+    it "should have a predicate of foaf:name" do
+      @statement.predicate.should == RDF::FOAF.name
+    end
+
+    it "should have an object with the literal 'Ivan Herman'" do
+      @statement.object.should == RDF::Literal('Ivan Herman')
+    end
   end
 
+  context "parsing a document with a profile containing a term mapping" do
+    before :each do
+      sampledoc = <<-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" version="XHTML+RDFa 1.0">
+  <head>
+    <title>Test</title>
+    <base href="http://example.org/"/>
+  </head>
+  <body profile="http://www.w3.org/2007/08/pyRdfa/profiles/foaf">
+  <div about="#me">
+    <p>
+      <span property="name">Ivan Herman</span>
+    </p>
+  </div>
+  </body>
+</html>
+EOF
+      
+      foaf = File.open(File.join(File.dirname(__FILE__), "..", "etc", "foaf.html"))
+      foaf_graph = RDF::Graph.new
+      RDF::RDFa::Reader.new(foaf,
+                  :base_uri => "http://www.w3.org/2007/08/pyRdfa/profiles/foaf").each do |statement|
+        foaf_graph << statement
+      end
+      
+      RDF::Graph.stub!(:load).with("http://www.w3.org/2007/08/pyRdfa/profiles/foaf",
+                      :base_uri => "http://www.w3.org/2007/08/pyRdfa/profiles/foaf",
+                      :format => :rdfa).and_return(foaf_graph)
+
+      @graph = parse(sampledoc, :strict => true)
+      @statement = @graph.statements.first
+    end
+
+    it "should return 1 triple" do
+      @graph.size.should == 1
+    end
+
+    it "should have a subject of http://example.org/#me" do
+      @statement.subject.should == RDF::URI('http://example.org/#me')
+    end
+
+    it "should have a predicate of foaf:name" do
+      @statement.predicate.should == RDF::FOAF.name
+    end
 
-  it "should parse BNodes" do
-    sampledoc = <<-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:foaf="http://xmlns.com/foaf/0.1/">
-      <head>
-    	<title>Test 0017</title>   
-      </head>
-      <body>
-      	 <p>
-            <span about="[_:a]" property="foaf:name">Manu Sporny</span>
-            <span about="[_:a]" rel="foaf:knows" resource="[_:b]">knows</span>
-            <span about="[_:b]" property="foaf:name">Ralph Swick</span>.
-         </p>
-      </body>
-    </html>
-    EOF
-
-    reader = RDF::RDFa::Reader.new(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml", :strict => true)
-
-    reader.graph.size.should == 3
-    reader.graph.should have_object("Ralph Swick")
-    reader.graph.should have_object("Manu Sporny")
+    it "should have an object with the literal 'Ivan Herman'" do
+      @statement.object.should == RDF::Literal('Ivan Herman')
+    end
   end
-  
-   def self.test_cases(suite)
+
+  def self.test_cases(suite)
      [] #RdfaHelper::TestCase.test_cases(suite)
+  end
+
+  # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
+  %w(xhtml html4 html5).each do |suite|
+    describe "w3c #{suite} testcases" do
+      describe "that are approved" do
+        test_cases(suite).each do |t|
+          puts t.inspect
+          next unless t.status == "approved"
+          #next unless t.name =~ /0140/
+          specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
+            #puts t.input
+            #puts t.results
+            begin
+              t.run_test do |rdfa_string, rdfa_parser|
+                rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
+              end
+            rescue SparqlException => e
+              pending(e.message) { raise }
+            end
+          end
+        end
+      end
+      describe "that are unreviewed" do
+        test_cases(suite).each do |t|
+          next unless t.status == "unreviewed"
+          #next unless t.name =~ /0185/
+          #puts t.inspect
+          specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
+            begin
+              t.run_test do |rdfa_string, rdfa_parser|
+                rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
+              end
+            rescue SparqlException => e
+              pending(e.message) { raise }
+            rescue Spec::Expectations::ExpectationNotMetError => e
+              if t.name =~ /01[789]\d/
+                raise
+              else
+                pending() {  raise }
+              end
+            end
+          end
+        end
+      end
    end
+ end
 
-   # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
-   %w(xhtml html4 html5).each do |suite|
-     describe "w3c #{suite} testcases" do
-       describe "that are approved" do
-         test_cases(suite).each do |t|
-           puts t.inspect
-           next unless t.status == "approved"
-           #next unless t.name =~ /0140/
-           specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
-             #puts t.input
-             #puts t.results
-             begin
-               t.run_test do |rdfa_string, rdfa_parser|
-                 rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
-               end
-             rescue SparqlException => e
-               pending(e.message) { raise }
-             end
-           end
-         end
-       end
-       describe "that are unreviewed" do
-         test_cases(suite).each do |t|
-           next unless t.status == "unreviewed"
-           #next unless t.name =~ /0185/
-           #puts t.inspect
-           specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
-             begin
-               t.run_test do |rdfa_string, rdfa_parser|
-                 rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
-               end
-             rescue SparqlException => e
-               pending(e.message) { raise }
-             rescue Spec::Expectations::ExpectationNotMetError => e
-               if t.name =~ /01[789]\d/
-                 raise
-               else
-                 pending() {  raise }
-               end
-             end
-           end
-         end
-       end
+  def parse(input, options)
+    @debug = []
+    graph = RDF::Graph.new
+    RDF::RDFa::Reader.new(input, options.merge(:debug => @debug)).each do |statement|
+      graph << statement
     end
+    graph
   end
-end
+
+end