ldpath 0.0.0 → 0.0.1

data/lib/ldpath/transform.rb

@@ -0,0 +1,143 @@
+module Ldpath
+  class Transform < Parslet::Transform
+
+    class << self
+      def default_prefixes
+        @default_prefixes ||= {
+          "rdf"  => RDF::Vocabulary.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#"),
+          "rdfs" => RDF::Vocabulary.new("http://www.w3.org/2000/01/rdf-schema#"),
+          "owl"  => RDF::Vocabulary.new("http://www.w3.org/2002/07/owl#"),
+          "skos" => RDF::Vocabulary.new("http://www.w3.org/2004/02/skos/core#"),
+          "dc"   => RDF::Vocabulary.new("http://purl.org/dc/elements/1.1/"),
+          "xsd"  => RDF::Vocabulary.new("http://www.w3.org/2001/XMLSchema#"),#          (LMF base index datatypes/XML Schema)
+          "lmf"  => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/types/1.0/"),#    (LMF extended index datatypes)
+          "fn"   => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/functions/1.0/"),# (LMF index functions)
+          "foaf" => RDF::Vocabulary.new("http://xmlns.com/foaf/0.1/"),
+          "info" => RDF::Vocabulary.new("info:"),
+          "urn" => RDF::Vocabulary.new("urn:"),
+        }
+      end
+    end
+
+    def apply obj, context = nil
+      context ||= { }
+      context[:prefixes] ||= {}.merge(self.class.default_prefixes)
+      super obj, context
+    end
+    
+    # Core types
+    rule(literal: simple(:literal)) { literal.to_s }
+    rule(uri: simple(:uri)) { RDF::URI.new(uri) }
+    
+    # Namespaces
+    rule(namespace: subtree(:namespace)) do
+      prefixes[namespace[:id].to_s] = RDF::Vocabulary.new(namespace[:uri])
+      nil
+    end
+    
+    rule(prefix: simple(:prefix), localName: simple(:localName)) do
+      (prefixes[prefix.to_s] || RDF::Vocabulary.new(prefix.to_s))[localName]
+    end
+
+    # Mappings
+    
+    rule(mapping: subtree(:mapping)) do
+      FieldMapping.new mapping[:name].to_s, mapping[:selector], mapping[:field_type]
+    end
+
+    ## Selectors
+    
+    
+    ### Atomic Selectors
+    rule(self: simple(:self)) do 
+      SelfSelector.new
+    end
+
+    rule(fname: simple(:fname), arglist: subtree(:arglist)) do
+      FunctionSelector.new fname.to_s, arglist
+    end
+  
+    rule(property: simple(:property)) do
+      PropertySelector.new property
+    end
+
+    rule(wildcard: simple(:wilcard)) do
+      WildcardSelector.new
+    end
+
+    rule(reverse_property: simple(:property)) do
+      ReversePropertySelector.new property
+    end
+
+    rule(range: subtree(:range)) do
+      range.fetch(:min,0).to_i..range.fetch(:max, Infinity).to_f
+    end
+    
+    rule(recursive: subtree(:properties)) do
+      repeat = case properties[:repeat]
+      when "*"
+        0..Infinity
+      when "+"
+        1..Infinity
+      when Range
+        properties[:repeat]
+      end
+
+      RecursivePathSelector.new properties[:delegate], repeat  
+    end
+  
+    ### Test Selectors
+
+    rule(delegate: subtree(:delegate), test: subtree(:test)) do
+      TestSelector.new delegate, test
+    end
+
+    rule(lang: simple(:lang)) do
+      LanguageTest.new lang.to_s.to_sym
+    end
+
+    rule(type: simple(:type)) do
+      TypeTest.new type
+    end
+
+    rule(type: simple(:type)) do
+      TypeTest.new type
+    end
+    
+    rule(not: subtree(:not_op)) do
+      NotTest.new not_op[:delegate]
+    end
+    
+    rule(and: subtree(:op)) do
+      AndTest.new op[:left], op[:right]
+    end
+    
+    rule(or: subtree(:op)) do
+      OrTest.new op[:left], op[:right]
+    end
+
+    rule(is: subtree(:is)) do
+      IsTest.new PropertySelector.new(is[:property]), is[:right]
+    end
+    
+    rule(is_a: subtree(:is_a)) do
+      IsTest.new PropertySelector.new(RDF.type), is_a[:right]
+    end
+    ### Compound Selectors
+    
+    rule(path: subtree(:path)) do
+      PathSelector.new path[:left], path[:right]
+    end
+    
+    rule(union: subtree(:union)) do
+      UnionSelector.new union[:left], union[:right]
+    end
+    
+    rule(intersection: subtree(:intersection)) do
+      IntersectionSelector.new intersection[:left], intersection[:right]
+    end
+
+
+    Infinity = 1.0 / 0.0
+  end
+end

