ldpath 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7fcb1c90659a5df73d2317bb95e7b6e94a084b6
-  data.tar.gz: 126daa1e8f17111e55ee2778d3b1e0a20a44b486
+  metadata.gz: 154cc858a4b03022c48012acdb9e897c105a7c3f
+  data.tar.gz: 5c99156666f615486d5b8134bcd869e0f9b44590
 SHA512:
-  metadata.gz: 16bbc3af47c263842b9ae8d370103cacc2b23665da21e1420cdd2c667b3c90dd8e0063e34339b8924b8c47aea8eeb4db54d84b4eca0502bfb100be895ec9c467
-  data.tar.gz: d9fc526a8eaa84254990752f45476244bfd826d83136b14c9304bd9316765ab3f4d361431a071967cd87d28f9ee2bafccd2285b83c0ac81e597fe207e00376eb
+  metadata.gz: 6a9879ef3a8345d8c0a5c82ab79b048c9143cd1da9c33b5d53e8940d54187666723c9c67f5114efa9d7e2485aa4c28e8d63c2d43919571f8f955169485106fb2
+  data.tar.gz: 81f9a84ff7d8a761327c833b8acd6a1ff96403c3e512c02fa6c060755817aab69d9382bcaa3782048a2d1d6c7c983528a155b2554a961c71fe4bb711d0fb7d6b

data/README.md

@@ -1,6 +1,6 @@
 # Ldpath
 
