ldpath 0.1.0 → 0.2.0

data/lib/ldpath/program.rb

@@ -1,10 +1,9 @@
 module Ldpath
   class Program
-
     include Ldpath::Functions
 
     class << self
-      def parse program, transform_context = {}
+      def parse(program, transform_context = {})
         parsed = parser.parse(program)
         ast = transform.apply parsed, transform_context
 
@@ -12,6 +11,7 @@ module Ldpath
       end
 
       private
+
       def transform
         Ldpath::Transform.new
       end
@@ -20,36 +20,35 @@ module Ldpath
         @parser ||= Ldpath::Parser.new
       end
     end
-    
-    attr_reader :mappings, :cache, :loaded, :prefixes, :filters
-    def initialize mappings, options = {}
 
+    attr_reader :mappings, :cache, :loaded, :prefixes, :filters
+    def initialize(mappings, options = {})
       @mappings ||= mappings
       @cache = options[:cache] || RDF::Util::Cache.new
       @prefixes = options[:prefixes] || {}
       @filters = options[:filters] || []
       @loaded = {}
     end
-    
-    def loading uri, context
-      if uri.to_s =~ /^http/ and !loaded[uri.to_s]
+
+    def loading(uri, context)
+      if uri.to_s =~ /^http/ && !loaded[uri.to_s]
         context << load_graph(uri.to_s)
       end
     end
 
-    def load_graph uri
+    def load_graph(uri)
       cache[uri] ||= begin
-        Ldpath.logger.debug "[#{self.object_id}] Loading #{uri.inspect}"
+        Ldpath.logger.debug "[#{object_id}] Loading #{uri.inspect}"
 
         reader_types = RDF::Format.reader_types.reject { |t| t.to_s =~ /html/ }.map do |t|
-          t.to_s =~ /text\/(?:plain|html)/  ? "#{t};q=0.5" : t
+          t.to_s =~ /text\/(?:plain|html)/ ? "#{t};q=0.5" : t
         end
 
         RDF::Graph.load(uri, headers: { 'Accept' => reader_types.join(", ") }).tap { loaded[uri] = true }
       end
     end
 
-    def evaluate uri, context = nil
+    def evaluate(uri, context = nil)
       h = {}
       context ||= load_graph(uri.to_s)
 
@@ -60,14 +59,14 @@ module Ldpath
       mappings.each do |m|
         h[m.name] ||= []
         h[m.name] += case m.selector
-        when Selector
-          m.selector.evaluate(self, uri, context).map do |x| 
-            next x unless m.field_type
-            RDF::Literal.new(x.to_s, datatype: m.field_type).canonicalize.object
-          end
-        else
-          Array(m.selector)
-        end
+                     when Selector
+                       m.selector.evaluate(self, uri, context).map do |x|
+                         next x unless m.field_type
+                         RDF::Literal.new(x.to_s, datatype: m.field_type).canonicalize.object
+                       end
+                     else
+                       Array(m.selector)
+                     end
       end
 
       h.merge(meta)
@@ -76,8 +75,8 @@ module Ldpath
     def meta
       @meta ||= {}
     end
-    
-    def func_call fname, uri, context, *arguments
+
+    def func_call(fname, uri, context, *arguments)
       if function_method? fname
         public_send(fname, uri, context, *arguments)
       else
@@ -86,9 +85,9 @@ module Ldpath
     end
 
     private
-    def function_method? function
+
+    def function_method?(function)
       Functions.public_instance_methods(false).include? function.to_sym
     end
-
   end
 end

data/lib/ldpath/selectors.rb

@@ -1,32 +1,32 @@
 module Ldpath
   class Selector
-    def evaluate program, uris, context
+    def evaluate(program, uris, context)
       Array(uris).map do |uri|
         loading program, uri, context
         evaluate_one uri, context
       end.flatten.compact
     end
-    
-    def loading program, uri, context
+
+    def loading(program, uri, context)
       program.loading uri, context
     end
   end
-  
+
   class SelfSelector < Selector
-    def evaluate_one uri, context
+    def evaluate_one(uri, context)
       uri
-    end 
+    end
   end
-  
+
   class FunctionSelector < Selector
     attr_reader :fname, :arguments
 
-    def initialize fname, arguments = []
+    def initialize(fname, arguments = [])
       @fname = fname
       @arguments = Array(arguments)
     end
-    
-    def evaluate program, uris, context
+
+    def evaluate(program, uris, context)
       Array(uris).map do |uri|
         loading program, uri, context
         args = arguments.map do |i|
@@ -41,25 +41,25 @@ module Ldpath
       end.flatten.compact
     end
   end
-  
+
   class PropertySelector < Selector
     attr_reader :property
