rdf-rdfa 0.3.1.2 → 0.3.3

data/spec/profile_spec.rb

@@ -4,50 +4,65 @@ 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://rdfa.digitalbazaar.com/test-suite/profiles/foaf") }
+      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.new("http://rdfa.digitalbazaar.com/test-suite/profiles/basic") }
-      
+      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
-    end
-  end
-  
-  describe ".find" do
-    before(:all) do
-      RDF::RDFa::Profile.find("http://rdfa.digitalbazaar.com/test-suite/profiles/basic")
-      RDF::RDFa::Profile.find("http://rdfa.digitalbazaar.com/test-suite/profiles/foaf")
-    end
-    
-    it "cached basic" do
-      RDF::RDFa::Profile.cache[RDF::URI.intern("http://rdfa.digitalbazaar.com/test-suite/profiles/basic")].should be_a(RDF::RDFa::Profile)
-    end
-    
-    it "cached foaf" do
-      RDF::RDFa::Profile.cache[RDF::URI.intern("http://rdfa.digitalbazaar.com/test-suite/profiles/foaf")].should be_a(RDF::RDFa::Profile)
+
+      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/{rdfa_reader_spec.rb → reader_spec.rb}

@@ -1,36 +1,38 @@
 $:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
-require 'rdfa_helper'
 
 describe RDF::RDFa::Format do
-  it "should be discover 'rdfa'" do
-    formats = [
-      RDF::Format.for(:rdfa),
-      RDF::Format.for("etc/foaf.html"),
-      RDF::Format.for(:file_name      => "etc/foaf.html"),
-      RDF::Format.for(:file_extension => "html"),
-      RDF::Format.for(:file_extension => "xhtml"),
-      RDF::Format.for(:file_extension => "svg"),
-      RDF::Format.for(:content_type   => "text/html"),
-      RDF::Format.for(:content_type   => "application/xhtml+xml"),
-      RDF::Format.for(:content_type   => "image/svg+xml"),
-    ]
-    formats.each { |format| format.should == RDF::RDFa::Format }
+  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
+    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
+    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
+    RDF::Format.for(:svg).writer.should == RDF::RDFa::Writer
   end
 end
 
@@ -414,64 +416,59 @@ describe "RDF::RDFa::Reader" do
   end
 
   describe :profiles do
-    before(:all) do
-      FileUtils.mkdir(TMP_DIR)
-      File.open(File.join(TMP_DIR, "profile.html"), "w") do |f|
-        f.write(%(<?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">#{RDF::DC}</span><span property="rdfa:prefix">dc</span></p>
-              <p typeof=""><span property="rdfa:uri">#{RDF::DC.title}</span><span property="rdfa:term">title</span></p>
-            </body>
-          </html>
-          )
-        )
-      end
-
+    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="dc:Agent">
+            <div about="http://example.com/doc" typeof="foo:Agent">
               <p property="title">A particular agent</p>
             </div>
           </body>
         </html>
         )
-    end
 
-    before(:each) do
+      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
-    
-    after(:all) do
-      FileUtils.rm_rf(TMP_DIR)
+
+    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
-      before(:each) do
+      subject do
         # Clear vocabulary cache
         RDF::RDFa::Profile.cache.send(:initialize)
-        @graph = RDF::Graph.new
-        @reader.each do |statement|
-          @graph << statement
-        end
+        RDF::Graph.new << @reader
       end
       
-      describe "processed graph" do
-        it "should have type dc:Agent" do
-          @graph.should have_statement(RDF::Statement.new(RDF::URI.new("http://example.com/doc"), RDF.type, RDF::DC.Agent))
-        end
-      
-        it "should have property dc:title" do
-          @graph.should have_statement(RDF::Statement.new(RDF::URI.new("http://example.com/doc"), RDF::DC.title, RDF::Literal.new("A particular agent")))
-        end
+      it "matches expected" do
+        subject.should be_equivalent_graph(@expected, :trace => @debug.join("\n"))
       end
     end
     
@@ -497,10 +494,11 @@ describe "RDF::RDFa::Reader" do
       before(:each) do
         bn_p = RDF::Node.new("prefix")
         bn_t = RDF::Node.new("term")
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.prefix, RDF::Literal.new("dc"))
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.uri, RDF::Literal.new(RDF::DC.to_s))
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.term, RDF::Literal.new("title"))
-        @profile_repository << RDF::Statement.new(bn_p, RDF::RDFA.uri, RDF::Literal.new(RDF::DC.title.to_s))
+        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)
@@ -508,118 +506,47 @@ describe "RDF::RDFa::Reader" do
 
       it "should not recieve RDF::Reader.open" do
         RDF::Reader.should_not_receive(:open).with("http://example.com/profile")
+        @reader.each {|s|}
       end
 
