ldpath 0.0.0 → 0.0.1

data/lib/ldpath/program.rb

@@ -1,259 +1,70 @@
-require 'parslet'
+module Ldpath
+  class Program
 
-class Ldpath::Program < Parslet::Parser
-  root :lines
-  rule(:lines) { line.repeat }
-  rule(:line) { expression >> newline }
-  rule(:newline) { any.absent? | str("\n") >> str("\r").maybe }
-  rule(:expression) { wsp | multiline_comment | namespace | mapping }
-  
-  rule(:multiline_comment) { (str('/*') >> (str('*/').absent? >> any).repeat >> str('*/')) }
-  
-  rule(:comma) { str(",") }
-  rule(:scolon) { str(";") }
-  rule(:colon) { str(":") }
-  rule(:dcolon) { str("::") }
-  rule(:assign) { str("=") }
-  rule(:k_prefix) { str("@prefix")}
-  rule(:k_graph) { str("@graph")}
-  
-  rule(:self_op) { str(".") }
-  rule(:and_op) { str("&") }
-  rule(:or_op) { str("|") }
-  rule(:p_sep) { str("/") }
-  rule(:plus) { str("+") }
-  rule(:star) { str("*") }
-  rule(:not_op) { str("!") }
-  rule(:inverse) { str("^") }
-  rule(:is) { str "is" }
-  rule(:is_a) { str "is-a" }
-  rule(:func) { str "fn:"}
-  rule(:type) { str "^^" }
-  rule(:lang) { str "@" }
-  
-  rule(:wsp) { (match["\s"] | str("\n")).repeat(1) }
-  rule(:wsp?) { wsp.maybe }
-  
-  # todo: fixme
-  rule(:uri) { (str("<") >> (str(">").absent? >> any).repeat >> str(">")) | (identifier.as(:prefix) >> str(":") >> identifier.as(:localName) )}
-  rule(:identifier) { match["a-zA-Z0-9_"] >> (match["a-zA-Z0-9_'\\.-"]).repeat }
+    include Ldpath::Functions
 
