ldpath 0.3.1 → 1.0.0

data/lib/ldpath/selectors.rb

@@ -1,19 +1,48 @@
 module Ldpath
   class Selector
     def evaluate(program, uris, context)
-      Array(uris).map do |uri|
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+      enum_wrap(uris).map do |uri|
         loading program, uri, context
-        evaluate_one uri, context
-      end.flatten.compact
+        enum_flatten_one(evaluate_one(uri, context)).each do |x|
+          yield x unless x.nil?
+        end
+      end
     end
 
     def loading(program, uri, context)
       program.loading uri, context
     end
+
+    protected
+
+    def enum_wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      elsif object.is_a? Hash
+        [object]
+      elsif object.is_a? Enumerable
+        object
+      else
+        [object]
+      end
+    end
+    
+    def enum_flatten_one(object)
+      return to_enum(:enum_flatten_one, object) unless block_given?
+
+      enum_wrap(object).each do |e|
+        enum_wrap(e).each do |v|
+          yield v
+        end
+      end
+    end
   end
 
   class SelfSelector < Selector
-    def evaluate_one(uri, context)
+    def evaluate_one(uri, _context)
       uri
     end
   end
@@ -27,7 +56,9 @@ module Ldpath
     end
 
     def evaluate(program, uris, context)
-      Array(uris).map do |uri|
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
+      enum_wrap(uris).map do |uri|
         loading program, uri, context
         args = arguments.map do |i|
           case i
@@ -37,8 +68,10 @@ module Ldpath
             i
           end
         end
-        program.func_call fname, uri, context, *args
-      end.flatten.compact
+        enum_flatten_one(program.func_call(fname, uri, context, *args)).each do |x|
+          yield x unless x.nil?
+        end
+      end
     end
   end
 
@@ -49,7 +82,7 @@ module Ldpath
     end
 
     def evaluate_one(uri, context)
-      context.query([uri, property, nil]).map(&:object)
+      context.query([uri, property, nil]).lazy.map(&:object)
     end
   end
 
@@ -62,15 +95,28 @@ module Ldpath
     def evaluate_one(uri, context)
       return PropertySelector.new(property).evaluate_one(uri_context) unless defined? RDF::Reasoner
 
-      context.query([uri, nil, nil]).select do |result|
+      context.query([uri, nil, nil]).lazy.select do |result|
         result.predicate.entail(:subPropertyOf).include? property
       end.map(&:object)
     end
   end
 
+  class NegatedPropertySelector < Selector
+    attr_reader :properties
+    def initialize(*properties)
+      @properties = properties
+    end
+
+    def evaluate_one(uri, context)
+      context.query([uri, nil, nil]).lazy.reject do |result|
+        properties.include? result.predicate
+      end.map(&:object)
+    end
+  end
+
   class WildcardSelector < Selector
     def evaluate_one(uri, context)
-      context.query([uri, nil, nil]).map(&:object)
+      context.query([uri, nil, nil]).lazy.map(&:object)
     end
   end
 
@@ -81,7 +127,7 @@ module Ldpath
     end
 
     def evaluate_one(uri, context)
-      context.query([nil, property, uri]).map(&:subject)
+      context.query([nil, property, uri]).lazy.map(&:subject)
     end
   end
 
@@ -93,19 +139,20 @@ module Ldpath
     end
 
     def evaluate(program, uris, context)
-      result = []
-      input = Array(uris)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
 
-      Range.new(0, repeat.min, true).each do
-        input = property.evaluate program, input, context
-      end
+      input = enum_wrap(uris)
 
-      repeat.each_with_index do |i, idx|
-        break if input.empty? || idx > 25 # we're probably lost..
+      (0..repeat.max).each_with_index do |i, idx|
+        break if input.none? || (repeat.max == Ldpath::Transform::Infinity && idx > 25) # we're probably lost..
         input = property.evaluate program, input, context
-        result |= input
+
+        next unless idx >= repeat.min
+
+        enum_wrap(input).each do |x|
+          yield x
+        end
       end
-      result.flatten.compact
     end
   end
 
@@ -118,21 +165,47 @@ module Ldpath
   end
 
   class PathSelector < CompoundSelector
-    def evaluate(program, uris, context)
+    def evaluate(program, uris, context, &block)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
       output = left.evaluate(program, uris, context)
