safrano 0.4.3 → 0.5.1

data/lib/odata/filter/parse.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
-require_relative './token.rb'
-require_relative './tree.rb'
-require_relative './error.rb'
+require_relative './token'
+require_relative './tree'
+require_relative './error'
 
-# top level OData namespace
-module OData
+# top level Safrano namespace
+module Safrano
   # for handling $filter
   module Filter
     # Parser for $filter input
     class Parser
       include Token
       attr_reader :cursor
+      attr_reader :error
+
       def initialize(input)
         @tree = RootTree.new
         @cursor = @tree
@@ -20,10 +22,14 @@ module OData
         @binop_stack = []
       end
 
+      def server_error
+        (@error = ::Safrano::ServerError)
+      end
+
       def grow_at_cursor(child)
-        raise 'unknown BroGrammingError' if @cursor.nil?
+        return server_error if @cursor.nil?
 
-        @cursor.attach(child)
+        @cursor.attach(child).tap_error { |err| return (@error = err) }
         @cursor = child
       end
 
@@ -42,7 +48,7 @@ module OData
       def insert_before_cursor(node)
         left = detach_cursor
         grow_at_cursor(node)
-        @cursor.attach(left)
+        @cursor.attach(left).tap_error { |err| return (@error = err) }
       end
 
       def invalid_separator_error(tok, typ)
@@ -58,12 +64,7 @@ module OData
       end
 
       def with_accepted(tok, typ)
-        acc, err = @cursor.accept?(tok, typ)
-        if acc
-          yield
-        else
-          @error = err
-        end
+        (err = @cursor.accept?(tok, typ)) ? (@error = err) : yield
       end
 
       def build
@@ -71,15 +72,19 @@ module OData
           case typ
           when :FuncTree
             with_accepted(tok, typ) { grow_at_cursor(FuncTree.new(tok)) }
+
           when :Delimiter
             case tok
             when '('
               with_accepted(tok, typ) do
                 grow_at_cursor(IdentityFuncTree.new) unless @cursor.is_a? FuncTree
-                openarg = ArgTree.new('(')
-                @stack << openarg
-                grow_at_cursor(openarg)
+                unless @error
+                  openarg = ArgTree.new('(')
+                  @stack << openarg
+                  grow_at_cursor(openarg)
+                end
               end
+
             when ')'
               break invalid_closing_delimiter_error(tok, typ) unless (@cursor = @stack.pop)
 
@@ -123,6 +128,7 @@ module OData
               end
               insert_before_cursor(binoptr)
             end
+
           when :BinopArithm
             with_accepted(tok, typ) do
               binoptr = BinopArithm.new(tok)
@@ -145,6 +151,12 @@ module OData
               grow_at_cursor(Literal.new(tok))
             end
 
+          when :NullLiteral
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+              grow_at_cursor(NullLiteral.new(tok))
+            end
+
           when :Qualit
             with_accepted(tok, typ) do
               @cursor.update_state(tok, typ)
@@ -162,19 +174,21 @@ module OData
               @cursor.update_state(tok, typ)
               grow_at_cursor(FPNumber.new(tok))
             end
+
           when :unmatchedQuote
             break unmatched_quote_error(tok, typ)
+
+          when :space
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+            end
           else
-            raise 'Severe Error'
+            server_error
           end
-          break if @error
-        end
-        begin
-          @tree.check_types unless @error
-        rescue ErrorInvalidArgumentType => e
-          @error = e
+          break(@error) if @error
         end
-        @error || @tree
+        (@error = @tree.check_types) unless @error
+        @error ? @error : Contract.valid(@tree)
       end
     end
   end

data/lib/odata/filter/sequel.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative './base.rb'
-require_relative './sequel_function_adapter.rb'
+require_relative './base'
+require_relative './sequel_function_adapter'
 
-module OData
+module Safrano
   module Filter
     # Base class for Leaves, Trees, RootTrees etc
     #    class Node
@@ -16,8 +16,9 @@ module OData
     # RootTrees have childrens but no parent
     class RootTree
       def apply_to_dataset(dtcx, jh)
