RubyGems - rdf-rdfa - Versions diffs - 0.3.4.2 → 0.3.5.1 - Mend

rdf-rdfa 0.3.4.2 → 0.3.5.1

Files changed (40) hide show

data/VERSION +1 -1
data/lib/rdf/rdfa/reader.rb +6 -6
data/lib/rdf/rdfa/writer.rb +29 -13
data/lib/rdf/rdfa/writer/haml_templates.rb +3 -0
metadata +111 -240
data/.yardopts +0 -13
data/CONTRIBUTORS +0 -1
data/Gemfile +0 -19
data/History.md +0 -98
data/README.md +0 -311
data/Rakefile +0 -64
data/etc/basic.html +0 -15
data/etc/foaf.html +0 -83
data/etc/profile.html +0 -40
data/etc/xhv.html +0 -459
data/example-files/bb-test.rb +0 -14
data/example-files/best-buy.html +0 -3203
data/example-files/data-view.xhtml +0 -369
data/example-files/erdf_profile.html +0 -116
data/example-files/gk-foaf.html +0 -283
data/example-files/payswarm.html +0 -449
data/example-files/payswarm.n3 +0 -86
data/example.rb +0 -23
data/lib/rdf/.gitignore +0 -2
data/pkg/.gitignore +0 -1
data/rdf-rdfa.gemspec +0 -163
data/script/console +0 -10
data/script/intern_vocabulary +0 -99
data/script/parse +0 -91
data/script/tc +0 -115
data/script/yard-to-rubyforge +0 -2
data/spec/.gitignore +0 -1
data/spec/literal_spec.rb +0 -244
data/spec/matchers.rb +0 -108
data/spec/profile_spec.rb +0 -68
data/spec/reader_spec.rb +0 -572
data/spec/spec.opts +0 -1
data/spec/spec_helper.rb +0 -46
data/spec/test_helper.rb +0 -97
data/spec/writer_spec.rb +0 -410

@@ -1,68 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-describe RDF::RDFa::Profile do
-  describe ".new" do
-    describe "foaf" do
-      subject { RDF::RDFa::Profile.new("http://example/") }
-      it "has a URI" do
-        subject.uri.should == RDF::URI("http://example/")
-      end
-      it "has no terms" do
-        subject.terms.should be_empty
-      end
-      it "has no vocabulary" do
-        subject.vocabulary.should be_nil
-      end
-      it "has no prefixes" do
-        subject.prefixes.should be_empty
-      end
-    end
-  end
-  describe ".find" do
-    describe "foaf" do
-      subject { RDF::RDFa::Profile.find("http://rdfa.digitalbazaar.com/test-suite/profiles/foaf") }
-      it "has 74 terms" do
-        subject.terms.keys.length.should == 74
-      end
-      it "uses symbols for term lookup" do
-        subject.terms.keys.all? {|k| k.is_a?(Symbol)}.should be_true
-      end
-      it "has no vocabulary" do
-        subject.vocabulary.should be_nil
-      end
-      it "has no prefixes" do
-        subject.prefixes.should be_empty
-      end
-    end
-    describe "basic" do
-      subject { RDF::RDFa::Profile.find("http://rdfa.digitalbazaar.com/test-suite/profiles/basic") }
-      it "has no terms" do
-        subject.terms.should be_empty
-      end
-      it "has no vocabulary" do
-        subject.vocabulary.should be_nil
-      end
-      it "has 6 prefixes" do
-        subject.prefixes.keys.length.should == 6
-      end
-      it "uses symbols for prefix lookup" do
-        subject.prefixes.keys.all? {|k| k.is_a?(Symbol)}.should be_true
-      end
-    end
-  end
-end

data/spec/reader_spec.rb DELETED