-      right.evaluate(program, output, context)
+      right.evaluate(program, output, context, &block)
     end
   end
 
   class UnionSelector < CompoundSelector
     def evaluate(program, uris, context)
-      left.evaluate(program, uris, context) | right.evaluate(program, uris, context)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
+      enum_union(left.evaluate(program, uris, context), right.evaluate(program, uris, context)).each do |x|
+        yield x
+      end
+    end
+
+    private
+
+    def enum_union(left, right)
+      return to_enum(:enum_union, left, right) unless block_given?
+
+      enum_wrap(left).each do |e|
+        yield e
+      end
+
+      enum_wrap(right).each do |e|
+        yield e
+      end
     end
   end
 
   class IntersectionSelector < CompoundSelector
     def evaluate(program, uris, context)
-      left.evaluate(program, uris, context) & right.evaluate(program, uris, context)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
+      result = left.evaluate(program, uris, context).to_a & right.evaluate(program, uris, context).to_a
+
+      result.each do |x|
+        yield x
+      end
     end
   end
 
@@ -144,15 +217,19 @@ module Ldpath
     end
 
     def evaluate(program, uris, context)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
       program.meta[identifier] = tap.evaluate(program, uris, context).map { |x| RDF::Literal.new(x.to_s).canonicalize.object }
 
-      Array(uris).map do |uri|
+      enum_wrap(uris).map do |uri|
         loading program, uri, context
-        evaluate_one uri, context
-      end.flatten.compact
+        enum_flatten_one(evaluate_one(uri, context)).each do |x|
+          yield x unless x.nil?
+        end
+      end
     end
 
-    def evaluate_one(uri, context)
+    def evaluate_one(uri, _context)
       uri
     end
   end

data/lib/ldpath/tests.rb

@@ -10,7 +10,7 @@ module Ldpath
     def evaluate(program, uris, context)
       entries = delegate.evaluate program, uris, context
       entries.select do |uri|
-        Array(test.evaluate(program, uri, context)).any? do |x|
+        enum_wrap(test.evaluate(program, uri, context)).any? do |x|
           x
         end
       end
@@ -23,11 +23,10 @@ module Ldpath
       @lang = lang
     end
 
-    def evaluate(program, uri, context)
+    def evaluate(_program, uri, _context)
       return unless uri.literal?
-      if (lang == "none" && !uri.has_language?) || uri.language == lang
-        uri
-      end
+
+      uri if (lang == "none" && !uri.has_language?) || uri.language == lang
     end
   end
 
@@ -37,11 +36,10 @@ module Ldpath
       @type = type
     end
 
-    def evaluate(program, uri, context)
+    def evaluate(program, uri, _context)
       return unless uri.literal?
-      if uri.has_datatype? && uri.datatype == type
-        uri
-      end
+
+      uri if uri.has_datatype? && uri.datatype == type
     end
   end
 
@@ -53,7 +51,7 @@ module Ldpath
     end
 
     def evaluate(program, uri, context)
-      !Array(delegate.evaluate(program, uri, context)).any? { |x| x }
+      !enum_wrap(delegate.evaluate(program, uri, context)).any? { |x| x }
     end
   end
 
@@ -79,8 +77,8 @@ module Ldpath
     end
 
     def evaluate(program, uri, context)
-      left.evaluate(program, uri, context).compact.any? &&
-        right.evaluate(program, uri, context).compact.any?
+      left.evaluate(program, uri, context).any? &&
+        right.evaluate(program, uri, context).any?
     end
   end
 
@@ -93,7 +91,7 @@ module Ldpath
     end
 
     def evaluate(program, uri, context)
-      left.evaluate(program, uri, context).compact.include?(right)
+      left.evaluate(program, uri, context).include?(right)
     end
   end
 end

data/lib/ldpath/transform.rb

@@ -15,7 +15,7 @@ module Ldpath
           "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:"),
+          "urn"  => RDF::Vocabulary.new("urn:")
         }
       end
     end
@@ -71,7 +71,7 @@ module Ldpath
     # Mappings
 
     rule(mapping: subtree(:mapping)) do
-      FieldMapping.new mapping[:name].to_s, mapping[:selector], mapping[:field_type]
+      FieldMapping.new mapping
     end
 
     ## Selectors