-        filtexpr = @children.first.leuqes(jh)
-        jh.dataset(dtcx).where(filtexpr).select_all(jh.start_model.table_name)
+        @children.first.leuqes(jh).if_valid do |filtexpr|
+          jh.dataset(dtcx).where(filtexpr).select_all(jh.start_model.table_name)
+        end
       end
 
       def sequel_expr(jh)
@@ -36,62 +37,102 @@ module OData
       def leuqes(jh)
         case @value
         when :startswith
-          Sequel.like(args[0].leuqes(jh),
-                      args[1].leuqes_starts_like(jh))
+          Contract.collect_result!(args[0].leuqes(jh),
+                                   args[1].leuqes_starts_like(jh)) do |l0, l1|
+            Sequel.like(l0, l1)
+          end
+
         when :endswith
-          Sequel.like(args[0].leuqes(jh),
-                      args[1].leuqes_ends_like(jh))
+          Contract.collect_result!(args[0].leuqes(jh),
+                                   args[1].leuqes_ends_like(jh)) do |l0, l1|
+            Sequel.like(l0, l1)
+          end
+
         when :substringof
 
           # there are multiple possible argument types (but all should return edm.string)
           if args[0].is_a?(QString)
             # substringof('Rhum', name)  -->
             # name contains substr 'Rhum'
-            Sequel.like(args[1].leuqes(jh),
-                        args[0].leuqes_substringof_sig1(jh))
+            Contract.collect_result!(args[1].leuqes(jh),
+                                     args[0].leuqes_substringof_sig1(jh)) do |l1, l0|
+              Sequel.like(l1, l0)
+            end
+
           # special non standard (ui5 client) case ?
           elsif args[0].is_a?(Literal) && args[1].is_a?(Literal)
-            Sequel.like(args[1].leuqes(jh),
-                        args[0].leuqes_substringof_sig1(jh))
+            Contract.collect_result!(args[1].leuqes(jh),
+                                     args[0].leuqes_substringof_sig1(jh)) do |l1, l0|
+              Sequel.like(l1, l0)
+            end
+
           elsif args[1].is_a?(QString)
             substringof_sig2(jh) # adapter specific
           else
             # TODO... actually not supported?
-            raise OData::Filter::Parser::ErrorFunctionArgumentType
+            raise Safrano::Filter::Parser::ErrorFunctionArgumentType
           end
         when :concat
-          Sequel.join([args[0].leuqes(jh),
-                       args[1].leuqes(jh)])
+          Contract.collect_result!(args[0].leuqes(jh),
+                                   args[1].leuqes(jh)) do |l0, l1|
+            Sequel.join([l0, l1])
+          end
+
         when :length
-          Sequel.char_length(args.first.leuqes(jh))
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.char_length(l) }
+
         when :trim
-          Sequel.trim(args.first.leuqes(jh))
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.trim(l) }
+
         when :toupper
-          Sequel.function(:upper, args.first.leuqes(jh))
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.function(:upper, l)  }
+
         when :tolower
-          Sequel.function(:lower, args.first.leuqes(jh))
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.function(:lower, l)  }
+
         # all datetime funcs are adapter specific (because sqlite does not have extract)
         when :year
-          year(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| year(l) }
+
         when :month
-          month(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| month(l) }
+
         when :second
-          second(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| second(l) }
+
         when :minute
-          minute(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| minute(l) }
+
         when :hour
-          hour(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| hour(l) }
+
         when :day
-          day(jh)
+          args.first.leuqes(jh)
+              .map_result! { |l| day(l) }
+
         # math functions
         when :round
-          Sequel.function(:round, args.first.leuqes(jh))
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.function(:round, l) }
+
         when :floor
-          floor(jh)
+          args.first.leuqes(jh)
+              .if_valid { |l| floor(l) }
+
         when :ceiling
-          ceiling(jh)
+          args.first.leuqes(jh)
+              .if_valid { |l| ceiling(l) }
         else
-          raise OData::FilterParseError
+          Safrano::FilterParseError
         end
       end
     end
@@ -110,9 +151,9 @@ module OData
       def leuqes(jh)
         case @value
         when :not
-          Sequel.~(@children.first.leuqes(jh))
+          @children.first.leuqes(jh).map_result! { |l| Sequel.~(l) }
         else
-          raise OData::FilterParseError
+          Safrano::FilterParseError
         end
       end
     end
