ldpath 0.1.0 → 0.2.0

data/lib/ldpath/version.rb

@@ -1,3 +1,3 @@
 module Ldpath
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/ldpath_parser_spec.rb

@@ -4,172 +4,232 @@ require 'parslet/convenience'
 describe Ldpath::Parser do
   subject { Ldpath::Parser.new }
   context ".parse" do
-    
-    describe "lines" do
+    describe "doc" do
       it "should parse line-oriented data" do
-        subject.lines.parse " \n \n"
+        subject.doc.parse " \n \n"
       end
     end
-    
-    describe "line" do
-      it "may be a line ending in a newline" do
-        subject.line.parse " \n"
-      end
-      
-      it "may be a line ending in EOF" do
-        subject.line.parse("/* abc */")
-      end
-    end
-    
-    describe "newline" do
+
+    describe "eol" do
       it 'may be a \n character' do
-        subject.newline.parse("\n")
+        subject.eol.parse("\n")
       end
-      
+
       it 'may be a \n\r' do
-        subject.newline.parse("\n\r")
+        subject.eol.parse("\n\r")
       end
     end
-    
+
     describe "eof" do
       it "is the eof" do
         subject.eof.parse ""
       end
     end
-    
+
     describe "wsp" do
       it "may be a space" do
         subject.wsp.parse " "
       end
-      
+
       it "may be a tab" do
         subject.wsp.parse "\t"
       end
-      
+
       it "may be a multiline comment" do
         subject.wsp.parse "/* xyz */"
       end
-    end
-    
-    describe "expression" do
-      it "may be whitespace" do
-        subject.expression.parse " "
+
+      it "may be a single line comment" do
+        subject.wsp.parse "# xyz"
       end
-      
+    end
+
+    describe "directive" do
       it "may be a namespace declaration" do
-        subject.expression.parse "@prefix x : info:x ;"
+        subject.directive.parse "@prefix x : <info:x> ;"
       end
-      
+
       it "may be a graph" do
-        subject.expression.parse "@graph test:context, foo:ctx, test:bar ;"
+        subject.directive.parse "@graph test:context, foo:ctx, test:bar ;"
       end
-      
 
       it "may be a filter" do
-        subject.expression.parse "@filter is-a test:Context ;"
+        subject.directive.parse "@filter is-a test:Context ;"
+      end
+    end
+
+    describe "prefixID" do
+      it "should parse prefix mappings" do
+        subject.prefixID.parse "@prefix x : <info:x> ;"
       end
-      
+
+      it "should parse the null prefix" do
+        subject.prefixID.parse "@prefix : <info:x> ;"
+      end
+    end
+
+    describe "statement" do
       it "may be a mapping" do
-        subject.expression.parse "id = . ;"
+        subject.statement.parse "id = . ;"
       end
     end
-    
-    describe "uri" do
-      it "may be a bracketed uri" do
-        result = subject.uri.parse "<info:x>"
-        expect(result[:uri]).to eq "info:x"
-      end
-      
-      it "may be a namespace and local name" do
-        result = subject.uri.parse "info:x"
-        expect(result[:uri][:prefix]).to eq "info"
-        expect(result[:uri][:localName]).to eq "x"
+
+    describe "iri" do
+      it "may be an iriref" do
+        result = subject.iri.parse "<info:x>"
+        expect(result[:iri]).to eq "info:x"
+      end
+
+      it "may be a prefixed name" do
+        result = subject.iri.parse "info:x"
+        expect(result[:iri][:prefix]).to eq "info"
+        expect(result[:iri][:localName]).to eq "x"
       end
     end
-    
+
     describe "identifier" do
       it "must start with an alphanumeric character" do
         subject.identifier.parse "a"
         subject.identifier.parse "J"
-        subject.identifier.parse "4"
-        subject.identifier.parse "_"
       end
-      
+
       it "may have additional alphanumeric characters" do
         subject.identifier.parse "aJ0_.-"
       end
+
+      it "may not end in a dot" do
+        expect { subject.identifier.parse "aJ0_.-." }.to raise_error
+      end
     end