-  rule(:namespace) { 
-    k_prefix >>
-    wsp? >>
-    identifier.as(:id) >>
-    wsp? >>
-    colon >>
-    wsp? >>
-    uri.as(:uri) >>
-    wsp? >>
-    scolon.maybe
-  }
-  
-  rule(:mapping) {
-    name_selector_mapping
-  }
-  
-  rule(:name_selector_mapping) {
-    identifier.as(:name) >>
-    wsp? >>
-    assign >>
-    wsp? >>
-    selector.as(:selector) >>
-    wsp? >>
-    (
-      dcolon >> wsp? >>
-      uri.as(:type)
-    ).maybe >>
-    wsp? >>
-    scolon
-  }
-  
-  rule(:selector) {
-    (
-      compound_selector |
-      testing_selector |
-      atomic_selector
-    ).as(:result)
-  }
-  
-  rule(:compound_selector) {
-    (
-      union_selector |
-      intersection_selector |
-      path_selector
-    ).as(:result)
-  }
-  
-  rule(:grouped_selector) {
-    wsp? >>
-    str("(") >> wsp? >> selector.as(:result) >> wsp? >> str(")") >> wsp?
-  }
-  
-  rule(:path_selector) {
-    wsp? >>
-    atomic_or_testing_selector.as(:left) >>
-    wsp? >>
-    p_sep >>
-    wsp? >>
-    atomic_or_testing_or_path_selector.as(:right) >>
-    wsp?
-  }
-  
-  rule(:intersection_selector) {
-    wsp? >>
-    atomic_or_testing_or_path_selector.as(:left) >>
-    wsp? >>
-    and_op >>
-    wsp? >>
-    selector.as(:right) >>
-    wsp?
-  }
-  
-  rule(:union_selector) {
-    wsp? >>
-    atomic_or_testing_or_path_selector.as(:left) >>
+    class << self
+      def parse program, transform_context = {}
+        parsed = parser.parse(program)
+        ast = transform.apply parsed, transform_context
+
+        Ldpath::Program.new ast.compact
+      end
+
+      private
+      def transform
+        Ldpath::Transform.new
+      end
+
+      def parser
+        @parser ||= Ldpath::Parser.new
+      end
+    end
     
-    wsp? >>
-    or_op >>
+    attr_reader :mappings
+    def initialize mappings
+      @mappings ||= mappings
+      @cache = {}
+    end
     
-    wsp? >>
-    selector.as(:right) >>
+    def loading uri, context
+      if uri.to_s =~ /^http/ and !context.has_subject?(uri)
+        @cache[uri] ||= RDF::Graph.load(uri)
+        context << @cache[uri]
+      end
+    end
+
+    def evaluate uri, context = nil
+      h = {}
+      context ||= RDF::Graph.load uri.to_s
+
+      mappings.each do |m|
+        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
+      end
+
+      h
+    end
     
-    wsp?
-  }
-  
-  rule(:atomic_or_testing_or_path_selector) {
-    (path_selector | atomic_or_testing_selector).as(:result)
-  }
-  
-  rule(:atomic_or_testing_selector) {
-    (testing_selector | atomic_selector).as(:result)
-  }
-  
-  rule(:atomic_selector) {
-    (
-      self_selector |
-      property_selector |
-      wildcard_selector | 
-      reverse_property_selector |
-      function_selector |
-      # string_constant_selector |
-      # recursive_path_selector |
-      grouped_selector
-    ).as(:result)
-  }
-  
-  rule(:self_selector) {
-    wsp? >> self_op >> wsp?
-  }
-  
-  rule(:property_selector) {
-    wsp? >> uri >> wsp?
-  }
-  
-  rule(:reverse_property_selector) {
-    wsp? >> inverse >> uri.as(:uri) >> wsp?
-  }
-  
-  rule(:wildcard_selector) {
-    wsp? >> star >> wsp?
-  }
-  
-  rule(:testing_selector) {
-    wsp? >>
-    atomic_selector.as(:delegate) >>
-    str("[") >>
-    wsp? >>
-    node_test.as(:test) >>
-    wsp? >>
-    str("]") >> wsp?
-  }
-  
-  rule(:node_test) {
-    grouped_test |
-    not_test |
-    and_test |
-    or_test |
-    atomic_node_test
-  }
-  
-  rule(:grouped_test) {
-    wsp? >> str("(") >> wsp? >> node_test >> wsp? >> str(")") >> wsp?
-  }
-  
-  rule(:atomic_node_test) {
-    # literal_language_test |
-    # literal_type_test |
-    is_a_test |
-    path_equality_test |
-    function_test |
-    path_test
-  }
-  
-  rule(:not_test) {
-    wsp? >> not_op >> node_test.as(:delegate) >> wsp?
-  }
-  
-  rule(:and_test) {
-    wsp? >> atomic_node_test >> wsp? >> and_op >> wsp? >> node_test >> wsp?
-  }
-  
-  rule(:or_test) {
-    wsp? >> atomic_node_test >> wsp? >> or_op >> wsp? >> node_test >> wsp?
-  }
-  
-  rule(:strlit) {
-    wsp? >> str('"') >> (str('"').absent? >> any).repeat >> str('"') >> wsp?
-  }
-  
-  rule(:node) {
-    uri.as(:uri) | strlit.as(:literal)
-  }
-  
-  rule(:is_a_test) {
-    wsp? >> is_a >> wsp? >> node.as(:node) >> wsp?
-  }
-  
-  rule(:path_equality_test) {
-    selector.as(:path) >> is >> node.as(:node)
-  }
-  
-  rule(:function_selector) {
-    (
-      func >> identifier.as(:fname) >> str("()") |
-      func >> identifier.as(:fname) >> str("(") >>
-        wsp? >>
-        (selector.as(:argument)) >>
-        (
-          (wsp? >> str(",") >> wsp? >> selector.as(:argument)).repeat
-        ).maybe >>
-        wsp? >>
-      str(")")
-    )
-  }
-  
-  rule(:function_test) {
-    (
-      func >> identifier.as(:fname) >> str("()") |
-      func >> identifier.as(:fname) >> str("(") >>
-        wsp? >>
-        (selector.as(:argument)) >>
-        (
-          (wsp? >> str(",") >> wsp? >> selector.as(:argument)).repeat
-        ).maybe >>
-        wsp? >>
-      str(")")
-    )
-  }
-  
-  rule(:path_test) {
-    (
-      path_selector |
-      testing_selector |
-      atomic_selector
-    ).as(:path)
-  }
-  
+    def func_call fname, uri, context, *arguments
+      if function_method? fname
+        public_send(fname, uri, context, *arguments)
+      else
+        raise "No such function: #{fname}"
+      end
+    end
+
+    private
+    def function_method? function
+      Functions.public_instance_methods(false).include? function.to_sym
+    end
 