@@ -138,12 +179,19 @@ module OData
                     when :and
                       :AND
                     else
-                      raise OData::FilterParseError
+                      return Safrano::FilterParseError
                     end
-
-        Sequel::SQL::BooleanExpression.new(leuqes_op,
-                                           @children[0].leuqes(jh),
-                                           @children[1].leuqes(jh))
+        Contract.collect_result!(@children[0].leuqes(jh),
+                                 @children[1].leuqes(jh)) do |c0, c1|
+          if c1 == NullLiteral::LEUQES
+            if @value == :eq
+              leuqes_op = :IS
+            elsif @value == :ne
+              leuqes_op = :'IS NOT'
+            end
+          end
+          Sequel::SQL::BooleanExpression.new(leuqes_op, c0, c1)
+        end
       end
     end
 
@@ -162,12 +210,12 @@ module OData
                     when :mod
                       :%
                     else
-                      raise OData::FilterParseError
+                      return Safrano::FilterParseError
                     end
-
-        Sequel::SQL::NumericExpression.new(leuqes_op,
-                                           @children[0].leuqes(jh),
-                                           @children[1].leuqes(jh))
+        Contract.collect_result!(@children[0].leuqes(jh),
+                                 @children[1].leuqes(jh)) do |c0, c1|
+          Sequel::SQL::NumericExpression.new(leuqes_op, c0, c1)
+        end
       end
     end
 
@@ -178,42 +226,42 @@ module OData
     # Numbers (floating point, ints, dec)
     class FPNumber
       def leuqes(_jh)
-        Sequel.lit(@value)
+        success Sequel.lit(@value)
       end
 
       def leuqes_starts_like(_jh)
-        "#{@value}%"
+        success  "#{@value}%"
       end
 
       def leuqes_ends_like(_jh)
-        "%#{@value}"
+        success  "%#{@value}"
       end
 
       def leuqes_substringof_sig1(_jh)
-        "%#{@value}%"
+        success  "%#{@value}%"
       end
     end
 
     # Literals are unquoted words
     class Literal
       def leuqes(jh)
-        raise OData::Filter::Parser::ErrorWrongColumnName unless jh.start_model.db_schema.key?(@value.to_sym)
+        return Safrano::FilterParseErrorWrongColumnName unless jh.start_model.db_schema.key?(@value.to_sym)
 
-        Sequel[jh.start_model.table_name][@value.to_sym]
+        success Sequel[jh.start_model.table_name][@value.to_sym]
       end
 
       # non stantard extensions to support things like
       # substringof(Rhum, name)  ????
       def leuqes_starts_like(_jh)
-        "#{@value}%"
+        success "#{@value}%"
       end
 
       def leuqes_ends_like(_jh)
-        "%#{@value}"
+        success "%#{@value}"
       end
 
       def leuqes_substringof_sig1(_jh)
-        "%#{@value}%"
+        success "%#{@value}%"
       end
 
       def as_string
@@ -221,31 +269,39 @@ module OData
       end
     end
 
+    # Null
+    class NullLiteral
+      def leuqes(jh)
+        # Sequel's representation of NULL
+        success LEUQES
+      end
+    end
+
     # Qualit (qualified lits) are words separated by /
     class Qualit
       def leuqes(jh)
         jh.add(@path)
         talias = jh.start_model.get_alias_sym(@path)
-        Sequel[talias][@attrib.to_sym]
+        success Sequel[talias][@attrib.to_sym]
       end
     end
 
     # Quoted Strings
     class QString
       def leuqes(_jh)
-        @value
+        success @value
       end
 
       def leuqes_starts_like(_jh)
-        "#{@value}%"
+        success "#{@value}%"
       end
 
       def leuqes_ends_like(_jh)
-        "%#{@value}"
+        success "%#{@value}"
       end
 
       def leuqes_substringof_sig1(_jh)
-        "%#{@value}%"
+        success "%#{@value}%"
       end
     end
   end

data/lib/odata/filter/sequel_function_adapter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative './tree.rb'
-require_relative './sequel.rb'
+require_relative './tree'
+require_relative './sequel'
 
-module OData
+module Safrano
   module Filter
     # sqlite adapter specific function handler
     module FuncTreeSqlite
