safrano 0.4.0 → 0.4.5

data/lib/odata/filter/sequel_function_adapter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative './tree'
+require_relative './sequel'
+
+module Safrano
+  module Filter
+    # sqlite adapter specific function handler
+    module FuncTreeSqlite
+      def substringof_sig2(jh)
+        # substringof(name, '__Route du Rhum__')  -->
+        # '__Route du Rhum__' contains name as a substring
+        # sqlite uses instr()
+        Contract.collect_result!(args[1].leuqes(jh),
+                                 args[0].leuqes(jh)) do |l1, l0|
+          substr_func = Sequel.function(:instr, l1, l0)
+          Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        end
+      end
+      # %d		day of month: 00
+      # %f		fractional seconds: SS.SSS
+      # %H		hour: 00-24
+      # %j		day of year: 001-366
+      # %J		Julian day number
+      # %m		month: 01-12
+      # %M		minute: 00-59
+      # %s		seconds since 1970-01-01
+      # %S		seconds: 00-59
+      # %w		day of week 0-6 with Sunday==0
+      # %W		week of year: 00-53
+      # %Y		year: 0000-9999
+      # %%		%
+
+      # sqlite does not have extract but recommends to use strftime
+      def year(lq)
+        Sequel.function(:strftime, '%Y', lq).cast(:integer)
+      end
+
+      def month(lq)
+        Sequel.function(:strftime, '%m', lq).cast(:integer)
+      end
+
+      def second(lq)
+        Sequel.function(:strftime, '%S', lq).cast(:integer)
+      end
+
+      def minute(lq)
+        Sequel.function(:strftime, '%M', lq).cast(:integer)
+      end
+
+      def hour(lq)
+        Sequel.function(:strftime, '%H', lq).cast(:integer)
+      end
+
+      def day(lq)
+        Sequel.function(:strftime, '%d', lq).cast(:integer)
+      end
+
+      def floor(_lq)
+        Safrano::FilterFunctionNotImplementedError.new("$filter function 'floor' is not implemented in sqlite adapter")
+      end
+
+      def ceiling(_lq)
+        Safrano::FilterFunctionNotImplementedError.new("$filter function 'ceiling' is not implemented in sqlite adapter")
+      end
+    end
+    # re-useable module with math floor/ceil functions for those adapters having these SQL funcs
+    module MathFloorCeilFuncTree
+      def floor(lq)
+        success Sequel.function(:floor, lq)
+      end
+
+      def ceiling(lq)
+        success Sequel.function(:ceil, lq)
+      end
+    end
+
+    # re-useable module with Datetime functions with extract()
+    module DateTimeFuncTreeExtract
+      def year(lq)
+        lq.extract(:year)
+      end
+
+      def month(lq)
+        lq.extract(:month)
+      end
+
+      def second(lq)
+        lq.extract(:second)
+      end
+
+      def minute(lq)
+        lq.extract(:minute)
+      end
+
+      def hour(lq)
+        lq.extract(:hour)
+      end
+
+      def day(lq)
+        lq.extract(:day)
+      end
+    end
+
+    # postgresql adapter specific function handler
+    module FuncTreePostgres
+      def substringof_sig2(jh)
+        # substringof(name, '__Route du Rhum__')  -->
+        # '__Route du Rhum__' contains name as a substring
+        # postgres does not know instr() but has strpos
+        Contract.collect_result!(args[1].leuqes(jh),
+                                 args[0].leuqes(jh)) do |l1, l0|
+          substr_func = Sequel.function(:strpos, l1, l0)
+          Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        end
+      end
+
+      # postgres uses extract()
+      include DateTimeFuncTreeExtract
+
+      # postgres has floor/ceil funcs
+      include MathFloorCeilFuncTree
+    end
+
+    # default adapter  function handler for all others... try to use the most common version
+    # :substring --> instr because here is seems Postgres is special
+    # datetime funcs --> exctract, here sqlite is special(uses format)
+    # note: we dont test this, provided as an example/template, might work eg for mysql
+    module FuncTreeDefault
+      def substringof_sig2(jh)
+        # substringof(name, '__Route du Rhum__')  -->
+        # '__Route du Rhum__' contains name as a substring
+        # instr() seems to be the most common substring func
+        Contract.collect_result!(args[1].leuqes(jh),
+                                 args[0].leuqes(jh)) do |l1, l0|
+          substr_func = Sequel.function(:instr, l1, l0)
+          Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        end
+      end
+
+      # XYZ uses extract() ?
+      include DateTimeFuncTreeExtract
+
+      # ... assume SQL
+      include MathFloorCeilFuncTree
+    end
+  end
+end

