rdf-n3 0.2.3.2 → 0.3.0

data/script/tc

@@ -2,12 +2,12 @@
 require 'rubygems'
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'rdf/n3'
-require 'spec/rdf_helper'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'rdfa_helper'))
 require 'getoptlong'
 
 def run_tc(tc)
   puts "run #{tc.name}"
-  puts RDF::Writer.for($format.to_sym).buffer { |writer|
+  puts RDF::Writer.for($output_format.to_sym).buffer { |writer|
     RDF::N3::Reader.new(tc.input, :base_uri => tc.about, :strict => $strict).each do |statement|
       writer << statement
     end
@@ -15,7 +15,7 @@ def run_tc(tc)
 end
 
 $verbose = false
-$format = :ntriples
+$output_format = :ntriples
 $strict = false
 suite = "turtle"
 opts = GetoptLong.new(
@@ -31,7 +31,7 @@ opts.each do |opt, arg|
   when '--verbose' then $verbose = true
   when '--quiet' then $quiet = true
   when '--debug' then ::RDF::N3::debug = true
-  when '--format' then $format = arg
+  when '--format' then $output_format = arg
   when '--suite' then suite = arg
   when '--strict' then $strict = true
   end

data/spec/cwm_spec.rb

@@ -12,11 +12,19 @@ describe RDF::N3::Reader do
 
     # Negative parser tests should raise errors.
     test_cases.each do |t|
+      next unless t.about.to_s =~ /n3$/
       #next unless t.about.uri.to_s =~ /rdfms-rdf-names-use/
-      #next unless t.name =~ /11/
+      #next unless t.name =~ /1018/
       #puts t.inspect
-      specify "test #{t.name}: " + (t.description || "#{t.inputDocument} against #{t.outputDocument}") do
+      specify "test #{t.name}: #{t.description}: #{t.inputDocument} against #{t.outputDocument}" do
         begin
+          if t.name =~ /1018/
+            pending("matcher does not stop")
+            next
+          elsif t.rdf_type == "CwmProofTest"
+            pending("proofs not supported")
+            next
+          end
           t.run_test do |rdf_string|
             t.debug = []
             g = RDF::Graph.new
@@ -28,7 +36,7 @@ describe RDF::N3::Reader do
             end
             g
           end
-        rescue #Spec::Expectations::ExpectationNotMetError => e
+        rescue RSpec::Expectations::ExpectationNotMetError => e
           if t.status == "pending"
             pending("Formulae not supported") {  raise } 
           else

data/spec/n3reader_spec.rb

@@ -264,7 +264,7 @@ describe "RDF::N3::Reader" do
     it "should allow mixed-case language" do
       n3doc = %(:x2 :p "xyz"@EN .)
       statement = parse(n3doc).statements.first
-      statement.object.to_ntriples.should == %("xyz"@en)
+      statement.object.to_ntriples.should == %("xyz"@EN)
     end
 
     it "should create typed literals" do
@@ -343,32 +343,13 @@ describe "RDF::N3::Reader" do
     end
   end
   
-  # describe "with illegal syntax" do
-  #   {
-  #     %(:y :p1 "xyz"^^xsd:integer .) => %r(Typed literal has an invalid lexical value: .* "xyz"),
-  #     %(:y :p1 "12xyz"^^xsd:integer .) => %r(Typed literal has an invalid lexical value: .* "12xyz"),
-  #     %(:y :p1 "xy.z"^^xsd:double .) => %r(Typed literal has an invalid lexical value: .* "xy\.z"),
-  #     %(:y :p1 "+1.0z"^^xsd:double .) => %r(Typed literal has an invalid lexical value: .* "\+1.0z"),
-  #     %(:a :b .) => %r(Illegal statment: ".*" missing object),
-  #     %(:a :b 'single quote' .) => RDF::ReaderError,
-  #     %(:a "literal value" :b .) => RDF::ReaderError,
-  #     %(@keywords prefix. :e prefix :f .) => %r(Keyword ".*" used as expression)
-  #   }.each_pair do |n3, error|
-  #     it "should raise error for '#{n3}'" do
-  #       lambda {
-  #         parse("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{n3}", :base_uri => "http://a/b")
-  #       }.should raise_error(error)
-  #     end
-  #   end
-  # end
-  
-  describe "with n3 grammer" do
+  describe "with n3 grammar" do
     describe "syntactic expressions" do
       it "should create typed literals with qname" do
         n3doc = %(
-          @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
-          @prefix foaf: <http://xmlns.com/foaf/0.1/>
-          @prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+          @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+          @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+          @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
           <http://example.org/joe> foaf:name \"Joe\"^^xsd:string .
         )
         statement = parse(n3doc).statements.first
@@ -482,16 +463,50 @@ describe "RDF::N3::Reader" do
         parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
-      it "should do something for @forAll" do
-        pending
+      it "substitutes variable for URI with @forAll" do
+        n3 = %(@forAll :x . :x :y :z .)
+        g = parse(n3, :base_uri => "http://a/b")
+        statement = g.statements.first
+        statement.subject.should be_a(RDF::Query::Variable)
+        statement.predicate.to_s.should == "http://a/b#y"
+        statement.object.to_s.should == "http://a/b#z"
+      end
+
+      it "substitutes variable for URIs with @forAll" do
+        n3 = %(@forAll :x, :y, :z . :x :y :z .)
+        g = parse(n3, :base_uri => "http://a/b")
+        statement = g.statements.first
+        statement.subject.should be_a(RDF::Query::Variable)
+        statement.predicate.should be_a(RDF::Query::Variable)
+        statement.object.should be_a(RDF::Query::Variable)
+        statement.subject.should_not == statement.predicate
+        statement.object.should_not == statement.predicate
+        statement.predicate.should_not == statement.object
       end
 
-      it "should do something for @forSome" do
-        pending
+      it "substitutes node for URI with @forEach" do
+        n3 = %(@forSome :x . :x :y :z .)
+        g = parse(n3, :base_uri => "http://a/b")
+        statement = g.statements.first
+        statement.subject.should be_a(RDF::Node)
+        statement.predicate.to_s.should == "http://a/b#y"
+        statement.object.to_s.should == "http://a/b#z"
+      end
+
+      it "substitutes node for URIs with @forEach" do
+        n3 = %(@forSome :x, :y, :z . :x :y :z .)
+        g = parse(n3, :base_uri => "http://a/b")
+        statement = g.statements.first
+        statement.subject.should be_a(RDF::Node)
+        statement.predicate.should be_a(RDF::Node)
+        statement.object.should be_a(RDF::Node)
+        statement.subject.should_not == statement.predicate
+        statement.object.should_not == statement.predicate
+        statement.predicate.should_not == statement.object
       end
     end
     
-    describe "namespaces" do
+    describe "prefixes" do
       it "should not append # for http://foo/bar" do
         n3 = %(@prefix : <http://foo/bar> . :a : :b .)
         nt = %(
@@ -562,11 +577,27 @@ describe "RDF::N3::Reader" do
         )
         parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
+      
+      it "returns defined prefixes" do
+        n3 = %(
+        @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+        @prefix : <http://test/> .
+        :foo a rdfs:Class.
+        :bar :d :c.
+        :a :d :c.
+        )
+        reader = RDF::N3::Reader.new(n3)
+        reader.each {|statement|}
+        reader.prefixes.should == {
+          :rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+          :rdfs => "http://www.w3.org/2000/01/rdf-schema#",
+          nil => "http://test/"}
+      end
     end
     
     describe "keywords" do
       [
-        %(prefix :<>.),
         %(base <>.),
         %(keywords a.),
         %(:a is :b of :c.),
@@ -577,10 +608,19 @@ describe "RDF::N3::Reader" do
         it "should require @ if keywords set to empty for '#{n3}'" do
           lambda do
             parse("@keywords . #{n3}", :base_uri => "http://a/b")
-          end.should raise_error(/unqualified keyword '\w+' used without @keyword directive/)
+          end.should raise_error(RDF::ReaderError)
         end
       end
       
+      [
+        %(prefix :<>.),
+      ].each do |n3|
+        it "parses as local name if keywords set to empty for '#{n3}'" do
+          lambda do
+            parse("@keywords . #{n3}", :base_uri => "http://a/b")
+          end.should_not raise_error(RDF::ReaderError)
+        end
+      end
       {
         %(:a a :b)  => %(<http://a/b#a> <http://a/b#a> <http://a/b#b> .),
         %(:a :b true) => %(<http://a/b#a> <http://a/b#b> <http://a/b#true> .),
@@ -611,7 +651,7 @@ describe "RDF::N3::Reader" do
         n3 = %(@keywords foo.)
         lambda do
           parse(n3, :base_uri => "http://a/b")
-        end.should raise_error(RDF::ReaderError, "undefined keywords used: foo")
+        end.should raise_error(RDF::ReaderError, /Undefined keywords used: foo/)
       end
     end
     
@@ -744,12 +784,6 @@ describe "RDF::N3::Reader" do
       end
 
       describe "from paths" do
-        it "should create bnode for path x.p" do
-          n3 = %(:x2.:y2 :p2 "3" .)
-          nt = %(:x2 :y2 _:bnode0 . _:bnode0 :p2 "3" .)
-          parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
-        end
-      
         it "should create bnode for path x!p" do
           n3 = %(:x2!:y2 :p2 "3" .)
           nt = %(:x2 :y2 _:bnode0 . _:bnode0 :p2 "3" .)
@@ -794,7 +828,7 @@ describe "RDF::N3::Reader" do
         it "should decode path with property list." do
           n3 = %(
           @prefix a: <http://a/ns#>.
-          :a2.a:b2.a:c2 :q1 "3" ; :q2 "4" , "5" .
+          :a2!a:b2!a:c2 :q1 "3" ; :q2 "4" , "5" .
           )
           nt = %(
           :a2 <http://a/ns#b2> _:bnode0 .
@@ -816,7 +850,7 @@ describe "RDF::N3::Reader" do
         end
 
         it "should decode path as object(2)" do
-          n3 = %(@prefix a: <http://a/ns#>. :r :p :o.a:p1.a:p2 .)
+          n3 = %(@prefix a: <http://a/ns#>. :r :p :o!a:p1!a:p2 .)
           nt = %(
           :o <http://a/ns#p1> _:bnode0 .
           _:bnode0 <http://a/ns#p2> _:bnode1 .
@@ -828,12 +862,67 @@ describe "RDF::N3::Reader" do
     end
     
     describe "formulae" do
-      it "should require that graph be formula_aware when encountering a formlua" do
-        pending
+      before(:each) { @repo = RDF::Repository.new }
+
+      it "creates an RDF::Graph instance for formula" do
+        n3 = %(:a :b {})
+        parse(n3, :graph => @repo, :base_uri => "http://a/b")
+        statement = @repo.statements.first
+        statement.object.should be_a(RDF::Node)
+      end
+
+      it "adds statements with context" do
+        
+      end
+
+      it "creates variables with ?" do
+        
       end
       
-      it "should separate triples between specified and quoted graphs" do
-        pending
+      context "contexts" do
+        before(:each) do
+          n3 = %(
+            # Test data in notation3 http://www.w3.org/DesignIssues/Notation3.html
+            #    
+            @prefix u: <http://www.example.org/utilities#> .
+            @prefix : <#> .
+
+            :assumption = { :fred u:knows :john .
+                            :john u:knows :mary .} .
+
+            :conclusion = { :fred u:knows :mary . } .
+
+            # The empty context is trivially true.
+            # Check that we can input it and output it!
+
+            :trivialTruth = { }.
+
+            # ENDS
+          )
+          @repo = RDF::Repository.new
+          parse(n3, :graph => @repo, :base_uri => "http://a/b")
+        end
+
+        it "assumption graph has 2 statements" do
+          tt = @repo.first(:subject => RDF::URI.new("http://a/b#assumption"), :predicate => RDF::OWL.sameAs)
+          tt.object.should be_a(RDF::Node)
+          @repo.query(:context => tt.object).to_a.length.should == 2
+        end
+
+        it "conclusion graph has 1 statements" do
+          tt = @repo.first(:subject => RDF::URI.new("http://a/b#conclusion"), :predicate => RDF::OWL.sameAs)
+          tt.object.should be_a(RDF::Node)
+          @repo.query(:context => tt.object).to_a.length.should == 1
+        end
+
+        it "trivialTruth equivalent to empty graph" do
+          tt = @repo.first(:subject => RDF::URI.new("http://a/b#trivialTruth"), :predicate => RDF::OWL.sameAs)
+          tt.object.should be_a(RDF::Node)
+          @repo.query(:context => tt.object) do |s|
+            puts "statement: #{s}"
+          end
+        end
+
       end
     end
     
@@ -919,34 +1008,43 @@ describe "RDF::N3::Reader" do
         nt = %(<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://foo/a#prop> "nilProp" .)
         parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
+
       it "should parse with compound items" do
         n3 = %(
-        @prefix a: <http://foo/a#> .
-
-        a:a a:p ( [ a:p2 "v1" ] 
-        	  <http://resource1>
-        	  <http://resource2>
-        	  ("inner list") ) .
-
-        <http://resource1> a:p "value" .
+          @prefix a: <http://foo/a#> .
+          a:a a:p (
+            [ a:p2 "v1" ] 
+            <http://resource1>
+            <http://resource2>
+            ("inner list")
+          ) .
+          <http://resource1> a:p "value" .
         )
         nt = %(
-        <http://foo/a#a> <http://foo/a#p> _:bnode5 .
-        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode4 .
-        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
-        _:bnode4 <http://foo/a#p2> "v1" .
-        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource1> .
+        <http://foo/a#a> <http://foo/a#p> _:bnode3 .
         <http://resource1> <http://foo/a#p> "value" .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode5 .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
+        _:bnode5 <http://foo/a#p2> "v1" .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource1> .
         _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode1 .
         _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource2> .
         _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode0 .
-        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode3 .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode4 .
         _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
-        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "inner list" .
-        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "inner list" .
+        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
         )
         g = parse(n3, :base_uri => "http://a/b")
-        normalize_bnodes(g, "bnode0").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug, :compare => :array)
+        g.subjects.to_a.length.should == 8
+        n = g.first_object(:subject => RDF::URI.new("http://foo/a#a"), :predicate => RDF::URI.new("http://foo/a#p"))
+        n.should be_a(RDF::Node)
+        seq = RDF::List.new(n, g)
+        seq.to_a.length.should == 4
+        seq.first.should be_a(RDF::Node)
+        seq.second.should == RDF::URI.new("http://resource1")
+        seq.third.should == RDF::URI.new("http://resource2")
+        seq.fourth.should be_a(RDF::Node)
       end
       
     end
@@ -1031,6 +1129,78 @@ describe "RDF::N3::Reader" do
     end
   end
 
+  describe "canonicalization" do
+#    {
+#      "<http://foo>"                 =>  "<http://foo>",
+#      "<http://foo/a>"               => "<http://foo/a>",
+#      "<http://foo#a>"               => "<http://foo#a>",
+#
+#      "<http://foo/>"                =>  "<http://foo/>",
+#      "<http://foo/#a>"              => "<http://foo/#a>",
+#
+#      "<http://foo#>"                =>  "<http://foo#>",
+#      "<http://foo#a>"               => "<http://foo/a>",
+#      "<http://foo#/a>"              => "<http://foo/a>",
+#      "<http://foo##a>"              => "<http://foo#a>",
+#
+#      "<http://foo/bar>"             =>  "<http://foo/bar>",
+#      "<http://foo/bar>"             => "<http://foo/a>",
+#      "<http://foo/bar/a>"           => "<http://foo/a>",
+#      "<http://foo/bar#a>"           => "<http://foo/bar#a>",
+#
+#      "<http://foo/bar/>"            =>  "<http://foo/bar/>",
+#      "<http://foo/bar/a>"           => "<http://foo/bar/a>",
+#      "<http://foo/bar//a>"          => "<http://foo/a>",
+#      "<http://foo/bar/#a>"          => "<http://foo/bar/#a>",
+#
+#      "<http://foo/bar#>"            =>  "<http://foo/bar#>",
+#      "<http://foo/bar#a>"           => "<http://foo/a>",
+#      "<http://foo/bar#/a>"          => "<http://foo/a>",
+#      "<http://foo/bar##a>"          => "<http://foo/bar#a>",
+#
+#      "<http://foo/bar##D%C3%BCrst>" => "<http://foo/bar#D%C3%BCrst>",
+#      "<http://foo/bar##Dürst>"      => "<http://foo/bar#D\\u00FCrst>",
+#    }.each_pair do |input, result|
+#      it "returns subject #{result} given #{input}" do
+#        n3 = %(#{input} a :b)
+#        nt = %(#{result} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#b> .)
+#        parse(n3, :base_uri => "http://a/b", :canonicalize => true).should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+#      end
+#    end
+
+    {
+      %("+1"^^xsd:integer) => %("1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+      %(+1) => %("1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+      %(true) => %("true"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      %("lang"@EN) => %("lang"@en),
+    }.each_pair do |input, result|
+      it "returns object #{result} given #{input}" do
+        n3 = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{input} .)
+        nt = %(<http://a/b#a> <http://a/b#b> #{result} .)
+        parse(n3, :base_uri => "http://a/b", :canonicalize => true).should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+      end
+    end
+  end
+  
+  describe "validation" do
+    {
+      %(:y :p1 "xyz"^^xsd:integer .) => %r("xyz" is not a valid .*),
+      %(:y :p1 "12xyz"^^xsd:integer .) => %r("12xyz" is not a valid .*),
+      %(:y :p1 "xy.z"^^xsd:double .) => %r("xy\.z" is not a valid .*),
+      %(:y :p1 "+1.0z"^^xsd:double .) => %r("\+1.0z" is not a valid .*),
+      %(:a :b .) =>RDF::ReaderError,
+      %(:a :b 'single quote' .) => RDF::ReaderError,
+      %(:a "literal value" :b .) => RDF::ReaderError,
+      %(@keywords prefix. :e prefix :f .) => RDF::ReaderError
+    }.each_pair do |n3, error|
+      it "should raise '#{error}' for '#{n3}'" do
+        lambda {
+          parse("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{n3}", :base_uri => "http://a/b", :validate => true)
+        }.should raise_error(error)
+      end
+    end
+  end
+  
   it "should parse rdf_core testcase" do
     sampledoc = <<-EOF;
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/Manifest.rdf#test001> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#PositiveParserTest> .
@@ -1052,8 +1222,8 @@ EOF
   
   def parse(input, options = {})
     @debug = []
-    graph = RDF::Graph.new
-    RDF::N3::Reader.new(input, options.merge(:debug => @debug, :strict => true)).each do |statement|
+    graph = options[:graph] || RDF::Graph.new
+    RDF::N3::Reader.new(input, {:debug => @debug, :validate => true, :canonicalize => false}.merge(options)).each do |statement|
       graph << statement
     end
     graph