-    
-    describe "strlit" do
+
+    describe "string" do
       it "is the content between \"" do
-        subject.strlit.parse '"abc"'
+        subject.string.parse '"abc"'
       end
-      
+
       it "should handle escaped characters" do
-        subject.strlit.parse '"a\"b"'
+        subject.string.parse '"a\"b"'
+      end
+
+      it "should handle single quoted strings" do
+        subject.string.parse "'abc'"
+      end
+
+      it "should handle long strings" do
+        str = <<-EOF
+          """
+           xyz
+          """
+        EOF
+
+        subject.string.parse str.strip
+      end
+
+      it "should handle long single-quoted strings" do
+        str = <<-EOF
+          '''
+           xyz
+          '''
+        EOF
+
+        subject.string.parse str.strip
       end
     end
-    
+
     describe "node" do
       it "may be a uri" do
         subject.node.parse "info:x"
       end
-      
+
       it "may be a literal" do
         subject.node.parse '"a"'
       end
+
+      it "may be a typed literal" do
+        subject.node.parse '"a"^^info:x'
+      end
+
+      it "may be a language literal" do
+        subject.node.parse '"a"@en'
+      end
+
+      it "may be a numeric literal" do
+        subject.node.parse '0'
+      end
+
+      it "may be a boolean literal" do
+        subject.node.parse 'true'
+      end
     end
-    
-    describe "selectors" do  
+
+    describe "selectors" do
       it "should parse mappings" do
         subject.parse("xyz = . ;\n")
       end
-      
+
       it "should parse wildcards" do
         subject.parse("xyz = * ;\n")
       end
-      
+
       it "should parse reverse properties" do
         subject.parse("xyz = ^info:a ;\n")
       end
-      
+
       it "should parse uri mappings" do
         subject.parse("xyz = <info:a> ;\n")
       end
-      
+
       it "should parse path mappings" do
         subject.mapping.parse("xyz = info:a / info:b :: a:b;")
       end
-      
+
+      it "should parse path selectors" do
+        subject.selector.parse("info:a / info:b")
+      end
+
       it "recursive_path_selector" do
         subject.recursive_path_selector.parse("(foo:go)*")
       end
-      
+
       it "function_selector" do
         subject.selector.parse('fn:concat(foaf:givename," ",foaf:surname)')
       end
-      
+
       it "tap_selector" do
         subject.selector.parse('?<a><info:a>')
       end
-      
+
       it "loose_selector" do
         subject.selector.parse('~<info:a>')
       end
     end
-    
+
     describe "integration tests" do
+      it "should parse a simple example" do
+        tree = subject.parse <<-EOF
+@prefix dcterms : <http://purl.org/dc/terms/> ;
+topic = <http://xmlns.com/foaf/0.1/primaryTopic> :: xsd:string ;
+EOF
+        expect(tree.length).to eq 2
+        expect(tree.first).to include :prefixID
+        expect(tree.first[:prefixID]).to include id: 'dcterms'
+        expect(tree.first[:prefixID]).to include iri: 'http://purl.org/dc/terms/'
+        expect(tree.last).to include :mapping
+        expect(tree.last[:mapping]).to include name: 'topic'
+        expect(tree.last[:mapping]).to include :selector
+      end
+
       it "should parse the foaf example" do
         subject.parse File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "foaf_example.program")))
       end
-      
+
       it "should parse the program.ldpath" do
         subject.parse File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "program.ldpath")))
       end
-      
+
       it "should parse the namespaces.ldpath" do
-        subject.parse_with_debug File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "namespaces.ldpath")))
+        subject.parse File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "namespaces.ldpath")))
       end
-    end  
+    end
   end
 end

data/spec/ldpath_program_spec.rb

@@ -25,16 +25,16 @@ is_test = .[dcterms:title is "Hello, world!"] ;
 is_not_test = .[!(dcterms:title is "Hello, world!")] ;
 EOF
     end
-    
+
     let(:object) { RDF::URI.new("info:a") }
     let(:parent) { RDF::URI.new("info:b") }
     let(:child) { RDF::URI.new("info:c") }
     let(:grandparent) { RDF::URI.new("info:d") }