-TODO: Write a gem description
+This is a ruby implementation of [LDPath](http://marmotta.apache.org/ldpath/language.html), a language for selecting values linked data resources.
 
 ## Installation
 
@@ -18,8 +18,23 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require 'ldpath'
 
+my_program = <<-EOF
+@prefix dcterms : <http://purl.org/dc/terms/> ;
+title = dcterms:title :: xsd:string ;
+EOF
+
+uri = RDF::URI.new "info:a"
+
+context = RDF::Graph.new << [uri, RDF::DC.title, "Some Title"]
+
+program = Ldpath::Program.parse my_program
+output = program.evaluate uri, context
+# => { ... }
+```
+ 
 ## Contributing
 
 1. Fork it ( http://github.com/<my-github-username>/ldpath/fork )

data/ldpath.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   
   spec.add_dependency "parslet"
+  spec.add_dependency "linkeddata"
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"

data/lib/ldpath.rb

@@ -1,5 +1,18 @@
 require "ldpath/version"
+require 'linkeddata'
 
 module Ldpath
+  require 'ldpath/field_mapping'
+  require 'ldpath/selectors'
+  require 'ldpath/tests'
+  require 'ldpath/parser'
+  require 'ldpath/transform'
+  require 'ldpath/functions'
   require 'ldpath/program'
+  
+  class << self
+    def evaluate program, uri, context
+      Ldpath::Program.parse(program).evaluate(uri, context)
+    end
+  end
 end

data/lib/ldpath/field_mapping.rb

@@ -0,0 +1,2 @@
+class Ldpath::FieldMapping < Struct.new(:name, :selector, :field_type)
+end

data/lib/ldpath/functions.rb

@@ -0,0 +1,144 @@
+module Ldpath
+  module Functions
+    def concat uri, context, *args
+      args.join
+    end
+    
+    def first uri, context, *args
+      args.flatten.compact.first
+    end
+    
+    def last uri, context, *args
+      args.flatten.compact.last
+    end
+    
+    def eq uri, context, *args
+      
+    end
+    
+    def ne uri, context, *args
+      
+    end
+    
+    def lt uri, context, *args
+      
+    end
+    
+    def le uri, context, *args
+      
+    end
+    
+    def gt uri, context, *args
+      
+    end
+    
+    def ge uri, context, *args
+      
+    end
+    
+    # collections
+    def flatten uri, context, *args
+      
+    end
+    
+    def get uri, context, *args
+    end
+    
+    def subList uri, context, *args
+      
+    end
+    
+    # dates
+    
+    def earliest uri, context, *args
+      args.flatten.min
+    end
+    
+    def latest uri, context, *args
+      args.flatten.max
+    end
+    
+    # math
+    
+    def min uri, context, *args
+      args.flatten.min
+    end
+    
+    def max uri, context, *args
+      args.flatten.max
+    end
+    
+    def round uri, context, *args
+      args.map do |n| 
+        Array(n).map do |i|
+          i.respond_to? :round ? i.round : i
+        end
+      end
+    end
+    
+    def sum uri, context, *args
+      args.inject(0) { |sum, n| sum + n }
+    end
+    
+    # text
+    
+    def replace uri, context, str, pattern, replacement
+      regex = Regexp.parse(pattern)
+      Array(str).map do |x|
+        x.gsub(regex, replacement)
+      end
+    end
+    
+    def strlen uri, context, str
+      Array(str).map { |x| x.length }
+    end
+    
+    def wc uri, context, str
+      Array(str).map { |x| x.split.length }
+    end
+    
+    def strLeft uri, context, str, left
+      Array(str).map { |x| x[0..left.to_i] }
+    end
+    
+    def strRight uri, context, str, right
+      Array(str).map { |x| x[right.to_i..x.length] }
+    end
+    
+    def substr uri, context, str, left, right
+      Array(str).map { |x| x[left.to_i..right.to_i] }
+    end
+    
+    def strJoin uri, context, str, sep = "", prefix = "", suffix = ""
+      prefix + Array(str).join(sep) + suffix
+    end
+    
+    def equals uri, context, str, other
+      Array(str).map { |x| x == other }
+    end
+    
+    def equalsIgnoreCase uri, context, str, other
+      Array(str).map { |x| x.downcase == other.downcase }
+    end
+    
+    def contains uri, context, str, substr
+      Array(str).map { |x| x.include? substr }
+    end
+    
+    def startsWith uri, context, str, suffix
+      
+      Array(str).map { |x| x.start_with? suffix }
+    end
+    
+    def endsWith uri, context, str, suffix
+      
+      Array(str).map { |x| x.end_with? suffix }
+    end
+    
+    def isEmpty uri, context, str
+      
+      Array(str).map(&:empty?)
+    end
+  
+  end
+end

data/lib/ldpath/parser.rb

@@ -0,0 +1,358 @@
+require 'parslet'
+
+module Ldpath
+  class Parser < Parslet::Parser
+    root :lines
+    rule(:lines) { line.repeat }
+    rule(:line) { expression >> wsp? >> (newline | eof) }
+
+    rule(:newline) {  (str("\n") >> str("\r").maybe).repeat(1) }
+    rule(:eof) { any.absent? }
+    rule(:wsp) { (match["\\t "] | multiline_comment).repeat(1) }
+    rule(:wsp?) { wsp.maybe }
+    rule(:multiline_comment) { (str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') ) }
+
+    rule(:expression) { wsp | namespace | mapping | graph }
+    
+    rule(:int) { match("\\d+") }
+    
+    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 "@" }
+    
+    # todo: fixme
+    rule(:uri) do
+      uri_in_brackets | 
+      prefix_and_localname
+    end
+    
+    rule(:uri_in_brackets) do
+      str("<") >> (str(">").absent? >> any).repeat.as(:uri) >> str(">")
+    end
+    
+    rule(:prefix_and_localname) do
+      (identifier.as(:prefix) >> str(":") >> identifier.as(:localName)).as(:uri)
+    end
+    
+    rule(:identifier) { match["a-zA-Z0-9_"] >> (match["a-zA-Z0-9_'\\.-"]).repeat }
+
+    rule(:strlit) {
+      wsp? >> 
+      str('"') >> (str("\\") >> str("\"") | (str('"').absent? >> any)).repeat.as(:literal) >> str('"') >> 
+      wsp?
+    }
+
+    rule(:node) {
+      uri.as(:uri) | strlit.as(:literal)
+    }
+
+    # @prefix id = uri ;
+    rule(:namespace) { 
+      (
+      wsp? >>
+      k_prefix >> wsp? >>
+      identifier.as(:id) >> wsp? >>
+      colon >> wsp? >>
+      uri.as(:uri) >> wsp? >>
+      scolon.maybe >> wsp?
+      ).as(:namespace)
+    }
+    
+    # @graph uri, uri, uri ;
+    rule(:graph) {
+      k_graph >> wsp? >> 
+      uri_list.as(:graphs) >> wsp? >> 
+      scolon
+    }
+    
+    rule(:uri_list) {
+      wsp? >> 
+      uri.as(:uri) >>
+      (
+        wsp? >> 
+        comma >> wsp? >> 
+        uri_list.as(:rest)
+      ).repeat
+    }
+    
+    # id = . ;
+    rule(:mapping) {
+      (
+        identifier.as(:name) >> wsp? >>
+        assign >> wsp? >>
+        selector.as(:selector) >> wsp? >>
+        (
+          dcolon >> wsp? >>
+          uri.as(:field_type)
+        ).maybe >> wsp? >>
+        scolon
+      ).as(:mapping)
+    }
+
+
+    # selector groups
+    rule(:selector) {
+      (
+        compound_selector |
+        testing_selector |
+        atomic_selector
+      )
+    }
+
+    rule(:compound_selector) {
+      (
+        union_selector |
+        intersection_selector |
+        path_selector
+      )
+    }
+    
+    rule(:testing_selector) {
+      wsp? >>
+      atomic_selector.as(:delegate) >>
+      str("[") >> wsp? >>
+      node_test.as(:test) >> wsp? >>
+      str("]") >> wsp?
+    }
+
+    rule(:atomic_selector) {
+      (
+        self_selector |
+        function_selector |
+        property_selector |
+        wildcard_selector | 
+        reverse_property_selector |
+        string_constant_selector |
+        recursive_path_selector |
+        grouped_selector
+      )
+    }    
+
+    rule(:atomic_or_testing_selector) {
+      (testing_selector | atomic_selector)
+    }
+
+    rule(:atomic_or_testing_or_path_selector) {
+      (path_selector | atomic_or_testing_selector)
+    }
+
+    # Compound selectors
+    ## x / y
+    rule(:path_selector) {
+      (
+        wsp? >>
+        atomic_or_testing_selector.as(:left) >> wsp? >>
+        p_sep >> wsp? >>
+        atomic_or_testing_or_path_selector.as(:right) >> wsp?
+      ).as(:path)
+    }
+    
+    ## x & y
+    rule(:intersection_selector) {
+      (
+        wsp? >>
+        atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
+        and_op >> wsp? >>
+        selector.as(:right) >> wsp?
+      ).as(:intersection)
+    }
+    
+    ## x | y
+    rule(:union_selector) {
+      (
+        wsp? >>
+        atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
+        or_op >> wsp? >>
+        selector.as(:right) >> wsp?
+      ).as(:union)
+    }
+
+    # Atomic Selectors
+    rule(:self_selector) {
+      wsp? >> 
+      self_op.as(:self) >> wsp?
+    }
+    
+    # fn:x() or fn:x(1,2,3)
+    rule(:function_selector) {
+      func >> identifier.as(:fname) >> str("()") |
+      func >> identifier.as(:fname) >> str("(") >> arglist.as(:arglist) >> str(")")
+    }
+    
+    rule(:arglist) {
+      wsp? >>
+      selector >> 
+      (
+        wsp? >> 
+        comma >> wsp? >> 
+        selector
+      ).repeat >>
+      wsp?
+    }
+
+    # xyz
+    rule(:property_selector) {
+      wsp? >> 
+      uri.as(:property) >> wsp?
+    }
+
+    # *
+    rule(:wildcard_selector) {
+      wsp? >> 
+      star.as(:wildcard) >> wsp?
+    }
+
+    # ^xyz
+    rule(:reverse_property_selector) {
+      wsp? >> 
+      inverse >> uri.as(:reverse_property) >> wsp?
+    }
+    
+    rule(:string_constant_selector) {
+      strlit
+    }
+    
+    # (x)*
+    rule(:recursive_path_selector) {
+      (
+        wsp? >> 
+        str("(") >> wsp? >>
+        selector.as(:delegate) >> wsp? >> 
+        str(")") >>
+        (
+          star |
+          plus |
+          (str("{") >> wsp? >> int.as(:min).maybe >> wsp? >>str(",") >> wsp? >> int.as(:max).maybe >> wsp? >>str("}") ).as(:range)
+        ).as(:repeat) >> wsp?
+      ).as(:recursive)
+    }
+    
+    rule(:grouped_selector) {
+      wsp? >>
+      str("(") >> wsp? >> 
+      selector >> wsp? >> 
+      str(")") >> wsp?
+    }
+    
+    # Testing Selectors
+    
+    rule(:node_test) {
+      grouped_test |
+      not_test |
+      and_test |
+      or_test  |
+      atomic_node_test
+    }
+
+    rule(:atomic_node_test) {
+      literal_language_test |
+      literal_type_test |
+      is_a_test |
+      path_equality_test |
+      function_test |
+      path_test
+    }
+
+    rule(:grouped_test) {
+      wsp? >> 
+      str("(")  >> wsp? >> 
+      node_test >> wsp? >> 
+      str(")")  >> wsp?
+    }
+    
+    rule(:not_test) {
+      (
+        wsp? >> 
+        not_op >> node_test.as(:delegate) >> 
+        wsp?
+      ).as(:not)
+    }
+    
+    rule(:and_test) {
+      (
+        wsp? >> 
+        atomic_node_test.as(:left) >> wsp? >> 
+        and_op >> wsp? >> 
+        node_test.as(:right) >> wsp?
+      ).as(:and)
+    }
+    
+    rule(:or_test) {
+      (
+        wsp? >> 
+        atomic_node_test.as(:left) >> wsp? >> 
+        or_op >> wsp? >> 
+        node_test.as(:right) >> wsp?
+      ).as(:or)
+    }
+
+    # @en
+    rule(:literal_language_test) {
+      wsp? >> 
+      lang >> identifier.as(:lang) >> 
+      wsp?
+    }
+    
+    # ^^xyz
+    rule(:literal_type_test) {
+      wsp? >> 
+      type >> uri.as(:type) >> 
+      wsp?
+    }
+    
+    rule(:is_a_test) {
+      (
+        wsp? >> 
+        is_a >> wsp? >> 
+        node.as(:right) >> 
+        wsp?
+      ).as(:is_a)
+    }
+    
+    rule(:path_equality_test) {
+      (
+        wsp? >>
+        selector >> wsp? >>
+        is >> wsp? >>
+        node.as(:right) >> wsp?
+      ).as(:is)
+    }
+    
+    rule(:function_test) {
+      wsp? >>
+      (
+      func >> identifier.as(:fname) >> str("()") |
+      func >> identifier.as(:fname) >> str("(") >>
+          arglist.as(:arglist) >>
+      str(")")
+      ) >> wsp?
+    }
+
+    rule(:path_test) {
+      (
+        path_selector |
+        testing_selector |
+        atomic_selector
+      )
+    }
+
+  end
+end