@@ -11,10 +11,11 @@ module OData
         # substringof(name, '__Route du Rhum__')  -->
         # '__Route du Rhum__' contains name as a substring
         # sqlite uses instr()
-
-        substr_func = Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
-
-        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        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
@@ -31,77 +32,73 @@ module OData
       # %%		%
 
       # sqlite does not have extract but recommends to use strftime
-      def year(jh)
-        Sequel.function(:strftime, '%Y', args.first.leuqes(jh)).cast(:integer)
+      def year(lq)
+        Sequel.function(:strftime, '%Y', lq).cast(:integer)
       end
 
-      def month(jh)
-        Sequel.function(:strftime, '%m', args.first.leuqes(jh)).cast(:integer)
+      def month(lq)
+        Sequel.function(:strftime, '%m', lq).cast(:integer)
       end
 
-      def second(jh)
-        Sequel.function(:strftime, '%S', args.first.leuqes(jh)).cast(:integer)
+      def second(lq)
+        Sequel.function(:strftime, '%S', lq).cast(:integer)
       end
 
-      def minute(jh)
-        Sequel.function(:strftime, '%M', args.first.leuqes(jh)).cast(:integer)
+      def minute(lq)
+        Sequel.function(:strftime, '%M', lq).cast(:integer)
       end
 
-      def hour(jh)
-        Sequel.function(:strftime, '%H', args.first.leuqes(jh)).cast(:integer)
+      def hour(lq)
+        Sequel.function(:strftime, '%H', lq).cast(:integer)
       end
 
-      def day(jh)
-        Sequel.function(:strftime, '%d', args.first.leuqes(jh)).cast(:integer)
+      def day(lq)
+        Sequel.function(:strftime, '%d', lq).cast(:integer)
       end
 
-      def floor(jh)
-        raise OData::Filter::FunctionNotImplemented, "$filter function 'floor' is not implemented in sqlite adapter"
+      def floor(_lq)
+        Safrano::FilterFunctionNotImplementedError.new("$filter function 'floor' is not implemented in sqlite adapter")
       end
 
-      def ceiling(jh)
-        raise OData::Filter::FunctionNotImplemented, "$filter function 'ceiling' is not implemented in sqlite adapter"
+      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(jh)
-        Sequel.function(:floor, args.first.leuqes(jh))
+      def floor(lq)
+        success Sequel.function(:floor, lq)
       end
 
-      def ceiling(jh)
-        Sequel.function(:ceil, args.first.leuqes(jh))
+      def ceiling(lq)
+        success Sequel.function(:ceil, lq)
       end
     end
 
     # re-useable module with Datetime functions with extract()
     module DateTimeFuncTreeExtract
-      def year(jh)
-        args.first.leuqes(jh).extract(:year)
-      end
-
-      def year(jh)
-        args.first.leuqes(jh).extract(:year)
+      def year(lq)
+        lq.extract(:year)
       end
 
-      def month(jh)
-        args.first.leuqes(jh).extract(:month)
+      def month(lq)
+        lq.extract(:month)
       end
 
-      def second(jh)
-        args.first.leuqes(jh).extract(:second)
+      def second(lq)
+        lq.extract(:second)
       end
 
-      def minute(jh)
-        args.first.leuqes(jh).extract(:minute)
+      def minute(lq)
+        lq.extract(:minute)
       end
 
-      def hour(jh)
-        args.first.leuqes(jh).extract(:hour)
+      def hour(lq)
+        lq.extract(:hour)
       end
 
-      def day(jh)
-        args.first.leuqes(jh).extract(:day)
+      def day(lq)
+        lq.extract(:day)
       end
     end
 
@@ -111,9 +108,11 @@ module OData
         # substringof(name, '__Route du Rhum__')  -->
         # '__Route du Rhum__' contains name as a substring
         # postgres does not know instr() but has strpos
-        substr_func = Sequel.function(:strpos, args[1].leuqes(jh), args[0].leuqes(jh))
-
-        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        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()
@@ -132,9 +131,11 @@ module OData
         # substringof(name, '__Route du Rhum__')  -->
         # '__Route du Rhum__' contains name as a substring
         # instr() seems to be the most common substring func
-        substr_func = Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
-
-        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+        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() ?