@@ -106,18 +106,13 @@ module Ldpath
     end
 
     rule(range: subtree(:range)) do
-      case range
-      when "*"
-        0..Infinity
-      when "+"
-        1..Infinity
-      when "?"
-        0..1
-      else
-        range.fetch(:min, 0).to_i..range.fetch(:max, Infinity).to_f
-      end
+      range.fetch(:min, 0).to_i..range.fetch(:max, Infinity).to_f
     end
 
+    rule(range: '*') { 0..Infinity }
+    rule(range: '+') { 1..Infinity }
+    rule(range: '?') { 0..1 }
+
     rule(delegate: subtree(:delegate), repeat: simple(:repeat)) do
       RecursivePathSelector.new delegate, repeat
     end
@@ -126,6 +121,10 @@ module Ldpath
       TapSelector.new identifier.to_s, tap
     end
 
+    rule(not: simple(:not), property: sequence(:property)) do
+      NegatedPropertySelector.new(*property)
+    end
+
     ### Test Selectors
 
     rule(delegate: subtree(:delegate), test: subtree(:test)) do
@@ -144,16 +143,16 @@ module Ldpath
       TypeTest.new type
     end
 
-    rule(not: subtree(:not_op)) do
-      NotTest.new not_op[:delegate]
+    rule(not: simple(:not_op), delegate: simple(:delegate)) do
+      NotTest.new delegate
     end
 
-    rule(and: subtree(:op)) do
-      AndTest.new op[:left], op[:right]
+    rule(op: '|', left_test: subtree(:left_test), right_test: subtree(:right_test)) do
+      OrTest.new left_test, right_test
     end
 
-    rule(or: subtree(:op)) do
-      OrTest.new op[:left], op[:right]
+    rule(op: '&', left_test: subtree(:left_test), right_test: subtree(:right_test)) do
+      AndTest.new left_test, right_test
     end
 
     rule(is: subtree(:is)) do
@@ -165,15 +164,17 @@ module Ldpath
     end
 
     ### Compound Selectors
-    rule(left: subtree(:left), op: simple(:op), right: subtree(:right)) do
-      case op
-      when "/"
-        PathSelector.new left, right
-      when "|"
-        UnionSelector.new left, right
-      when "&"
-        IntersectionSelector.new left, right
-      end
+
+    rule(op: '/', left: subtree(:left), right: subtree(:right)) do
+      PathSelector.new left, right
+    end
+
+    rule(op: '|', left: subtree(:left), right: subtree(:right)) do
+      UnionSelector.new left, right
+    end
+
+    rule(op: '&', left: subtree(:left), right: subtree(:right)) do
+      IntersectionSelector.new left, right
     end
 
     Infinity = 1.0 / 0.0

data/lib/ldpath/version.rb

@@ -1,3 +1,3 @@
 module Ldpath
-  VERSION = "0.3.1"
+  VERSION = '1.0.0'.freeze
 end

data/lib/ldpath.rb

@@ -10,8 +10,11 @@ module Ldpath
   require 'ldpath/transform'
   require 'ldpath/functions'
   require 'ldpath/program'
+  require 'ldpath/result'
 
   class << self
+    attr_writer :logger
+
     def evaluate(program, uri, context)
       Ldpath::Program.parse(program).evaluate(uri, context)
     end
@@ -25,9 +28,5 @@ module Ldpath
         end
       end
     end
-
-    def logger=(logger)
-      @logger = logger
-    end
   end
 end

data/spec/fixtures/bbc_b0081dq5.nt

@@ -0,0 +1,4 @@
+<http://www.bbc.co.uk/programmes/b0081dq5> <http://xmlns.com/foaf/0.1/primaryTopic> <_:b0> .
+<_:b0> <http://purl.org/ontology/po/pid> "b0081dq5" .
+<_:b0> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/primaryTopic> .
+<_:b0> <http://purl.org/dc/elements/1.1/title> "Huw Stephens" .

data/spec/fixtures/loc_n79021164.nt

@@ -0,0 +1,3 @@
+<http://id.loc.gov/authorities/names/n79021164> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.loc.gov/mads/rdf/v1#PersonalName> .
+<http://id.loc.gov/authorities/names/n79021164> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.loc.gov/mads/rdf/v1#Authority> .
+<http://id.loc.gov/authorities/names/n79021164> <http://www.loc.gov/mads/rdf/v1#authoritativeLabel> "Twain, Mark, 1835-1910 (network call to LOC)"@en .

