ldpath 0.1.0 → 0.2.0

data/spec/ldpath_transform_spec.rb

@@ -5,67 +5,145 @@ describe Ldpath::Transform do
   it "should transform literals" do
     subject.apply(literal: "xyz")
   end
-  
+
   it "should transform uris" do
-    subject.apply(uri:"http://www.w3.org/2003/01/geo/wgs84_pos#")
-  end
-  
-  it "should transform nested uris" do
-    subject.apply(uri: { uri: "info:a"})
+    actual = subject.apply(iri: "info:a")
+    expect(actual).to eq RDF::URI.new("info:a")
   end
-  
+
   it "should transform prefix + localNames" do
-    subject.apply(prefix: "info", localName:"a")
+    actual = subject.apply(prefix: "rdf", localName: "type")
+    expect(actual).to eq RDF.type
   end
-  
+
   it "should transform mappings" do
-    subject.apply parser.parse("x = . ;")
+    actual = subject.apply parser.parse("x = . ;")
+    expect(actual.length).to eq 1
+    mapping = actual.first
+    expect(mapping).to be_a_kind_of Ldpath::FieldMapping
+    expect(mapping.name).to eq "x"
+    expect(mapping.selector).to be_a_kind_of Ldpath::SelfSelector
   end
-  
+
   it "should transform wildcards" do
-    subject.apply parser.parse("xyz = * ;\n")
+    actual = subject.apply parser.parse("xyz = * ;\n")
+
+    mapping = actual.first
+    expect(mapping).to be_a_kind_of Ldpath::FieldMapping
+    expect(mapping.name).to eq "xyz"
+    expect(mapping.selector).to be_a_kind_of Ldpath::WildcardSelector
   end
-  
+
   it "should transform reverse properties" do
-    subject.apply parser.parse("xyz = ^info:a ;\n")
+    actual = subject.apply parser.parse("xyz = ^info:a ;\n")
+
+    mapping = actual.first
+    expect(mapping).to be_a_kind_of Ldpath::FieldMapping
+    expect(mapping.name).to eq "xyz"
+    expect(mapping.selector).to be_a_kind_of Ldpath::ReversePropertySelector
+    expect(mapping.selector.property).to eq RDF::URI.new("info:a")
   end
-  
-  it "should transform recursive properties" do
-    subject.apply parser.parse("xyz = (info:a)* ;\n")
-    subject.apply parser.parse("xyz = (info:a)+ ;\n")
-    subject.apply parser.parse("xyz = (info:a){,5} ;\n")
-    subject.apply parser.parse("xyz = (info:a){2,5} ;\n")
-    subject.apply parser.parse("xyz = (info:a){2,} ;\n")
+
+  describe "recursive properties" do
+    it "is a zero-or-one matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a)? ;\n")
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 0..1
+    end
+
+    it "is a 0-to-infinity matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a)* ;\n")
+
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 0..Ldpath::Transform::Infinity
+    end
+
+    it "is a 1-to-infinity matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a)+ ;\n")
+
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 1..Ldpath::Transform::Infinity
+    end
+
+    it "is a 0 to 5 matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a){,5} ;\n")
+
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 0..5
+    end
+
+    it "is a 2 to 5 matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a){2,5} ;\n")
+
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 2..5
+    end
+
+    it "is a 2 to infinity matcher" do
+      actual = subject.apply parser.parse("xyz = (info:a){2,} ;\n")
+
+      selector = actual.first.selector
+      expect(selector).to be_a_kind_of Ldpath::RecursivePathSelector
+      expect(selector.property.property).to eq RDF::URI.new("info:a")
+      expect(selector.repeat).to eq 2..Ldpath::Transform::Infinity
+    end
   end
-  
+
   it "should transform tap selectors" do
-    subject.apply parser.parse("xyz = ?<x>info:a ;\n")
+    actual = subject.apply parser.parse("xyz = ?<x>info:a ;\n")
+
+    selector = actual.first.selector
+    expect(selector).to be_a_kind_of Ldpath::TapSelector
+    expect(selector.identifier).to eq "x"
+    expect(selector.tap).to be_a_kind_of Ldpath::PropertySelector
   end
-  
+
   it "should transform loose property selectors" do
-    subject.apply parser.parse("xyz = ~info:a ;\n")
-  end
+    actual = subject.apply parser.parse("xyz = ~info:a ;\n")
 