-    def initialize property
+    def initialize(property)
       @property = property
     end
 
-    def evaluate_one uri, context
+    def evaluate_one(uri, context)
       context.query([uri, property, nil]).map(&:object)
     end
   end
-  
+
   class LoosePropertySelector < Selector
     attr_reader :property
-    def initialize property
+    def initialize(property)
       @property = property
     end
 
-    def evaluate_one uri, context
+    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|
@@ -67,83 +67,83 @@ module Ldpath
       end.map(&:object)
     end
   end
-  
+
   class WildcardSelector < Selector
-    def evaluate_one uri, context
+    def evaluate_one(uri, context)
       context.query([uri, nil, nil]).map(&:object)
     end
   end
-  
+
   class ReversePropertySelector < Selector
     attr_reader :property
-    def initialize property
+    def initialize(property)
       @property = property
     end
-    
-    def evaluate_one uri, context
+
+    def evaluate_one(uri, context)
       context.query([nil, property, uri]).map(&:subject)
     end
   end
-  
+
   class RecursivePathSelector < Selector
     attr_reader :property, :repeat
-    def initialize property, repeat
+    def initialize(property, repeat)
       @property = property
       @repeat = repeat
     end
-    
-    def evaluate program, uris, context
+
+    def evaluate(program, uris, context)
       result = []
       input = Array(uris)
-      
-      Range.new(0,repeat.min,true).each do
+
+      Range.new(0, repeat.min, true).each do
         input = property.evaluate program, input, context
       end
-      
+
       repeat.each_with_index do |i, idx|
-        break if input.empty? or idx > 25 # we're probably lost..
+        break if input.empty? || idx > 25 # we're probably lost..
         input = property.evaluate program, input, context
         result |= input
       end
       result.flatten.compact
     end
   end
-  
+
   class CompoundSelector < Selector
     attr_reader :left, :right
-    def initialize left, right
+    def initialize(left, right)
       @left = left
       @right = right
     end
   end
-  
+
   class PathSelector < CompoundSelector
-    def evaluate program, uris, context
+    def evaluate(program, uris, context)
       output = left.evaluate(program, uris, context)
       right.evaluate(program, output, context)
     end
   end
-  
+
   class UnionSelector < CompoundSelector
-    def evaluate program, uris, context
+    def evaluate(program, uris, context)
       left.evaluate(program, uris, context) | right.evaluate(program, uris, context)
     end
   end
 
-  class IntersectionSelector < CompoundSelector    
-    def evaluate program, uris, context
+  class IntersectionSelector < CompoundSelector
+    def evaluate(program, uris, context)
       left.evaluate(program, uris, context) & right.evaluate(program, uris, context)
     end
   end
 
   class TapSelector < Selector
     attr_reader :identifier, :tap
-    def initialize identifier, tap
+    def initialize(identifier, tap)
       @identifier = identifier
       @tap = tap
     end
 
-    def evaluate program, uris, context
+    def evaluate(program, uris, context)
       program.meta[identifier] = tap.evaluate(program, uris, context).map { |x| RDF::Literal.new(x.to_s).canonicalize.object }
 
       Array(uris).map do |uri|
@@ -151,10 +151,9 @@ module Ldpath
         evaluate_one uri, context
       end.flatten.compact
     end
-    
-    def evaluate_one uri, context
+
+    def evaluate_one(uri, context)
       uri
     end
   end
-
 end

data/lib/ldpath/tests.rb

@@ -1,14 +1,13 @@
 module Ldpath
-  
   class TestSelector < Selector
     attr_reader :delegate, :test
 
-    def initialize delegate, test
+    def initialize(delegate, test)
       @delegate = delegate
       @test = test
     end
 
-    def evaluate program, uris, context
+    def evaluate(program, uris, context)
       entries = delegate.evaluate program, uris, context
       entries.select do |uri|
         Array(test.evaluate(program, uri, context)).any? do |x|
@@ -20,82 +19,80 @@ module Ldpath
 
   class LanguageTest < TestSelector
     attr_reader :lang
-    def initialize lang
+    def initialize(lang)
       @lang = lang
     end
 
-    def evaluate program, uri, context
+    def evaluate(program, uri, context)
       return unless uri.literal?
-      if (lang == "none" && !uri.has_language?) or uri.language == lang 
-        uri 
+      if (lang == "none" && !uri.has_language?) || uri.language == lang
+        uri
       end
     end
   end
 
   class TypeTest < TestSelector
     attr_reader :type
-    def initialize type
+    def initialize(type)
       @type = type
     end
 
-    def evaluate program, uri, context
+    def evaluate(program, uri, context)
       return unless uri.literal?
-      if uri.has_datatype? and uri.datatype == type
+      if uri.has_datatype? && uri.datatype == type
         uri
       end
     end
   end