data/spec/ldpath_parser_spec.rb

@@ -200,12 +200,30 @@ describe Ldpath::Parser do
       end
 
       it "tap_selector" do
-        subject.selector.parse('?<a><info:a>')
+        subject.selector.parse('?<__autocomplete>fn:predicates()')
       end
 
       it "loose_selector" do
         subject.selector.parse('~<info:a>')
       end
+
+      it "negated property selector" do
+        subject.selector.parse('!<info:a>')
+      end
+    end
+
+    describe "tests" do
+      it "should pass a simple property test" do
+        subject.selector.parse('.[info:a]')
+      end
+
+      it "should pass a property test with '&'" do
+        subject.selector.parse('.[info:a & info:b]')
+      end
+
+      it "should pass a property test with '|'" do
+        subject.selector.parse('.[info:a | info:b]')
+      end
     end
 
     describe "integration tests" do

data/spec/ldpath_program_spec.rb

@@ -36,19 +36,19 @@ EOF
     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::Vocab::DC.title, "Hello, world!"]
+      graph << [object, RDF::Vocab::DC.isPartOf, parent]
+      graph << [object, RDF::Vocab::DC.description, RDF::Literal.new("English!", language: "en")]
+      graph << [object, RDF::Vocab::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]
+      graph << [parent, RDF::Vocab::DC.title, "Parent title"]
+      graph << [child, RDF::Vocab::DC.isPartOf, object]
+      graph << [child, RDF::Vocab::DC.title, "Child title"]
+      graph << [parent, RDF::Vocab::DC.isPartOf, grandparent]
 
-      result = subject.evaluate object, graph
+      result = subject.evaluate object, context: graph
 
       expect(result["title"]).to match_array "Hello, world!"
       expect(result["parent_title"]).to match_array "Parent title"
@@ -97,17 +97,17 @@ EOF
 
     let(:graph) do
       graph = RDF::Graph.new
-      graph << [object, RDF::DC.title, "Hello, world!"]
-      graph << [object, RDF::DC.description, "Description"]
-      graph << [object, RDF::DC.hasPart, "a"]
-      graph << [object, RDF::DC.hasPart, "b"]
-      graph << [object, RDF::DC.hasPart, "c"]
+      graph << [object, RDF::Vocab::DC.title, "Hello, world!"]
+      graph << [object, RDF::Vocab::DC.description, "Description"]
+      graph << [object, RDF::Vocab::DC.hasPart, "a"]
+      graph << [object, RDF::Vocab::DC.hasPart, "b"]
+      graph << [object, RDF::Vocab::DC.hasPart, "c"]
 
       graph
     end
 
     subject do
-      program.evaluate object, graph
+      program.evaluate object, context: graph
     end
 
     describe "concat" do
@@ -191,8 +191,13 @@ title = foaf:primaryTopic / dc:title :: xsd:string ;
 EOF
     end
 
+    before do
+      stub_request(:get, 'http://www.bbc.co.uk/programmes/b0081dq5')
+          .to_return(status: 200, body: webmock_fixture('bbc_b0081dq5.nt'), headers: { 'Content-Type' => 'application/n-triples' })
+    end
+
     it "should work" do
