rdf_context 0.4.8 → 0.5.0

data/spec/namespaces_spec.rb

@@ -66,6 +66,32 @@ describe "Namespace" do
     end
   end
   
+  describe "normalization" do
+    {
+      %w(http://foo ) =>  "http://foo",
+      %w(http://foo a) => "http://fooa",
+
+      %w(http://foo/ ) =>  "http://foo/",
+      %w(http://foo/ a) => "http://foo/a",
+
+      %w(http://foo# ) =>  "http://foo#",
+      %w(http://foo# a) => "http://foo#a",
+
+      %w(http://foo/bar ) =>  "http://foo/bar",
+      %w(http://foo/bar a) => "http://foo/bara",
+
+      %w(http://foo/bar/ ) =>  "http://foo/bar/",
+      %w(http://foo/bar/ a) => "http://foo/bar/a",
+
+      %w(http://foo/bar# ) =>  "http://foo/bar#",
+      %w(http://foo/bar# a) => "http://foo/bar#a",
+    }.each_pair do |input, result|
+      it "should create <#{result}> from <#{input[0]}> and '#{input[1]}'" do
+        (Namespace.new(input[0], "test") + input[1].to_s).should == result
+      end
+    end
+  end
+
   it "should be be equivalent" do
     Namespace.new("http://a", "aa").should == Namespace.new("http://a", "aa")
   end

data/spec/rdf_helper.rb

@@ -0,0 +1,197 @@
+module RdfHelper
+  # Class representing test cases in format http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#
+  class TestCase
+    include Matchers
+    MF_NS = Namespace.new("http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#", "mf")
+    QT_NS = Namespace.new("http://www.w3.org/2001/sw/DataAccess/tests/test-query#", "qt")
+    
+    attr_accessor :about
+    attr_accessor :approval
+    attr_accessor :conclusionDocument
+    attr_accessor :data
+    attr_accessor :description
+    attr_accessor :discussion
+    attr_accessor :document
+    attr_accessor :entailmentRules
+    attr_accessor :inputDocument
+    attr_accessor :issue
+    attr_accessor :name
+    attr_accessor :outputDocument
+    attr_accessor :premiseDocument
+    attr_accessor :rdf_type
+    attr_accessor :status
+    attr_accessor :warning
+    attr_accessor :parser
+    attr_accessor :compare
+    
+    def initialize(triples, uri_prefix, test_dir, options = {})
+      case options[:test_type]
+      when :mf
+        parse_mf(triples, uri_prefix, test_dir, options[:graph])
+      else
+        parse_w3c(triples, uri_prefix, test_dir)
+      end
+    end
+    
+    def parse_w3c(triples, uri_prefix, test_dir)
+      triples.each do |statement|
+        next if statement.subject.is_a?(BNode)
+        
+        if statement.is_type?
+          self.rdf_type = statement.object.short_name
+        elsif statement.predicate.short_name =~ /Document\Z/i
+          puts "#{statement.predicate.short_name}: #{statement.object.inspect}" if $DEBUG
+          self.send("#{statement.predicate.short_name}=", statement.object.to_s.sub(uri_prefix, test_dir))
+          puts "#{statement.predicate.short_name}: " + self.send("#{statement.predicate.short_name}") if $DEBUG
+          if statement.predicate.short_name == "inputDocument"
+            self.about ||= statement.object
+            self.name ||= statement.subject.short_name
+          end
+        elsif statement.predicate.short_name == "referenceOutput"
+          puts "referenceOutput: #{statement.object.inspect}" if $DEBUG
+          outputDocument = statement.object.to_s.sub(uri_prefix, test_dir)
+          puts "referenceOutput: " + self.send("#{statement.predicate.short_name}") if $DEBUG
+        elsif self.respond_to?("#{statement.predicate.short_name}=")
+          self.send("#{statement.predicate.short_name}=", statement.object.to_s)
+        end
+      end
+    end
+
+    def parse_mf(subject, uri_prefix, test_dir, graph)
+      props = graph.properties(subject)
+      @name = (props[MF_NS.name.to_s] || []).first.to_s
+      @description =  (props[RDFS_NS.comment.to_s] || []).first.to_s
+      @outputDocument = (props[MF_NS.result.to_s] || []).first
+      @outputDocument = @outputDocument.to_s.sub(uri_prefix, test_dir) if @outputDocument
+      action = (props[MF_NS.action.to_s] || []).first
+      a_props = graph.properties(action)
+      @about = (a_props[QT_NS.data.to_s] || []).first
+      @inputDocument = @about.to_s.sub(uri_prefix, test_dir)
+    end
+    
+    def inspect
+      "[Test Case " + %w(
+        about
+        name
+        inputDocument
+        outputDocument
+        issue
+        status
+        approval
+        description
+        discussion
+        issue
+        warning
+      ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
+      "]"
+    end
+    
+    # Read in file, and apply modifications reference either .html or .xhtml
+    def input
+      @input ||= File.read(inputDocument)
+    end
+
+    def output
+      @output ||= outputDocument && File.read(outputDocument)
+    end
+
+    # Run test case, yields input for parser to create triples
+    def run_test(options = {})
+      rdf_string = input
+
+      # Run
+      @parser = Parser.new
+      yield(rdf_string, @parser)
+
+      return unless output
+
+      if self.compare == :array
+        @parser.graph.should be_equivalent_graph(self.output, self)
+      else
+        output_parser = Parser.new
+        output_fmt = output_parser.detect_format(self.output, self.outputDocument)
+        output_parser.parse(self.output, about, :type => output_fmt)
+
+        @parser.graph.should be_equivalent_graph(output_parser, self)
+      end
+    end
+
+    def trace
+      @parser.debug.to_a.join("\n")
+    end
+    
+    def self.parse_test_cases(test_uri = nil, test_dir = nil)
+      raise "Missing test_uri" unless test_uri
+      raise "Missing test_dir" unless test_dir
+      @test_cases = [] unless test_uri == @test_uri
+      return unless @test_cases.empty?
+
+      test = test_uri.to_s.split('/').last
+      test_dir = test_dir + "/" unless test_dir.match(%r(/$))
+      
+      @positive_parser_tests = []
+      @negative_parser_tests = []
+      @positive_entailment_tests = []
+      @negative_entailment_tests = []
+
+      manifest = File.read(File.join(test_dir, test))
+      parser = Parser.new
+      begin
+        puts "parse <#{test_uri}>" if $DEBUG
+        parser.parse(manifest, test_uri)
+      rescue
+        raise "Parse error: #{$!}\n\t#{parser.debug.join("\t\n")}\n\n"
+      end
+      graph = parser.graph
+      
+      uri_base = Addressable::URI.join(test_uri, ".").to_s
+
+      # If this is a turtle test (type mf:Manifest) parse with
+      # alternative test case
+      case graph.type_of(test_uri).first
+      when MF_NS.Manifest
+        # Get test entries
+        entries = graph.triples(Triple.new(test_uri, MF_NS.entries, nil)) || []
+        entries = entries.first
+        raise "No entires found for MF Manifest" unless entries.is_a?(Triple)
+        
+        @test_cases = graph.seq(entries.object).map do |subject|
+          TestCase.new(subject, uri_base, test_dir, :test_type => :mf, :graph => graph)
+        end
+      else
+        # One of:
+        #   http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema
+        #   http://www.w3.org/2000/10/swap/test.n3#
+        #   http://www.w3.org/2004/11/n3test#
+        # Group by subject
+        test_hash = graph.triples.inject({}) do |hash, st|
+          a = hash[st.subject] ||= []
+          a << st
+          hash
+        end
+
+        @test_cases = test_hash.values.map do |statements|
+          TestCase.new(statements, uri_base, test_dir)
+        end
+     end.
+      compact.
+      sort_by{|t| t.name.to_s}
+
+
+     @test_cases.each do |tc|
+       next if tc.status && tc.status != "APPROVED"
+       case tc.rdf_type
+       when "PositiveParserTest" then @positive_parser_tests << tc
+       when "NegativeParserTest" then @negative_parser_tests << tc
+       when "PositiveEntailmentTest" then @positive_entailment_tests << tc
+       when "NegativeEntailmentTest" then @negative_entailment_tests << tc
+       end
+     end
+    end
+    def self.test_cases(test_uri = nil, test_dir = nil);                parse_test_cases(test_uri, test_dir); @test_cases; end
+    def self.positive_parser_tests(test_uri = nil, test_dir = nil);     parse_test_cases(test_uri, test_dir); @positive_parser_tests; end
+    def self.negative_parser_tests(test_uri = nil, test_dir = nil);     parse_test_cases(test_uri, test_dir); @negative_parser_tests; end
+    def self.positive_entailment_tests(test_uri = nil, test_dir = nil); parse_test_cases(test_uri, test_dir); @positive_entailment_tests; end
+    def self.negative_entailment_tests(test_uri = nil, test_dir = nil); parse_test_cases(test_uri, test_dir); @negative_entailment_tests; end
+  end
+end

data/spec/rdfa_helper.rb

@@ -1,5 +1,3 @@
-require 'matchers'
-
 module RdfaHelper
   # Class representing test cases in format http://www.w3.org/2006/03/test-description#
   class TestCase
@@ -26,7 +24,6 @@ module RdfaHelper
     attr_accessor :expectedResults
     attr_accessor :parser
     
-    @@test_cases = []
     @@suite = ""
     
     def initialize(statements, suite)
@@ -70,6 +67,8 @@ module RdfaHelper
       reviewStatus.to_s.split("#").last
     end
     
+    def compare; :graph; end
+    
     def information
       %w(purpose specificationReference).map {|a| v = self.send(a); "#{a}: #{v}" if v}.compact.join("\n")
     end
@@ -80,7 +79,7 @@ module RdfaHelper
     
     # Read in file, and apply modifications to create a properly formatted HTML
     def input
-      f = self.name + ".txt"
+      f = self.inputDocument
       found_head = false
       namespaces = ""
       body = File.readlines(File.join(TEST_DIR, "tests", f)).map do |line|
@@ -130,6 +129,9 @@ module RdfaHelper
       suite == "xhtml" ? body : body.gsub(HTMLRE, '\1.html')
     end
     
+    def inputDocument; self.name + ".txt"; end
+    def outputDocument; self.name + ".sparql"; end
+
     # Run test case, yields input for parser to create triples
     def run_test
       rdfa_string = input
@@ -145,9 +147,11 @@ module RdfaHelper
       if (query_string.match(/UNION|OPTIONAL/) || title.match(/XML/)) && triples
         # Check triples, as Rasql doesn't implement UNION
         @parser.graph.should be_equivalent_graph(triples, self)
-      else
+      elsif $redland_enabled
         # Run SPARQL query
         @parser.graph.should pass_query(query_string, self)
+      else
+        #pending("Query skipped, Redland not installed")
       end
 
       @parser.graph.to_rdfxml.should be_valid_xml
@@ -158,17 +162,17 @@ module RdfaHelper
     end
     
     def self.test_cases(suite)
-      @@test_cases = [] unless @@suite == suite
-      return @@test_cases unless @@test_cases.empty?
+      @test_cases = [] unless @suite == suite
+      return @test_cases unless @test_cases.empty?
       
-      @@suite = suite # Process the given test suite
-      @@manifest_url = "#{BASE_MANIFEST_URL}#{suite}-manifest.rdf"
+      @suite = suite # Process the given test suite
+      @manifest_url = "#{BASE_MANIFEST_URL}#{suite}-manifest.rdf"
       
       manifest_str = File.read(File.join(TEST_DIR, "#{suite}-manifest.rdf"))
       parser = RdfXmlParser.new
       
       begin
-        parser.parse(manifest_str, @@manifest_url)
+        parser.parse(manifest_str, @manifest_url)
       rescue
         raise "Parse error: #{$!}\n\t#{parser.debug.to_a.join("\t\n")}\n\n"
       end
@@ -181,7 +185,7 @@ module RdfaHelper
         hash
       end
       
-      @@test_cases = test_hash.values.map {|statements| TestCase.new(statements, suite)}.
+      @test_cases = test_hash.values.map {|statements| TestCase.new(statements, suite)}.
         compact.
         sort_by{|t| t.name }
     end

data/spec/rdfa_parser_spec.rb

@@ -114,15 +114,13 @@ describe "RDFa parser" do
       describe "that are approved" do
         test_cases(suite).each do |t|
           next unless t.status == "approved"
-          #next unless t.name =~ /0115/
+          #next unless t.name =~ /0140/
           #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 Spec::Expectations::ExpectationNotMetError => e
-              raise
+            #puts t.input
+            #puts t.results
+            t.run_test do |rdfa_string, rdfa_parser|
+              rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
             end
           end
         end
@@ -130,7 +128,7 @@ describe "RDFa parser" do
       describe "that are unreviewed" do
         test_cases(suite).each do |t|
           next unless t.status == "unreviewed"
-          next unless t.name =~ /017\d/
+          #next unless t.name =~ /017\d/
           #puts t.inspect
           specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
             begin

data/spec/rdfxml_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require File.join(File.dirname(__FILE__), 'spec_helper')
 include RdfContext
 
@@ -181,12 +182,9 @@ xmlns:ex="http://www.example.org/" xml:lang="en" xml:base="http://www.example.or
 <http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate> <http://example.org/stuff/1.0/prop> .
 <http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#object> \"blah\" .
 EOF
-    tc = RdfXMLHelper::TestCase.new([])
-    tc.about = "http://example.com"
-    tc.parser = @parser
 
-    graph = @parser.parse(sampledoc, tc.about, :strict => true)
-    graph.should be_equivalent_graph(triples, tc)
+    graph = @parser.parse(sampledoc, "http://example.com/", :strict => true)
+    graph.should be_equivalent_graph(triples, :about => "http://example.com/", :trace => @parser.debug)
   end
   
   it "should make sure that the value of rdf:ID attributes match the XML Name production (data attribute version)" do
@@ -276,25 +274,21 @@ EOF
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/amp-in-url/test001.nt> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#NT-Document> .
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/amp-in-url/test001.rdf> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#RDF-XML-Document> .
 EOF
-    tc = RdfXMLHelper::TestCase.new([])
-    tc.about = "http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/Manifest.rdf#test001"
-    tc.parser = @parser
-    graph = @parser.parse(sampledoc, tc.about, :strict => true)
-    graph.should be_equivalent_graph(triples, tc)
+    uri = "http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/Manifest.rdf#test001"
+
+    graph = @parser.parse(sampledoc, uri, :strict => true)
+    graph.should be_equivalent_graph(triples, :about => uri, :trace => @parser.debug)
   end
   
   describe "parsing rdf files" do
-    def test_file(filepath, uri = nil)
-      n3_string = File.read(filepath)
-      graph = @parser.parse(n3_string, uri, :strict => true)
-      ntriples = graph.to_ntriples
-      ntriples.gsub!(/_:bn\d+/, '_:node1')
-      ntriples = ntriples.split("\n").sort.join("\n")
+    def test_file(filepath, uri)
+      rdf_string = File.read(filepath)
+      graph = @parser.parse(rdf_string, uri, :strict => true)
 
       nt_string = File.read(filepath.sub('.rdf', '.nt'))
-      nt_string = nt_string.split("\n").sort.join("\n")
+      nt_graph = N3Parser.parse(nt_string, uri)
 
-      ntriples.should == nt_string
+      graph.should be_equivalent_graph(nt_graph, :about => uri, :trace => @parser.debug)
     end
 
     before(:all) do
@@ -307,23 +301,22 @@ EOF
       test_file(file, "http://www.bbc.co.uk/music/artists/#{gid}")
     end
 
-    # it "should parse xml literal test" do
-    #   file = File.join(@rdf_dir, "xml-literal-mixed.rdf")
-    #   test_file(file)
-    # end
+    it "should parse xml literal test" do
+     file = File.join(@rdf_dir, "xml-literal-mixed.rdf")
+     test_file(file, "http://www.example.com/books#book12345")
+    end
   end
 
   # W3C Test suite from http://www.w3.org/2000/10/rdf-tests/rdfcore/
   describe "w3c rdfcore tests" do
-    require 'rdfxml_helper'
-    include RdfXMLHelper
+    require 'rdf_helper'
     
     def self.positive_tests
-      RdfXMLHelper::TestCase.positive_parser_tests rescue []
+      RdfHelper::TestCase.positive_parser_tests(RDFCORE_TEST, RDFCORE_DIR) rescue []
     end
 
     def self.negative_tests
-      RdfXMLHelper::TestCase.negative_parser_tests rescue []
+      RdfHelper::TestCase.negative_parser_tests(RDFCORE_TEST, RDFCORE_DIR) rescue []
     end
     
     # Negative parser tests should raise errors.
@@ -332,7 +325,7 @@ EOF
         #next unless t.about.uri.to_s =~ /rdfms-rdf-names-use/
         #next unless t.name =~ /11/
         #puts t.inspect
-        specify "test #{t.about.uri.to_s}" do
+        specify "test #{t.name}: " + (t.description || "#{t.inputDocument} against #{t.outputDocument}") do
           t.run_test do |rdf_string, parser|
             parser.parse(rdf_string, t.about.uri.to_s, :strict => true, :debug => [])
           end
@@ -345,7 +338,7 @@ EOF
         #next unless t.about.uri.to_s =~ /rdfms-empty-property-elements/
         #next unless t.name =~ /1/
         #puts t.inspect
-        specify "test #{t.about.uri.to_s}" do
+        specify "test #{t.name}: " + (t.description || t.inputDocument) do
           t.run_test do |rdf_string, parser|
             lambda do
               parser.parse(rdf_string, t.about.uri.to_s, :strict => true, :debug => [])

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 begin
   require 'spec'
   require 'active_support'
@@ -9,6 +10,12 @@ rescue LoadError
   require 'active_support'
 end
 
+begin
+  require 'rdf/redland'
+  $redland_enabled = true
+rescue LoadError
+end
+
 ActiveSupport::XmlMini.backend = 'Nokogiri'
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -18,6 +25,19 @@ require 'matchers'
 
 include RdfContext
 
+TMP_DIR = File.join(File.dirname(__FILE__), 'tmp')
+
+SWAP_DIR = File.join(File.dirname(__FILE__), 'swap_test')
+SWAP_TEST = "http://www.w3.org/2000/10/swap/test/n3parser.tests"
+CWM_TEST = "http://www.w3.org/2000/10/swap/test/regression.n3"
+
+TURTLE_DIR = File.join(File.dirname(__FILE__), 'turtle')
+TURTLE_TEST = "http://www.w3.org/2001/sw/DataAccess/df1/tests/manifest.ttl"
+TURTLE_BAD_TEST = "http://www.w3.org/2001/sw/DataAccess/df1/tests/manifest-bad.ttl"
+
+RDFCORE_DIR = File.join(File.dirname(__FILE__), 'rdfcore')
+RDFCORE_TEST = "http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf"
+
 Spec::Runner.configure do |config|
   config.include(Matchers)
 end