-      it "should have type dc:Agent" do
-        @graph = RDF::Graph.new
-        @reader.each do |statement|
-          @graph << statement
-        end
-
-        @graph.should have_statement(RDF::Statement.new(RDF::URI.new("http://example.com/doc"), RDF.type, RDF::DC.Agent))
-      end
-    
-      it "should have property dc:title" do
-        @graph = RDF::Graph.new
-        @reader.each do |statement|
-          @graph << statement
-        end
-
-        @graph.should have_statement(RDF::Statement.new(RDF::URI.new("http://example.com/doc"), RDF::DC.title, RDF::Literal.new("A particular agent")))
+      it "matches expected" do
+        graph = RDF::Graph.new << @reader
+        graph.should be_equivalent_graph(@expected, :trace => @debug.join("\n"))
       end
     end
   end
   
-  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 html5 html5 svgtiny).each do |suite| # html4 html5
-    describe "w3c #{suite} testcases" do
-      describe "that are required" do
-        test_cases(suite).each do |t|
-          next unless t.classification =~ /required/
-          #next unless t.name =~ /0001/
-          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|
-                t.debug = []
-                parse(rdfa_string,
-                    :base_uri => t.informationResourceInput,
-                    :debug => t.debug,
-                    :version => t.version)
-              end
-            rescue RSpec::Expectations::ExpectationNotMetError => e
-              if t.input =~ /XMLLiteral/
-                pending("XMLLiteral canonicalization not implemented yet")
-              else
-                raise
-              end
-            rescue SparqlException => e
-              pending(e.message) { raise }
-            end
-          end
-        end
-      end
-
-      describe "that are optional" do
-        test_cases(suite).each do |t|
-          next unless t.classification =~ /optional/
-          #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|
-                t.debug = []
-                parse(rdfa_string,
-                    :base_uri => t.informationResourceInput,
-                    :debug => t.debug,
-                    :version => t.version)
-              end
-            rescue SparqlException => e
-              pending(e.message) { raise }
-            rescue RSpec::Expectations::ExpectationNotMetError => e
-              if t.name =~ /01[789]\d/
-                raise
-              else
-                pending() {  raise }
-              end
-            end
-          end
-        end
-      end
-
-      describe "that are buggy" do
-        test_cases(suite).each do |t|
-          next unless t.classification =~ /buggy/
-          #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|
-                t.debug = []
-                parse(rdfa_string,
-                    :base_uri => t.informationResourceInput,
-                    :debug => t.debug,
-                    :version => t.version)
-              end
-            rescue SparqlException => e
-              pending(e.message) { raise }
-            rescue RSpec::Expectations::ExpectationNotMetError => e
-              if t.name =~ /01[789]\d/
-                raise
-              else
-                pending() {  raise }
+  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 = []
+                  graph = RDF::Graph.load(t.input(host_language, version), :debug => t.debug, :format => :rdfa)
+                  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
+    end
+  end
 
   def parse(input, options)
     @debug = options[:debug] || []

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $:.unshift File.dirname(__FILE__)
 
+require "bundler/setup"
 require 'rubygems'
 require 'rspec'
 require 'bigdecimal'  # XXX Remove Me
@@ -8,34 +9,13 @@ require 'rdf/rdfa'
 require 'rdf/spec'
 require 'rdf/spec/matchers'
 require 'rdf/isomorphic'
-
-begin
-  require 'rdf/redland'
-  $redland_enabled = true
-rescue LoadError
-end
+require 'open-uri/cached'
 require 'matchers'
 
-include Matchers
-
-module RDF
-  module Isomorphic
-    alias_method :==, :isomorphic_with?
-  end
-  class Graph
-    def to_ntriples
-      RDF::Writer.for(:ntriples).buffer do |writer|
-        writer << self
-      end
-    end
-
-    def to_rdfxml
-      RDF::Writer.for(:rdfxml).buffer do |writer|
-        writer << self
-      end
-    end
-  end
-end
+# Create and maintain a cache of downloaded URIs
+URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
+Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
+OpenURI::Cache.class_eval { @cache_path = URI_CACHE }
 
 ::RSpec.configure do |c|
   c.filter_run :focus => true
@@ -43,7 +23,6 @@ end
   c.exclusion_filter = {
     :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
   }
-  c.include(Matchers)
   c.include(RDF::Spec::Matchers)
 end
 
@@ -60,8 +39,6 @@ def detect_format(stream)
     string = stream.to_s
   end
   case string
-  when /<\w+:RDF/ then RDF::RDFXML::Reader
-  when /<RDF/     then RDF::RDFXML::Reader
   when /<html/i   then RDF::RDFa::Reader
   when /@prefix/i then RDF::N3::Reader
   else                 RDF::NTriples::Reader