+  end
 end

data/lib/ldpath/selectors.rb

@@ -0,0 +1,124 @@
+module Ldpath
+  class Selector
+    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
+      program.loading uri, context
+    end
+  end
+  
+  class SelfSelector < Selector
+    def evaluate_one uri, context
+      uri
+    end 
+  end
+  
+  class FunctionSelector < Selector
+    attr_reader :fname, :arguments
+
+    def initialize fname, arguments
+      @fname = fname
+      @arguments = arguments
+    end
+    
+    def evaluate program, uris, context
+      Array(uris).map do |uri|
+        loading program, uri, context
+        args = arguments.map do |i|
+          case i
+          when Selector
+            i.evaluate(program, uri, context)
+          else
+            i
+          end
+        end
+        program.func_call fname, uri, context, *arguments
+      end.flatten.compact
+    end
+  end
+  
+  class PropertySelector < Selector
+    attr_reader :property
+    def initialize property
+      @property = property
+    end
+
+    def evaluate_one uri, context
+      context.query([uri, property, nil]).map(&:object)
+    end
+  end
+  
+  class WildcardSelector < Selector
+    def evaluate_one uri, context
+      context.query([uri, nil, nil]).map(&:object)
+    end
+  end
+  
+  class ReversePropertySelector < Selector
+    attr_reader :property
+    def initialize property
+      @property = property
+    end
+    
+    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
+      @property = property
+      @repeat = repeat
+    end
+    
+    def evaluate program, uris, context
+      result = []
+      input = Array(uris)
+      
+      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..
+        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
+      @left = left
+      @right = right
+    end
+  end
+  
+  class PathSelector < CompoundSelector
+    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
+      left.evaluate(program, uris, context) | right.evaluate(program, uris, context)
+    end
+  end
+
+  class IntersectionSelector < CompoundSelector    
+    def evaluate program, uris, context
+      left.evaluate(program, uris, context) & right.evaluate(program, uris, context)
+    end
+  end
+
+end

data/lib/ldpath/tests.rb

@@ -0,0 +1,102 @@
+module Ldpath
+  
+  class TestSelector < Selector
+    attr_reader :delegate, :test
+
+    def initialize delegate, test
+      @delegate = delegate
+      @test = test
+    end
+
+    def evaluate program, uris, context
+      entries = delegate.evaluate program, uris, context
+      entries.select do |uri|
+        Array(test.evaluate(program, uri, context)).any? do |x|
+          x
+        end
+      end
+    end
+  end
+
+  class LanguageTest < TestSelector
+    attr_reader :lang
+    def initialize lang
+      @lang = lang
+    end
+
+    def evaluate program, uri, context
+      return unless uri.literal?
+      if (lang == "none" && !uri.has_language?) or uri.language == lang 
+        uri 
+      end
+    end
+  end
+
+  class TypeTest < TestSelector
+    attr_reader :type
+    def initialize type
+      @type = type
+    end
+
+    def evaluate program, uri, context
+      return unless uri.literal?
+      if uri.has_datatype? and uri.datatype == type
+        uri
+      end
+    end
+  end
+  
+  class NotTest < TestSelector
+    attr_reader :delegate
+    
+    def initialize delegate
+      @delegate = delegate
+    end
+    
+    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
+      @left = left
+      @right = right
+    end
+    
+    def evaluate program, uri, context
+      left.evaluate(program, uri, context).any? || right.evaluate(program, uri, context).any?
+    end
+  end
+
+  class AndTest < TestSelector    
+
+    attr_reader :left, :right
+    
+    def initialize left, right
+      @left = left
+      @right = right
+    end
+
+    def evaluate program, uri, context
+      left.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
+      @left = left
+      @right = right
+    end
+    
+    def evaluate program, uri, context
+      left.evaluate(program, uri, context).compact.include?(right)
+    end
+  end
+end