-      result = subject.evaluate RDF::URI.new("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
+      result = subject.evaluate RDF::URI.new("http://www.bbc.co.uk/programmes/b0081dq5")
       expect(result["title"]).to match_array "Huw Stephens"
     end
   end
@@ -205,9 +210,16 @@ predicates = <http://xmlns.com/foaf/0.1/primaryTopic> / fn:predicates() :: xsd:s
 EOF
     end
 
+    before do
+      stub_request(:get, 'http://www.bbc.co.uk/programmes/b0081dq5')
+        .to_return(status: 200, body: webmock_fixture('bbc_b0081dq5.nt'), headers: { 'Content-Type' => 'application/n-triples' })
+    end
+
     it "should work" do
-      result = subject.evaluate RDF::URI.new("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
-      expect(result["predicates"]).to include "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", "http://purl.org/ontology/po/pid", "http://purl.org/dc/elements/1.1/title"
+      result = subject.evaluate RDF::URI.new("http://www.bbc.co.uk/programmes/b0081dq5")
+      expect(result["predicates"]).to include "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+                                              "http://purl.org/ontology/po/pid",
+                                              "http://purl.org/dc/elements/1.1/title"
     end
   end
 
@@ -219,9 +231,9 @@ EOF
     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 << [object, RDF::Vocab::DC.title, "Object"]
+      graph << [child, RDF::Vocab::DC.title, "Child"]
+      graph << [object, RDF::Vocab::DC.hasPart, child]
 
       graph
     end
@@ -236,7 +248,7 @@ child_title_with_tap = dcterms:hasPart / ?<tap>fn:predicates() / dcterms:title :
     end
 
     it "should work" do
-      result = subject.evaluate object, graph
+      result = subject.evaluate object, context: graph
       expect(result["child_title_with_tap"]).to eq result["child_title"]
       expect(result["tap"]).to eq ["http://purl.org/dc/terms/title"]
     end
@@ -250,9 +262,9 @@ child_title_with_tap = dcterms:hasPart / ?<tap>fn:predicates() / dcterms:title :
     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 << [object, RDF::Vocab::DC.title, "Object"]
+      graph << [child, RDF::Vocab::DC.title, "Child"]
+      graph << [object, RDF::Vocab::DC.hasPart, child]
 
       graph
     end
@@ -267,7 +279,7 @@ title_with_loose =  ~dc:title :: xsd:string ;
     end
 
     it "should work" do
-      result = subject.evaluate object, graph
+      result = subject.evaluate object, context: graph
       expect(result["title_with_loose"]).to eq result["title"]
     end
   end
@@ -288,27 +300,70 @@ title_with_loose =  ~dc:title :: xsd:string ;
     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 << [object, RDF.type, RDF::Vocab::DC.Agent]
+      graph << [object, RDF::Vocab::DC.title, "Title"]
+      graph << [other_object, RDF::Vocab::DC.title, "Other Title"]
 
       graph
     end
 
     it "should work" do
-      result = subject.evaluate object, graph
+      result = subject.evaluate object, context: graph
       expect(result["title"]).to eq ["Title"]
     end
 
     it "filters objects that don't match" do
-      result = subject.evaluate other_object, graph
+      result = subject.evaluate other_object, context: graph
       expect(result).to be_empty
     end
   end
 
   describe "error handling" do
     it "should provide a reasonable exception" do
-      expect { Ldpath::Program.parse "title .= <oops> ;" }.to raise_error /Expected "=", but got "."/
+      expect { Ldpath::Program.parse "title .= <oops> ;" }.to raise_error(/Expected "=", but got "."/)
+    end
+  end
+
+  describe '#evaluate' do
+    context 'when passing limit_to_context' do
+      subject do
+        Ldpath::Program.parse <<-EOF
+@prefix madsrdf : <http://www.loc.gov/mads/rdf/v1#> ;
+@prefix schema: <http://www.w3.org/2000/01/rdf-schema#> ;
+property = madsrdf:authoritativeLabel :: xsd:string ;
+        EOF
+      end
+
+      let(:subject_uri) { RDF::URI('http://id.loc.gov/authorities/names/n79021164') }
+
+      let(:graph) do
+        graph = RDF::Graph.new
+        graph << [subject_uri, RDF::Vocab::MADS.authoritativeLabel, 'Mark Twain (passed in context)']
+        graph
+      end
+
+      before do
+        stub_request(:get, 'http://id.loc.gov/authorities/names/n79021164')
+            .to_return(status: 200, body: webmock_fixture('loc_n79021164.nt'), headers: { 'Content-Type' => 'application/n-triples' })
+      end
+
+      context 'as false' do
+        let(:expected_values) { ['Mark Twain (passed in context)', 'Twain, Mark, 1835-1910 (network call to LOC)'] }
+
+        it 'returns values from context and network call' do
+          result = subject.evaluate subject_uri, context: graph
+          expect(result['property']).to match_array expected_values
+        end
+      end
+
+      context 'as true' do
+        let(:expected_values) { ['Mark Twain (passed in context)'] }
+
+        it 'returns values from context only' do
+          result = subject.evaluate(subject_uri, context: graph, limit_to_context: true)
+          expect(result['property']).to match_array expected_values
+        end
+      end
     end
   end
 end