data/lib/ldpath/version.rb

@@ -1,3 +1,3 @@
 module Ldpath
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/spec/fixtures/foaf_example.program

@@ -0,0 +1,9 @@
+@prefix foaf : <http://xmlns.com/foaf/0.1/> ;
+@prefix geo : <http://www.w3.org/2003/01/geo/wgs84_pos#> ;
+title      = foaf:name | fn:concat(foaf:givename," ",foaf:surname) :: xsd:string ;
+summary    = dc:description :: lmf:text ;
+geo        = foaf:based_near :: lmf:location;
+interest   = foaf:interest / (rdfs:label[@en] | rdfs:label[@none] | <http://rdf.freebase.com/ns/type.object.name>[@en]) :: xsd:string;
+friends    = foaf:knows / (foaf:name | fn:concat(foaf:givename," ",foaf:surname)) :: xsd:string;
+contrycode = foaf:based_near / <http://www.geonames.org/ontology#countryCode> :: xsd:string ;
+type       = rdf:type :: xsd:anyURI ;

data/spec/fixtures/namespaces.ldpath

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2013 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+@prefix skos: <http://www.w3.org/2004/02/skos/core#>
+@prefix foo: <http://foo.com/some/path#> ;
+@prefix foaf: <http://xmlns.com/foaf/0.1/> ;
+@prefix test: <http://example.com/>
+@prefix dcterms: <http://purl.org/dc/terms/> ;
+@prefix foobar: <urn:uuid:1234> ;

data/spec/fixtures/program.ldpath

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2013 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+@prefix test: <http://example.com/> ;
+@prefix foo: <http://foo.com/some/path#> ;
+
+@graph test:context, foo:ctx, test:bar ;
+
+/*
+@filter test:type is foo:bar | test:p1 & is-a test:Case ;
+
+@boost foo:boost / ^test:boost ;
+*/
+
+path = test:p1 / test:p2 :: test:type ;
+lang_test = test:p1[@en] :: test:type ;
+type_test = foo:p2[^^test:int] :: test:type ;
+int_s = (foo:go)* :: test:type ;
+int_p = (foo:go)+ :: test:type ;
+group = (test:p1 / test:p2) :: test:type ;
+
+inverse = ^test:incoming :: test:type ;
+
+config = test:foo :: test:type ;
+/*
+foo:bar = test:foo :: test:type ;
+<http://test/> = test:test :: test:type ;
+*/

data/spec/ldpath_parser_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'pp'
+require 'parslet/convenience'
+describe Ldpath::Parser do
+  subject { Ldpath::Parser.new }
+  context ".parse" do
+    
+    describe "lines" do
+      it "should parse line-oriented data" do
+        subject.lines.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
+      it 'may be a \n character' do
+        subject.newline.parse("\n")
+      end
+      
+      it 'may be a \n\r' do
+        subject.newline.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 " "
+      end
+      
+      it "may be a namespace declaration" do
+        subject.expression.parse "@prefix x : info:x ;"
+      end
+      
+      it "may be a graph" do
+        subject.expression.parse "@graph test:context, foo:ctx, test:bar ;"
+      end
+      
+      it "may be a mapping" do
+        subject.expression.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"
+      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
+    end
+    
+    describe "strlit" do
+      it "is the content between \"" do
+        subject.strlit.parse '"abc"'
+      end
+      
+      it "should handle escaped characters" do
+        subject.strlit.parse '"a\"b"'
+      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
+    end
+    
+    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.parse("xyz = info:a / info:b :: a:b;\n")
+      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
+    end
+    
+    describe "integration tests" do
+      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 File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "namespaces.ldpath")))
+      end
+    end  
+  end
+end