@@ -1,572 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-describe RDF::RDFa::Format do
-  context "should be discover 'rdfa'" do
-    [
-      [:rdfa,                                        RDF::RDFa::Format],
-      ["etc/foaf.html",                              RDF::RDFa::Format],
-      [{:file_name      => "etc/foaf.html"},         RDF::RDFa::Format],
-      [{:file_extension => "html"},                  RDF::RDFa::Format],
-      [{:file_extension => "xhtml"},                 RDF::RDFa::XHTML],
-      [{:file_extension => "svg"},                   RDF::RDFa::SVG],
-      [{:content_type   => "text/html"},             RDF::RDFa::Format],
-      [{:content_type   => "application/xhtml+xml"}, RDF::RDFa::XHTML],
-      [{:content_type   => "image/svg+xml"},         RDF::RDFa::SVG],
-    ].each do |(arg, format)|
-      it "returns #{format} for #{arg.inspect}" do
-        RDF::Format.for(arg).should == format
-      end
-    end
-  end
-  it "should discover 'html'" do
-    RDF::Format.for(:html).reader.should == RDF::RDFa::Reader
-    RDF::Format.for(:html).writer.should == RDF::RDFa::Writer
-  end
-  it "should discover 'xhtml'" do
-    RDF::Format.for(:xhtml).reader.should == RDF::RDFa::Reader
-    RDF::Format.for(:xhtml).writer.should == RDF::RDFa::Writer
-  end
-  it "should discover 'svg'" do
-    RDF::Format.for(:svg).reader.should == RDF::RDFa::Reader
-    RDF::Format.for(:svg).writer.should == RDF::RDFa::Writer
-  end
-end
-describe "RDF::RDFa::Reader" do
-  describe "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
-  describe :interface do
-    before(:each) do
-      @sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.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>
-        )
-    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
-  describe "parsing a simple doc" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.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>
-        )
-      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0001.xhtml", :validate => 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
-  describe "parsing a simple doc without a base URI" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.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>
-        )
-      @graph = parse(sampledoc, :validate => 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
-  describe "parsing a document containing an XML Literal" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml"
-              xmlns:dc="http://purl.org/dc/elements/1.1/"
-              xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-          <head>
-            <title>Test 0011</title>
-          </head>
-          <body>
-            <div about="">
-              Author: <span property="dc:creator">Albert Einstein</span>
-              <h2 property="dc:title" datatype="rdf:XMLLiteral">E = mc<sup>2</sup>: The Most Urgent Problem of Our Time</h2>
-          </div>
-          </body>
-        </html>
-        )
-      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0011.xhtml", :validate => 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
-      begin
-        @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 xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">2</sup>: The Most Urgent Problem of Our Time), :datatype => RDF.XMLLiteral)
-        ])
-      rescue RSpec::Expectations::ExpectationNotMetError => e
-        pending("XMLLiteral canonicalization not implemented yet")
-      end
-    end
-  end
-  describe "parsing a document containing sereral bnodes" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1"
-              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>
-        )
-      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0017.xhtml", :validate => 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
-  describe "parsing a document that uses the typeof attribute" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1"
-              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>
-        )
-      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0049.xhtml", :validate => 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
-  describe "parsing a document with a <base> tag in the <head>" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1"
-            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>
-        )
-      @graph = parse(sampledoc, :base_uri => "http://rdfa.digitalbazaar.com/test-suite/test-cases/xhtml1/0072.xhtml", :validate => 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
-  describe "parsing a document with a profile containing a prefix mapping" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1">
-          <head>
-            <title>Test</title>
-            <base href="http://example.org/"/>
-          </head>
-          <body profile="http://rdfa.digitalbazaar.com/test-suite/test-cases/tests/../../profiles/basic">
-          <div about="#me">
-            <p>
-              <span property="foaf:name">Ivan Herman</span>
-            </p>
-          </div>
-          </body>
-        </html>
-        )
-      @graph = parse(sampledoc, :validate => 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
-  describe "parsing a document with a profile containing a term mapping" do
-    before :each do
-      sampledoc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1">
-          <head>
-            <title>Test</title>
-            <base href="http://example.org/"/>
-          </head>
-          <body profile="http://rdfa.digitalbazaar.com/test-suite/test-cases/tests/../../profiles/foaf">
-          <div about="#me">
-            <p>
-              <span property="name">Ivan Herman</span>
-            </p>
-          </div>
-          </body>
-        </html>
-      )
-      @graph = parse(sampledoc, :validate => 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
-  describe :profiles do
-    before(:each) do
-      @profile = StringIO.new(%q(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html>
-        <html xmlns="http://www.w3.org/1999/xhtml">
-          <head>
-            <title>Test mappings</title>
-          </head>
-          <body prefix="rdfa: http://www.w3.org/ns/rdfa#">
-            <p typeof=""><span property="rdfa:uri">http://example.org/</span><span property="rdfa:prefix">foo</span></p>
-            <p typeof=""><span property="rdfa:uri">http://example.org/title</span><span property="rdfa:term">title</span></p>
-          </body>
-        </html>
-      ))
-      def @profile.content_type; "text/html"; end
-      def @profile.base_uri; "http://example.com/profile"; end
-      @doc = %(<?xml version="1.0" encoding="UTF-8"?>
-        <!DOCTYPE html>
-        <html xmlns="http://www.w3.org/1999/xhtml">
-          <body profile="http://example.com/profile">
-            <div about="http://example.com/doc" typeof="foo:Agent">
-              <p property="title">A particular agent</p>
-            </div>
-          </body>
-        </html>
-        )
-      RDF::Util::File.stub!(:open_file).and_yield(@profile)
-      @profile_repository = RDF::Repository.new(:title => "Test Profile Repository")
-      @debug = []
-      @reader = RDF::RDFa::Reader.new(@doc, :profile_repository => @profile_repository, :debug => @debug, :validate => true)
-      @expected = RDF::Graph.new
-      @expected << [RDF::URI("http://example.com/doc"), RDF.type, RDF::URI("http://example.org/Agent")]
-      @expected << [RDF::URI("http://example.com/doc"), RDF::URI("http://example.org/title"), "A particular agent"]
-    end
-    it "parses profile" do
-      RDF::Reader.should_receive(:for).at_least(1).times.and_return(RDF::RDFa::Reader)
-      g = RDF::Graph.load(@profile)
-      g.count.should == 4
-    end
-    describe "new profile" do
-      subject do
-        # Clear vocabulary cache
-        RDF::RDFa::Profile.cache.send(:initialize)
-        RDF::Graph.new << @reader
-      end
-      it "matches expected" do
-        subject.should be_equivalent_graph(@expected, :trace => @debug.join("\n"))
-      end
-    end
-    describe "cached profile" do
-      before(:each) do
-        # Clear vocabulary cache
-        RDF::RDFa::Profile.cache.send(:initialize)
-        @reader.each {|s|}
-      end
-      it "should not re-parse profile" do
-        RDF::RDFa::Profile.cache.send(:initialize)
-        RDF::Reader.should_not_receive(:open).with("http://example.com/profile")
-        RDF::RDFa::Reader.new(@doc, :profile_repository => @profile_repository).each {|p|}
-      end
-      it "should create vocab_cache" do
-        RDF::RDFa::Profile.cache.should be_a(RDF::Util::Cache)
-      end
-    end
-    describe "profile content" do
-      before(:each) do
-        bn_p = RDF::Node.new("prefix")
-        bn_t = RDF::Node.new("term")
-        ctx = RDF::URI("http://example.com/profile")
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.prefix, RDF::Literal.new("foo"), :context => ctx)
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.uri, RDF::Literal.new("http://example.org/"), :context => ctx)
-        @profile_repository << RDF::Statement.new(bn_t, RDF::RDFA.term, RDF::Literal.new("title"), :context => ctx)
-        @profile_repository << RDF::Statement.new(bn_t, RDF::RDFA.uri, RDF::Literal.new("http://example.org/title"), :context => ctx)
-        # Clear vocabulary cache
-        RDF::RDFa::Profile.cache.send(:initialize)
-      end
-      it "should not recieve RDF::Reader.open" do
-        RDF::Reader.should_not_receive(:open).with("http://example.com/profile")
-        @reader.each {|s|}
-      end
-      it "matches expected" do
-        graph = RDF::Graph.new << @reader
-        graph.should be_equivalent_graph(@expected, :trace => @debug.join("\n"))
-      end
-    end
-  end
-  # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
-  describe "w3c test cases" do
-    require 'test_helper'
-    Fixtures::TestCase::HOST_LANGUAGE_VERSION_SETS.each do |(host_language, version)|
-      describe "for #{host_language} #{version}" do
-        %w(required optional buggy).each do |classification|
-          describe "that are #{classification}" do
-            Fixtures::TestCase.for_specific(host_language, version, Fixtures::TestCase::Test.send(classification)) do |t|
-              specify "test #{t.name}: #{t.title}#{",  (negative test)" if t.expectedResults.false?}" do
-                begin
-                  t.debug = []
-                  reader = RDF::Reader.open(t.input(host_language, version),
-                    :base_uri => t.input(host_language, version),
-                    :debug => t.debug,
-                    :format => :rdfa)
-                  reader.should be_a RDF::Reader
-                  # Make sure auto-detect works
-                  unless host_language =~ /svg/ || t.name == "0216" # due to http-equiv
-                    reader.host_language.should == host_language.to_sym
-                    reader.version.should == version.to_sym
-                  end
-                  graph = RDF::Graph.new << reader
-                  query = Kernel.open(t.results(host_language, version))
-                  graph.should pass_query(query, t)
-                rescue RSpec::Expectations::ExpectationNotMetError => e
-                  if %w(0198).include?(t.name) || query =~ /XMLLiteral/m
-                    pending("XMLLiteral canonicalization not implemented yet")
-                  elsif classification != "required"
-                    pending("#{classification} test") {  raise }
-                  else
-                    raise
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-  def parse(input, options)
-    @debug = options[:debug] || []
-    graph = RDF::Graph.new
-    RDF::RDFa::Reader.new(input, options.merge(:debug => @debug)).each do |statement|
-      graph << statement
-    end
-    graph
-  end
-end