+    selector = actual.first.selector
+    expect(selector).to be_a_kind_of Ldpath::LoosePropertySelector
+    expect(selector.property).to eq RDF::URI.new("info:a")
+  end
 
   it "should transform namespaces" do
-    subject.apply parser.parse("@prefix foaf: <http://xmlns.com/foaf/0.1/>")
+    subject.apply parser.parse("@prefix xyz: <info:xyz>")
+    expect(subject.prefixes).to include "xyz"
+    expect(subject.prefixes["xyz"].to_s).to eq "info:xyz"
   end
-  
+
   it "should transform path selectors" do
-    subject.apply parser.parse("x = . / . ;")
+    actual = subject.apply parser.parse("x = info:a / . ;")
+
+    selector = actual.first.selector
+    expect(selector).to be_a_kind_of Ldpath::PathSelector
+    expect(selector.left).to be_a_kind_of Ldpath::PropertySelector
+    expect(selector.right).to be_a_kind_of Ldpath::SelfSelector
   end
-  
+
   it "should transform functions" do
-    subject.apply parser.function_selector.parse("fn:concat(foaf:givename,\" \",foaf:surname)")
+    selector = subject.apply parser.function_selector.parse("fn:concat(foaf:givename,\" \",foaf:surname)")
+
+    expect(selector).to be_a_kind_of Ldpath::FunctionSelector
+    expect(selector.fname).to eq "concat"
+    expect(selector.arguments.length).to eq 3
   end
-  
+
   it "should transform the foaf example" do
-    subject.apply parser.parse(File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "foaf_example.program")))
-)
+    subject.apply parser.parse(File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "foaf_example.program"))))
   end
-  
+
   it "should parse the program.ldpath" do
     subject.apply parser.parse File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "program.ldpath")))
   end
-
 end

data/spec/lib/functions/list_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "LDPath list functions" do
+  let(:object) { RDF::URI.new("info:a") }
+
+  let(:graph) do
+    graph = RDF::Graph.new
+    l = RDF::List[1, 2, 3]
+    graph << [object, RDF::URI.new("http://example.com/list"), l]
+    graph << l
+    graph
+  end
+
+  subject do
+    program.evaluate object, graph
+  end
+
+  describe "fn:flatten" do
+    let(:program) do
+      Ldpath::Program.parse <<-EOF
+        @prefix ex : <http://example.com/> ;
+        list_items = fn:flatten(ex:list) :: xsd:string ;
+      EOF
+    end
+
+    it "collapses the RDF list into individual values" do
+      expect(subject["list_items"]).to match_array ["1", "2", "3"]
+    end
+  end
+
+  describe "fn:flatten" do
+    let(:program) do
+      Ldpath::Program.parse <<-EOF
+        @prefix ex : <http://example.com/> ;
+        list_item = fn:get(ex:list, "1") :: xsd:string ;
+      EOF
+    end
+
+    it "extracts a single term by position from the RDF list" do
+      expect(subject["list_item"]).to eq ["2"]
+    end
+  end
+
+  describe "fn:subList" do
+    let(:program) do
+      Ldpath::Program.parse <<-EOF
+        @prefix ex : <http://example.com/> ;
+        list_items = fn:subList(ex:list, "1") :: xsd:string ;
+        list_items_by_range = fn:subList(ex:list, "0", "1") :: xsd:string ;
+      EOF
+    end
+
+    it "extracts a list of terms by index" do
+      expect(subject["list_items"]).to eq ["2", "3"]
+    end
+
+    it "selects the range, inclusively" do
+      expect(subject["list_items_by_range"]).to eq ["1", "2"]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,4 +4,4 @@ require 'ldpath'
 require 'rdf/reasoner'
 
 RDF::Reasoner.apply(:rdfs)
-RDF::Reasoner.apply(:owl)
+RDF::Reasoner.apply(:owl)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldpath
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Beer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-05 00:00:00.000000000 Z
+date: 2015-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -104,6 +104,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_hound.yml"
+- ".rubocop_todo.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -127,6 +130,7 @@ files:
 - spec/ldpath_program_spec.rb
 - spec/ldpath_spec.rb
 - spec/ldpath_transform_spec.rb
+- spec/lib/functions/list_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/cbeer/ldpath.rb
 licenses:
@@ -148,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of LDPath
@@ -160,4 +164,5 @@ test_files:
 - spec/ldpath_program_spec.rb
 - spec/ldpath_spec.rb
 - spec/ldpath_transform_spec.rb
+- spec/lib/functions/list_spec.rb
 - spec/spec_helper.rb