-  
+
   class NotTest < TestSelector
     attr_reader :delegate
-    
-    def initialize delegate
+
+    def initialize(delegate)
       @delegate = delegate
     end
-    
-    def evaluate program, uri, context
+
+    def evaluate(program, uri, context)
       !Array(delegate.evaluate(program, uri, context)).any? { |x| x }
     end
   end
 
   class OrTest < TestSelector
     attr_reader :left, :right
-    
-    def initialize left, right
+
+    def initialize(left, right)
       @left = left
       @right = right
     end
-    
-    def evaluate program, uri, context
+
+    def evaluate(program, uri, context)
       left.evaluate(program, uri, context).any? || right.evaluate(program, uri, context).any?
     end
   end
 
-  class AndTest < TestSelector    
-
+  class AndTest < TestSelector
     attr_reader :left, :right
-    
-    def initialize left, right
+
+    def initialize(left, right)
       @left = left
       @right = right
     end
 
-    def evaluate program, uri, context
+    def evaluate(program, uri, context)
       left.evaluate(program, uri, context).compact.any? &&
-         right.evaluate(program, uri, context).compact.any?
+        right.evaluate(program, uri, context).compact.any?
     end
   end
-  
+
   class IsTest < TestSelector
-    
     attr_reader :left, :right
-    
-    def initialize left, right
+
+    def initialize(left, right)
       @left = left
       @right = right
     end
-    
-    def evaluate program, uri, context
+
+    def evaluate(program, uri, context)
       left.evaluate(program, uri, context).compact.include?(right)
     end
   end

data/lib/ldpath/transform.rb

@@ -1,5 +1,6 @@
 module Ldpath
   class Transform < Parslet::Transform
+    attr_reader :prefixes
 
     class << self
       def default_prefixes
@@ -9,37 +10,38 @@ module Ldpath
           "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)
+          "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:"),
+          "urn"  => RDF::Vocabulary.new("urn:"),
         }
       end
     end
 
-    def apply obj, context = nil
-      context ||= { }
+    def apply(obj, context = nil)
+      context ||= {}
       context[:filters] ||= []
       context[:prefixes] ||= {}.merge(self.class.default_prefixes)
+      @prefixes = context[:prefixes]
       super obj, context
     end
-    
+
     # Core types
     rule(literal: simple(:literal)) { literal.to_s }
-    rule(uri: simple(:uri)) { RDF::URI.new(uri) }
-    
+    rule(iri: simple(:iri)) { RDF::IRI.new(iri) }
+
     # Namespaces
-    rule(namespace: subtree(:namespace)) do
-      prefixes[namespace[:id].to_s] = RDF::Vocabulary.new(namespace[:uri])
+    rule(prefixID: subtree(:prefixID)) do
+      prefixes[prefixID[:id].to_s] = RDF::Vocabulary.new(prefixID[:iri])
       nil
     end
-    
+
     rule(prefix: simple(:prefix), localName: simple(:localName)) do
       (prefixes[prefix.to_s] || RDF::Vocabulary.new(prefix.to_s))[localName]
     end
-    
+
     rule(filter: subtree(:filter)) do
       filters << filter[:test]
       nil
@@ -50,18 +52,16 @@ module Ldpath
       nil
     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 
+    rule(self: simple(:self)) do
       SelfSelector.new
     end
 
@@ -72,12 +72,12 @@ module Ldpath
     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(loose_property: simple(:property)) do
+
+    rule(loose: simple(:loose), property: simple(:property)) do
       LoosePropertySelector.new property
     end
 
@@ -85,31 +85,31 @@ module Ldpath
       WildcardSelector.new
     end
 
-    rule(reverse_property: simple(:property)) do
+    rule(reverse: simple(: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]
+      case range
       when "*"
         0..Infinity
       when "+"
         1..Infinity
-      when Range
-        properties[:repeat]
+      when "?"
+        0..1
+      else
+        range.fetch(:min, 0).to_i..range.fetch(:max, Infinity).to_f
       end
+    end
 
-      RecursivePathSelector.new properties[:delegate], repeat  
+    rule(delegate: subtree(:delegate), repeat: simple(:repeat)) do
+      RecursivePathSelector.new delegate, repeat
     end
 
     rule(identifier: simple(:identifier), tap: subtree(:tap)) do
       TapSelector.new identifier.to_s, tap
     end
-  
+
     ### Test Selectors
 
     rule(delegate: subtree(:delegate), test: subtree(:test)) do
@@ -127,15 +127,15 @@ module Ldpath
     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
@@ -143,25 +143,23 @@ module Ldpath
     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]
+    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
     end
 
-
     Infinity = 1.0 / 0.0
   end
 end