data/spec/ldpath_program_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Ldpath::Program do
+  describe "Simple program" do
+    subject do
+      Ldpath::Program.parse <<-EOF
+@prefix dcterms : <http://purl.org/dc/terms/> ;
+title = dcterms:title :: xsd:string ;
+parent_title = dcterms:isPartOf / dcterms:title :: xsd:string ;
+titles = dcterms:title | (dcterms:isPartOf / dcterms:title) | (^dcterms:isPartOf / dcterms:title) :: xsd:string ;
+no_titles = dcterms:title & (dcterms:isPartOf / dcterms:title) & (^dcterms:isPartOf / dcterms:title) :: xsd:string ;
+self = . :: xsd:string ;
+wildcard = * ::xsd:string ;
+child_title = ^dcterms:isPartOf / dcterms:title :: xsd:string ;
+recursive = (dcterms:isPartOf)* ;
+en_description = dcterms:description[@en] ;
+conditional = dcterms:isPartOf[dcterms:title] ;
+conditional_false = dcterms:isPartOf[dcterms:description] ;
+int_value = <info:intProperty>[^^xsd:integer] :: xsd:integer ;
+numeric_value = <info:numericProperty> :: xsd:integer ;
+escaped_string = "\\"" :: xsd:string;
+and_test = .[dcterms:title & dcterms:gone] ;
+or_test = .[dcterms:title | dcterms:gone] ;
+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]
+      graph << [object, RDF::DC.description, RDF::Literal.new("English!", language: "en")]
+      graph << [object, RDF::DC.description, RDF::Literal.new("French!", language: "fr")]
+      graph << [object, RDF::URI.new("info:intProperty"), 1]
+      graph << [object, RDF::URI.new("info:intProperty"), "garbage"]
+      graph << [object, RDF::URI.new("info:numericProperty"), "1"]
+      graph << [parent, RDF::DC.title, "Parent title"]
+      graph << [child, RDF::DC.isPartOf, object]
+      graph << [child, RDF::DC.title, "Child title"]
+      graph << [parent, RDF::DC.isPartOf, grandparent]
+
+      result = subject.evaluate object, graph
+
+      expect(result["title"]).to match_array "Hello, world!"
+      expect(result["parent_title"]).to match_array "Parent title"
+      expect(result["self"]).to match_array(object)
+      expect(result["wildcard"]).to include "Hello, world!", parent
+      expect(result["child_title"]).to match_array "Child title"
+      expect(result["titles"]).to match_array ["Hello, world!", "Parent title", "Child title"]
+      expect(result["no_titles"]).to be_empty
+      expect(result["recursive"]).to match_array [parent, grandparent]
+      expect(result["en_description"].first.to_s).to eq "English!"
+      expect(result["conditional"]).to match_array parent
+      expect(result["conditional_false"]).to be_empty
+      expect(result["int_value"]).to match_array 1
+      expect(result["numeric_value"]).to match_array 1
+      expect(result["escaped_string"]).to match_array '\"'
+      expect(result["and_test"]).to be_empty
+      expect(result["or_test"]).to match_array(object)
+      expect(result["is_test"]).to match_array(object)
+      expect(result["is_not_test"]).to be_empty
+    end
+  end
+  
+  describe "functions" do
+    
+      subject do
+        Ldpath::Program.parse <<-EOF
+@prefix dcterms : <http://purl.org/dc/terms/> ;
+title = fn:concat("a", "b") ;
+first_a = fn:first("a", "b") ;
+last_b = fn:last("a", "b") ;
+EOF
+      end
+
+      let(:object) { RDF::URI.new("info:a") }
+      
+      let(:graph) do
+        RDF::Graph.new
+      end
+      
+    it "should work" do
+      result = subject.evaluate object, graph
+      expect(result["title"]).to match_array "ab"
+      expect(result["first_a"]).to match_array "a"
+      expect(result["last_b"]).to match_array "b"
+      
+    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"
+    end
+  end
+end