-    
+
     let(:graph) do
       RDF::Graph.new
     end
-    
+
     it "should work" do
       graph << [object, RDF::DC.title, "Hello, world!"]
       graph << [object, RDF::DC.isPartOf, parent]
@@ -70,7 +70,7 @@ EOF
       expect(result["is_not_test"]).to be_empty
     end
   end
-  
+
   describe "functions" do
     let(:program) do
       Ldpath::Program.parse <<-EOF
@@ -94,7 +94,7 @@ EOF
     end
 
     let(:object) { RDF::URI.new("info:a") }
-    
+
     let(:graph) do
       graph = RDF::Graph.new
       graph << [object, RDF::DC.title, "Hello, world!"]
@@ -137,7 +137,7 @@ EOF
         expect(subject).to include "first_b" => ["b"]
       end
     end
-    
+
     describe "last" do
       it "should take the last value" do
         expect(subject).to include "last_b" => ["b"]
@@ -182,17 +182,15 @@ EOF
       end
     end
   end
-  
+
   describe "Data loading" do
     subject do
-      
       Ldpath::Program.parse <<-EOF
 @prefix dcterms : <http://purl.org/dc/terms/> ;
 title = foaf:primaryTopic / dc:title :: xsd:string ;
 EOF
-      
     end
-    
+
     it "should work" do
       result = subject.evaluate RDF::URI.new("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
       expect(result["title"]).to match_array "Huw Stephens"
@@ -217,17 +215,17 @@ EOF
     let(:object) { RDF::URI.new("info:a") }
     let(:child) { RDF::URI.new("info:b") }
     let(:grandchild) { RDF::URI.new("info:c") }
-    
+
     let(:graph) do
       graph = RDF::Graph.new
-      
+
       graph << [object, RDF::DC.title, "Object"]
       graph << [child, RDF::DC.title, "Child"]
       graph << [object, RDF::DC.hasPart, child]
 
       graph
     end
-    
+
     subject do
       Ldpath::Program.parse <<-EOF
 @prefix dcterms : <http://purl.org/dc/terms/> ;
@@ -243,22 +241,22 @@ child_title_with_tap = dcterms:hasPart / ?<tap>fn:predicates() / dcterms:title :
       expect(result["tap"]).to eq ["http://purl.org/dc/terms/title"]
     end
   end
-  
+
   describe "loose selector" do
     let(:object) { RDF::URI.new("info:a") }
     let(:child) { RDF::URI.new("info:b") }
     let(:grandchild) { RDF::URI.new("info:c") }
-    
+
     let(:graph) do
       graph = RDF::Graph.new
-      
+
       graph << [object, RDF::DC.title, "Object"]
       graph << [child, RDF::DC.title, "Child"]
       graph << [object, RDF::DC.hasPart, child]
 
       graph
     end
-    
+
     subject do
       Ldpath::Program.parse <<-EOF
 @prefix dcterms : <http://purl.org/dc/terms/> ;
@@ -275,7 +273,6 @@ title_with_loose =  ~dc:title :: xsd:string ;
   end
 
   describe "filter" do
-    
     subject do
       Ldpath::Program.parse <<-EOF
     @prefix dcterms : <http://purl.org/dc/terms/> ;
@@ -287,28 +284,25 @@ title_with_loose =  ~dc:title :: xsd:string ;
 
     let(:object) { RDF::URI.new("info:a") }
     let(:other_object) { RDF::URI.new("info:b") }
-    
-    
+
     let(:graph) do
       graph = RDF::Graph.new
-      
+
       graph << [object, RDF.type, RDF::DC.Agent]
       graph << [object, RDF::DC.title, "Title"]
       graph << [other_object, RDF::DC.title, "Other Title"]
 
       graph
     end
-    
+
     it "should work" do
       result = subject.evaluate object, graph
       expect(result["title"]).to eq ["Title"]
     end
-    
+
     it "filters objects that don't match" do
       result = subject.evaluate other_object, graph
       expect(result).to be_empty
     end
-
-
   end
 end