data/lib/odata/filter/token.rb

@@ -1,19 +1,24 @@
-# top level OData namespace
-module OData
+# frozen_string_literal: true
+
+module Safrano
   module Filter
     class Parser
       # Input tokenizer
       module Token
         FUNCNAMES = %w[concat substringof endswith startswith length indexof
-                       replace substring trim toupper tolower].freeze
-        FUNCRGX = FUNCNAMES.join('|').freeze
-        QSTRINGRGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
-        BINOBOOL = '[eE][qQ]|[LlgGNn][eETt]|[aA][nN][dD]|[oO][rR]'.freeze
-        BINOARITHM = '[aA][dD][dD]|[sS][uU][bB]|[mM][uU][lL]|[dD][iI][vV]|[mM][oO][dD]'.freeze
-        NOTRGX = 'not|NOT'.freeze
-        FPRGX = '\d+(?:\.\d+)?(?:e[+-]?\d+)?'.freeze
-        QUALITRGX = '\w+(?:\/\w+)+'.freeze
-        RGX = /(#{FUNCRGX})|([\(\),])|(#{BINOBOOL})|(#{BINOARITHM})|(#{NOTRGX})|#{QSTRINGRGX}|(#{FPRGX})|(#{QUALITRGX})|(\w+)|(')/.freeze
+                       replace substring trim toupper tolower
+                       day hour minute month second year
+                       round floor ceiling].freeze
+        FUNCRGX = FUNCNAMES.join('|')
+        NULLRGX = 'null|NULL|Null'
+        QSTRINGRGX = /'((?:[^']|(?:'{2}))*)'/.freeze
+        BINOBOOL = '[eE][qQ]|[LlgGNn][eETt]|[aA][nN][dD]|[oO][rR]'
+        BINOARITHM = '[aA][dD][dD]|[sS][uU][bB]|[mM][uU][lL]|[dD][iI][vV]|[mM][oO][dD]'
+        NOTRGX = 'not|NOT|Not'
+        FPRGX = '\d+(?:\.\d+)?(?:e[+-]?\d+)?'
+        QUALITRGX = '\w+(?:\/\w+)+'
+        RGX = /(#{FUNCRGX})|(#{NULLRGX})|([\(\),])|(#{BINOBOOL})\s+|(#{BINOARITHM})|(#{NOTRGX})|#{QSTRINGRGX}|(#{FPRGX})|(#{QUALITRGX})|(\w+)|(')/.freeze
+
         def each_typed_token(inp)
           typ = nil
 
@@ -30,27 +35,29 @@ module OData
                   when 0
                     :FuncTree
                   when 1
+                    :NullLiteral
+                  when 2
                     case found
                     when '(', ')'
                       :Delimiter
                     when ','
                       :Separator
                     end
-                  when 2
-                    :BinopBool
                   when 3
-                    :BinopArithm
+                    :BinopBool
                   when 4
-                    :UnopTree
+                    :BinopArithm
                   when 5
-                    :QString
+                    :UnopTree
                   when 6
-                    :FPNumber
+                    :QString
                   when 7
-                    :Qualit
+                    :FPNumber
                   when 8
-                    :Literal
+                    :Qualit
                   when 9
+                    :Literal
+                  when 10
                     :unmatchedQuote
                   end
             yield found, typ

data/lib/odata/filter/tree.rb

@@ -1,10 +1,14 @@
-require_relative './error.rb'
+# frozen_string_literal: true
 
-module OData
+require_relative './base'
+require_relative './error'
+
+module Safrano
   module Filter
     # Base class for Leaves, Trees, RootTrees etc
     class Node
       attr_reader :value
+
       def initialize(val, &block)
         @value = val
         instance_eval(&block) if block_given?
@@ -16,19 +20,26 @@ module OData
     end
 
     # Leaves are Nodes with a parent but no children
-    class Leave < Node
+    class Leave
       attr_accessor :parent
+
+      # nil is considered as accepted, otherwise non-nil=the error
       def accept?(tok, typ)
-        [false, Parser::ErrorInvalidToken(tok, typ)]
+        Parser::ErrorInvalidToken(tok, typ)
       end
 
       def check_types; end
+
+      def attach(_child)
+        Safrano::Filter::Parser::ErrorLeaveChild
+      end
     end
 
     # RootTrees have childrens but no parent
-    class RootTree < Node
+    class RootTree
       attr_reader :children
       attr_accessor :state
+
       def initialize(val: :root, &block)
         @children = []
         super(val, &block)
@@ -37,6 +48,7 @@ module OData
       def attach(child)
         child.parent = self
         @children << child
+        Contract::OK
       end
 
       def detach(child)
@@ -50,28 +62,32 @@ module OData
 
       def update_state(tok, typ) end
 
+      # nil is considered as accepted, otherwise non-nil=the error
       def accept?(tok, typ)
         case typ
-        when :Literal, :Qualit, :QString, :FuncTree, :ArgTree, :UnopTree, :FPNumber
-          true
+        when :Literal, :NullLiteral, :Qualit, :QString, :FuncTree, :ArgTree,
+             :UnopTree, :FPNumber
+          nil
         when :Delimiter
           if tok == '('
-            true
+            nil
           else
-            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+            Parser::ErrorInvalidToken.new(tok, typ, self)
           end
         else
-          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          Parser::ErrorInvalidToken.new(tok, typ, self)
         end
       end
 
       def check_types
-        @children.each(&:check_types)
+        err = nil
+        @children.find { |c| (err = c.check_types) }
+        err
       end
     end
 
     # Tree's have Parent and children
-    class Tree < RootTree
+    class Tree
       attr_accessor :parent
 
       def initialize(val)
@@ -80,7 +96,7 @@ module OData
     end
 
     # For functions... should have a single child---> the argument list
-    class FuncTree < Tree
+    class FuncTree
       def initialize(val)
         super(val.downcase.to_sym)
       end
@@ -117,10 +133,11 @@ module OData
         end
       end
 
+      # nil is considered as accepted, otherwise non-nil=the error
       def accept?(tok, typ)
         case typ
         when :BinopBool, :BinopArithm
-          true
+          nil
         else
           super(tok, typ)
         end
@@ -131,9 +148,9 @@ module OData
         when :length
           argtyp = args.first.edm_type
           if (argtyp != :any) && (argtyp != :string)
-            raise Parser::ErrorInvalidArgumentType.new(self,
-                                                       expected: :string,
-                                                       actual: argtyp)
+            return Parser::ErrorInvalidArgumentType.new(self,
+                                                        expected: :string,
+                                                        actual: argtyp)
           end
         end
         super
@@ -143,24 +160,44 @@ module OData
     # Indentity Func to use as "parent" func of parenthesis expressions
     # --> allow to handle generically parenthesis always as argument of
     # some function
-    class IdentityFuncTree < FuncTree
+    class IdentityFuncTree
       def initialize
         super(:__indentity)
       end
 
       # we can have parenthesis with one expression inside everywhere
       # only in FuncTree this is redefined for the function's arity
+      # Note: if you change this method, please also update arity_full_monkey?
+      #       see below
       def arity_full?(cursize)
         cursize >= 1
       end
 
+      # this is for testing only.
+      # see 99_threadsafe_tc.rb
+      # there we will monkey patch  arity_full? by adding some sleeping
+      # to easily slow down a given test-thread (while the other one runs normaly)
+      #
+      # The rule is to keep this method here exactly same as the original
+      #   "productive" one
+      #
+      # With this trick we can test  threadsafeness without touching
+      # "productive" code
+      def arity_full_monkey?(cursize)
+        cursize >= 1
+      end
+
       def edm_type
         @children.first.edm_type
       end
+
+      def ==(other)
+        @children == other.children
+      end
     end
 
     # unary op eg. NOT
-    class UnopTree < Tree
+    class UnopTree
       def initialize(val)
         super(val.downcase.to_sym)
       end
@@ -187,7 +224,7 @@ module OData
     end
 
     # Bin ops
-    class BinopTree < Tree
+    class BinopTree
       def initialize(val)
         @state = :open
         super(val.downcase.to_sym)
@@ -195,13 +232,13 @@ module OData
 
       def update_state(_tok, typ)
         case typ
-        when :Literal, :Qualit, :QString, :FuncTree, :BinopBool, :BinopArithm, :UnopTree, :FPNumber
+        when :Literal, :NullLiteral, :Qualit, :QString, :FuncTree, :BinopBool, :BinopArithm, :UnopTree, :FPNumber
           @state = :closed
         end
       end
     end
 
-    class BinopBool < BinopTree
+    class BinopBool
       # reference:
       # OData v4 par 5.1.1.9 Operator Precedence
       def precedence
@@ -224,7 +261,7 @@ module OData
       end
     end
 
-    class BinopArithm < BinopTree
+    class BinopArithm
       # reference:
       # OData v4 par 5.1.1.9 Operator Precedence
       def precedence
@@ -238,15 +275,16 @@ module OData
         end
       end
 
-      # TODO different num types?
+      # TODO: different num types?
       def edm_type
         :any
       end
     end
 
     # Arguments or lists
-    class ArgTree < Tree
+    class ArgTree
       attr_reader :type
+
       def initialize(val)
         @type = :expression
         @state = :open
@@ -259,47 +297,48 @@ module OData
           @state = :closed
         when :Separator
           @state =  :sep
-        when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
+        when :Literal, :NullLiteral, :Qualit, :QString, :FuncTree, :FPNumber
           @state =  :val
         end
       end
 
+      # nil is considered as accepted, otherwise non-nil=the error
       def accept?(tok, typ)
         case typ
         when :Delimiter
           if @value == '(' && tok == ')' && @state != :closed
-            if @parent.arity_full?(@children.size)
-              true
+            if (@parent.class == IdentityFuncTree) or
+               (@parent.arity_full?(@children.size))
+
+              nil
             else
-              [false, Parser::ErrorInvalidArity.new(tok, typ, self)]
+              Parser::ErrorInvalidArity.new(tok, typ, self)
             end
           else
-            [false, Parser::ErrorUnmatchedClose.new(tok, typ, self)]
+            if @value == '(' && tok == '(' && @state == :open
+              nil
+            else
+              Parser::ErrorUnmatchedClose.new(tok, typ, self)
+            end
           end
         when :Separator
           if @value == '(' && tok == ',' && @state == :val
-            true
-          else
-            if (@state == :sep)
-              [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
-            else
-              true
-            end
+            nil
+          elsif @state == :sep
+            Parser::ErrorInvalidToken.new(tok, typ, self)
           end
-        when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
+        when :Literal, :NullLiteral, :Qualit, :QString, :FuncTree, :FPNumber
           if (@state == :open) || (@state == :sep)
             if @parent.arity_full?(@children.size)
-              [false, Parser::ErrorInvalidArity.new(tok, typ, self)]
-            else
-              true
+              Parser::ErrorInvalidArity.new(tok, typ, self)
             end
           else
-            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+            Parser::ErrorInvalidToken.new(tok, typ, self)
           end
         when :BinopBool, :BinopArithm
-          true
+          nil
         else
-          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          Parser::ErrorInvalidToken.new(tok, typ, self)
         end
       end
 
@@ -309,13 +348,13 @@ module OData
     end
 
     # Numbers (floating point, ints, dec)
-    class FPNumber < Leave
+    class FPNumber
       def accept?(tok, typ)
         case typ
         when :Delimiter, :Separator, :BinopBool, :BinopArithm
-          true
+          nil
         else
-          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          Parser::ErrorInvalidToken.new(tok, typ, self)
         end
       end
 
@@ -326,54 +365,65 @@ module OData
     end
 
     # Literals are unquoted words without /
-    class Literal < Leave
+    class Literal
       def accept?(tok, typ)
         case typ
         when :Delimiter, :Separator, :BinopBool, :BinopArithm
-          true
+          nil
         else
-          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          Parser::ErrorInvalidToken.new(tok, typ, self)
         end
       end
 
       def edm_type
         :any
       end
+
+      # error, Literal are leaves
+      # when the child is a IdentityFuncTree then this looks like
+      # an attempt to use a unknown function, eg. ceil(Total)
+      # instead of ceiling(Total)
+      def attach(child)
+        if child.is_a? Safrano::Filter::IdentityFuncTree
+          Safrano::FilterUnknownFunctionError.new(value)
+        else
+          super
+        end
+      end
     end
 
     # Qualit (qualified lits) are words separated by /
     # path/path/path/attrib
-    class Qualit < Literal
+    class Qualit
       REGEXP = /((?:\w+\/)+)(\w+)/.freeze
       attr_reader :path
       attr_reader :attrib
+
       def initialize(val)
         super(val)
         # split into path + attrib
-        if (md = REGEXP.match(val))
-          @path = md[1].chomp('/')
-          @attrib = md[2]
-        else
-          raise Parser::Error.new(self, Qualit)
-        end
+        raise Parser::Error.new(self, Qualit) unless (md = REGEXP.match(val))
+
+        @path = md[1].chomp('/')
+        @attrib = md[2]
       end
     end
 
     # Quoted Strings
-    class QString < Leave
-      DoubleQuote = "''".freeze
-      SingleQuote = "'".freeze
+    class QString
+      DBL_QO = "''"
+      SI_QO = "'"
       def initialize(val)
         # unescape double quotes
-        super(val.gsub(DoubleQuote, SingleQuote))
+        super(val.gsub(DBL_QO, SI_QO))
       end
 
       def accept?(tok, typ)
         case typ
         when :Delimiter, :Separator, :BinopBool, :BinopArithm
-          true
+          nil
         else
-          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          Parser::ErrorInvalidToken.new(tok, typ, self)
         end
       end