ldpath 0.3.1 → 1.0.0

data/lib/ldpath/functions.rb

@@ -1,83 +1,83 @@
 # rubocop:disable Style/MethodName
 module Ldpath
   module Functions
-    def concat(uri, context, *args)
-      args.flatten.compact.join
+    def concat(_uri, _context, *args)
+      deep_flatten_compact(*args).to_a.join
     end
 
-    def first(uri, context, *args)
-      args.flatten.compact.first
+    def first(_uri, _context, *args)
+      deep_flatten_compact(*args).first
     end
 
-    def last(uri, context, *args)
-      args.flatten.compact.last
+    def last(_uri, _context, *args)
+      deep_flatten_compact(*args).to_a.last
     end
 
-    def count(uri, context, *args)
-      args.flatten.compact.length
+    def count(_uri, _context, *args)
+      deep_flatten_compact(*args).count
     end
 
-    def eq(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:eq"
-      end
+    def eq(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:eq" unless rem.empty?
+
       a == b
     end
 
-    def ne(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:ne"
-      end
+    def ne(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:ne" unless rem.empty?
+
       a != b
     end
 
-    def lt(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:lt"
-      end
+    def lt(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:lt" unless rem.empty?
+
       a < b
     end
 
-    def le(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:le"
-      end
+    def le(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:le" unless rem.empty?
+
       a <= b
     end
 
-    def gt(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:gt"
-      end
+    def gt(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:gt" unless rem.empty?
+
       a > b
     end
 
-    def ge(uri, context, *args)
-      a, b, *rem = args.flatten
-      unless rem.empty?
-        raise "Too many arguments to fn:ge"
-      end
+    def ge(_uri, _context, *args)
+      a, b, *rem = deep_flatten_compact(*args).first(3)
+      raise "Too many arguments to fn:ge" unless rem.empty?
+
       a >= b
     end
 
     # collections
     def flatten(uri, context, lists)
-      Array(lists).flatten.map { |x| RDF::List.new(x, context).to_a }.flatten
+      return to_enum(:flatten, uri, context, lists) unless block_given?
+
+      deep_flatten_compact(lists).each do |x|
+        RDF::List.new(subject: x, graph: context).to_a.each do |i|
+          yield i
+        end
+      end
     end
 
     def get(uri, context, list, idx)
       idx = idx.respond_to?(:to_i) ? idx.to_i : idx.to_s.to_i
 
-      flatten(uri, context, list)[idx]
+      flatten(uri, context, list).to_a[idx]
     end
 
     def subList(uri, context, list, idx_start, idx_end = nil)
-      arr = flatten(uri, context, list)
+      arr = flatten(uri, context, list).to_a
 
       idx_start = idx_start.respond_to?(:to_i) ? idx_start.to_i : idx_start.to_s.to_i
       idx_end &&= idx_end.respond_to?(:to_i) ? idx_end.to_i : idx_end.to_s.to_i
@@ -91,102 +91,114 @@ module Ldpath
 
     # dates
 
-    def earliest(uri, context, *args)
-      args.flatten.min
+    def earliest(_uri, _context, *args)
+      deep_flatten_compact(*args).min
     end
 
-    def latest(uri, context, *args)
-      args.flatten.max
+    def latest(_uri, _context, *args)
+      deep_flatten_compact(*args).max
     end
 
     # math
 
-    def min(uri, context, *args)
-      args.flatten.min
+    def min(_uri, _context, *args)
+      deep_flatten_compact(*args).min
     end
 
-    def max(uri, context, *args)
-      args.flatten.max
+    def max(_uri, _context, *args)
+      deep_flatten_compact(*args).max
     end
 
-    def round(uri, context, *args)
-      args.map do |n|
-        Array(n).map do |i|
-          i.respond_to? :round ? i.round : i
-        end
+    def round(_uri, _context, *args)
+      deep_flatten_compact(*args).map do |i|
+        i.respond_to?(:round) ? i.round : i
       end
     end
 
-    def sum(uri, context, *args)
-      args.inject(0) { |sum, n| sum + n }
+    def sum(_uri, _context, *args)
+      args.inject(0) { |acc, elem| acc + elem }
     end
 
     # text
 
-    def replace(uri, context, str, pattern, replacement)
+    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)
+    def strlen(_uri, _context, str)
       Array(str).map(&:length)
     end
 
-    def wc(uri, context, str)
+    def wc(_uri, _context, str)
       Array(str).map { |x| x.split.length }
     end
 
-    def strLeft(uri, context, str, left)
+    def strLeft(_uri, _context, str, left)
       Array(str).map { |x| x[0..left.to_i] }
     end
 
-    def strRight(uri, context, str, right)
+    def strRight(_uri, _context, str, right)
       Array(str).map { |x| x[right.to_i..x.length] }
     end
 
-    def substr(uri, context, str, left, right)
+    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 = "")
+    def strJoin(_uri, _context, str, sep = "", prefix = "", suffix = "")
       prefix + Array(str).join(sep) + suffix
     end
 
-    def equals(uri, context, str, other)
+    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 }
+    def equalsIgnoreCase(_uri, _context, str, other)
+      Array(str).map { |x| x.casecmp(other) }
     end
 
-    def contains(uri, context, str, substr)
+    def contains(_uri, _context, str, substr)
       Array(str).map { |x| x.include? substr }
     end
 
-    def startsWith(uri, context, str, suffix)
+    def startsWith(_uri, _context, str, suffix)
       Array(str).map { |x| x.start_with? suffix }
     end
 
-    def endsWith(uri, context, str, suffix)
+    def endsWith(_uri, _context, str, suffix)
       Array(str).map { |x| x.end_with? suffix }
     end
 
-    def isEmpty(uri, context, str)
+    def isEmpty(_uri, _context, str)
       Array(str).map(&:empty?)
     end
 
-    def predicates(uri, context, *args)
+    def predicates(uri, context, *_args)
       context.query([uri, nil, nil]).map(&:predicate).uniq
     end
 
-    def xpath(uri, context, xpath, node)
+    def xpath(_uri, _context, xpath, node)
       x = Array(xpath).flatten.first
       Array(node).flatten.compact.map do |n|
         Nokogiri::XML(n.to_s).xpath(x.to_s, prefixes.map { |k, v| [k, v.to_s] }).map(&:text)
       end
     end
+
+    private
+
+    def deep_flatten_compact(*args)
+      return to_enum(:deep_flatten_compact, *args) unless block_given?
+
+      args.each do |x|
+        if x.is_a? Enumerable
+          x.each { |y| yield y unless y.nil? }
+        else
+          yield x unless x.nil?
+        end
+      end
+    end
   end
 end

data/lib/ldpath/parser.rb

@@ -116,8 +116,7 @@ module Ldpath
     rule(:identifier) { pn_chars_base >> (str(".").maybe >> pn_chars).repeat }
 
     rule(:pn_chars_base) do
-      # also \u10000-\uEFFFF
-      match("[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]")
+      match("[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]")
     end
 
     rule(:pn_chars) do
@@ -203,7 +202,7 @@ module Ldpath
 
     # ( x = "xyz", y = "abc" )
     rule(:field_type_options) do
-      str("(") >> wsp? >> (field_type_option >> (wsp? >> comma >> wsp? >> field_type_option).repeat).as(:options) >> wsp? >> str(")")
+      group(field_type_option >> (wsp? >> comma >> wsp? >> field_type_option).repeat).as(:options)
     end
 
     # x = "xyz"
@@ -261,7 +260,8 @@ module Ldpath
         literal_selector |
         recursive_path_selector |
         grouped_selector |
-        tap_selector
+        tap_selector |
+        not_property_selector
       )
     end
 
@@ -284,11 +284,11 @@ module Ldpath
     end
 
     rule(:function_without_args) do
-      func >> identifier.as(:fname) >> str("()")
+      func >> identifier.as(:fname) >> group(wsp?)
     end
 
     rule(:function_with_arglist) do
-      func >> identifier.as(:fname) >> str("(") >> wsp? >> arglist.as(:arglist) >> wsp? >> str(")")
+      func >> identifier.as(:fname) >> group(arglist.as(:arglist))
     end
 
     rule(:arglist) do
@@ -322,15 +322,21 @@ module Ldpath
       inverse.as(:reverse) >> iri.as(:property)
     end
 
+    rule(:not_property_selector) do
+      not_one_property_selector
+    end
+
+    rule(:not_one_property_selector) do
+      not_op.as(:not) >> iri.repeat(1, 1).as(:property)
+    end
+
     rule(:literal_selector) do
       literal.as(:literal)
     end
 
     # (x)?; (x)*; (x)+; (x){3,5}
     rule(:recursive_path_selector) do
-      str("(") >> wsp? >>
-        selector.as(:delegate) >> wsp? >>
-        str(")") >>
+      group(selector.as(:delegate)) >>
         range.as(:repeat)
     end
 
@@ -346,18 +352,16 @@ module Ldpath
 
     # (<info:a>)
     rule(:grouped_selector) do
-      str("(") >> wsp? >>
-        selector >> wsp? >>
-        str(")")
+      group(selector)
     end
 
     # ?<a>(<info:a>)
     rule(:tap_selector) do
       question >>
         str("<") >> wsp? >>
-        identifier.as(:identifier) >> wsp? >>
+        (str(">").absent? >> any).repeat(1).as(:identifier) >> wsp? >>
         str(">") >> wsp? >>
-        (atomic_selector).as(:tap)
+        atomic_selector.as(:tap)
     end
 
     # Testing Selectors
@@ -365,8 +369,7 @@ module Ldpath
     rule(:node_test) do
       grouped_test |
         not_test |
-        and_test |
-        or_test |
+        compound_test |
         atomic_node_test
     end
 
@@ -380,31 +383,17 @@ module Ldpath
     end
 
     rule(:grouped_test) do
-      str("(") >> wsp? >>
-        node_test >> wsp? >>
-        str(")")
+      group(node_test)
     end
 
     rule(:not_test) do
-      (
-        not_op >> node_test.as(:delegate)
-      ).as(:not)
+      not_op.as(:not) >> node_test.as(:delegate)
     end
 
-    rule(:and_test) do
-      (
-        atomic_node_test.as(:left) >> wsp? >>
-        and_op >> wsp? >>
-        node_test.as(:right)
-      ).as(:and)
-    end
-
-    rule(:or_test) do
-      (
-        atomic_node_test.as(:left) >> wsp? >>
-        or_op >> wsp? >>
-        node_test.as(:right)
-      ).as(:or)
+    rule(:compound_test) do
+      atomic_node_test.as(:left_test) >> wsp? >>
+        compound_operator.as(:op) >> wsp? >>
+        node_test.as(:right_test)
     end
 
     # @en
@@ -443,5 +432,11 @@ module Ldpath
         atomic_selector
       )
     end
+
+    def group(atom)
+      str("(") >> wsp? >>
+        atom >> wsp? >>
+        str(")")
+    end
   end
 end

data/lib/ldpath/program.rb

@@ -1,8 +1,6 @@
 module Ldpath
   class Program
-    include Ldpath::Functions
-
-    ParseError     = Class.new StandardError
+    ParseError = Class.new StandardError
 
     class << self
       def parse(program, transform_context = {})
@@ -14,7 +12,7 @@ module Ldpath
       def load(program)
         parser.parse(program, reporter: Parslet::ErrorReporter::Deepest.new)
       rescue Parslet::ParseFailed => e
-        fail ParseError, e.cause.ascii_tree
+        raise ParseError, e.parse_failure_cause.ascii_tree
       end
 
       private
@@ -28,73 +26,20 @@ module Ldpath
       end
     end
 
-    attr_reader :mappings, :cache, :loaded, :prefixes, :filters
+    attr_reader :mappings, :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/ && !loaded[uri.to_s]
-        context << load_graph(uri.to_s)
-      end
-    end
-
-    def load_graph(uri)
-      cache[uri] ||= begin
-        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
-        end
-
-        RDF::Graph.load(uri, headers: { 'Accept' => reader_types.join(", ") }).tap { loaded[uri] = true }
-      end
     end
 
-    def evaluate(uri, context = nil)
-      h = {}
-      context ||= load_graph(uri.to_s)
-
+    def evaluate(uri, context: nil, limit_to_context: false)
+      result = Ldpath::Result.new(self, uri, context: context, limit_to_context: limit_to_context)
       unless filters.empty?
-        return h unless filters.all? { |f| f.evaluate(self, uri, context) }
+        return {} unless filters.all? { |f| f.evaluate(result, uri, result.context) }
       end
 
-      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
-      end
-
-      h.merge(meta)
-    end
-
-    def meta
-      @meta ||= {}
-    end
-
-    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
+      result.to_hash
     end
   end
 end

data/lib/ldpath/result.rb

@@ -0,0 +1,83 @@
+module Ldpath
+  class Result
+    include Ldpath::Functions
+    attr_reader :program, :uri, :cache, :loaded
+
+    def initialize(program, uri, cache: RDF::Util::Cache.new, context: nil, limit_to_context: false)
+      @program = program
+      @uri = uri
+      @cache = cache
+      @loaded = {}
+      @context = context
+      @limit_to_context = limit_to_context
+    end
+
+    def loading(uri, context)
+      return unless uri.to_s =~ /^http/
+      return if loaded[uri.to_s]
+
+      context << load_graph(uri.to_s) unless limit_to_context?
+      context
+    end
+
+    def load_graph(uri)
+      cache[uri] ||= begin
+        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 =~ %r{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 [](key)
+      evaluate(mappings.find { |x| x.name == key })
+    end
+
+    def to_hash
+      h = mappings.each_with_object({}) do |mapping, hash|
+        hash[mapping.name] = evaluate(mapping).to_a
+      end
+
+      h.merge(meta)
+    end
+
+    def func_call(fname, uri, context, *arguments)
+      raise "No such function: #{fname}" unless function_method? fname
+
+      public_send(fname, uri, context, *arguments)
+    end
+
+    def context
+      @context ||= load_graph(uri.to_s)
+    end
+
+    def prefixes
+      program.prefixes
+    end
+
+    def meta
+      @meta ||= {}
+    end
+
+    private
+
+    def evaluate(mapping)
+      mapping.evaluate(self, uri, context)
+    end
+
+    def function_method?(function)
+      Functions.public_instance_methods(false).include? function.to_sym
+    end
+
+    def mappings
+      program.mappings
+    end
+
+    def limit_to_context?
+      @limit_to_context
+    end
+  end
+end