safrano 0.4.2 → 0.5.0

data/lib/odata/filter/error.rb

@@ -1,18 +1,31 @@
-module OData
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Safrano
   class SequelAdapterError < StandardError
     attr_reader :inner
+
     def initialize(err)
       @inner = err
     end
   end
+
   module Filter
     class Parser
       # Parser errors
-      class Error < StandardError
+
+      class Error
+        def Error.http_code
+          const_get(:HTTP_CODE)
+        end
+        HTTP_CODE = 400
+
         attr_reader :tok
         attr_reader :typ
         attr_reader :cur_val
         attr_reader :cur_typ
+
         def initialize(tok, typ, cur)
           @tok = tok
           @typ = typ
@@ -24,31 +37,61 @@ module OData
       end
       # Invalid Tokens
       class ErrorInvalidToken < Error
+        include ::Safrano::ErrorInstance
+        def initialize(tok, typ, cur)
+          super
+          @msg = "Bad Request: invalid token #{tok} in $filter"
+        end
       end
       # Unmached closed
       class ErrorUnmatchedClose < Error
+        include ::Safrano::ErrorInstance
+        def initialize(tok, typ, cur)
+          super
+          @msg = "Bad Request: unmatched #{tok} in $filter"
+        end
       end
 
-      class ErrorFunctionArgumentType < StandardError
+      class ErrorFunctionArgumentType
+        include ::Safrano::ErrorInstance
       end
 
-      class ErrorWrongColumnName < StandardError
+      class ErrorWrongColumnName
+        include ::Safrano::ErrorInstance
+      end
+
+      # attempt to add a child to a Leave
+      class ErrorLeaveChild
+        include ::Safrano::ErrorInstance
       end
 
       # Invalid function arity
       class ErrorInvalidArity < Error
+        include ::Safrano::ErrorInstance
+        def initialize(tok, typ, cur)
+          super
+          @msg = "Bad Request: wrong number of parameters for function #{cur.parent.value.to_s} in $filter"
+        end
       end
       # Invalid separator in this context (missing parenthesis?)
       class ErrorInvalidSeparator < Error
+        include ::Safrano::ErrorInstance
       end
 
       # unmatched quot3
       class UnmatchedQuoteError < Error
+        include ::Safrano::ErrorInstance
+        def initialize(tok, typ, cur)
+          super
+          @msg = "Bad Request: unbalanced quotes #{tok} in $filter"
+        end
       end
 
       # wrong type of function argument
-      class ErrorInvalidArgumentType < StandardError
-        def initialize(tree, expected:,  actual:)
+      class ErrorInvalidArgumentType < Error
+        include ::Safrano::ErrorInstance
+
+        def initialize(tree, expected:, actual:)
           @tree = tree
           @expected = expected
           @actual = actual

data/lib/odata/filter/parse.rb

@@ -1,15 +1,19 @@
-require_relative './token.rb'
-require_relative './tree.rb'
-require_relative './error.rb'
+# frozen_string_literal: true
 
-# top level OData namespace
-module OData
+require_relative './token'
+require_relative './tree'
+require_relative './error'
+
+# 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
@@ -18,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
 
@@ -40,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)
@@ -56,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
@@ -69,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)
 
@@ -121,6 +128,7 @@ module OData
               end
               insert_before_cursor(binoptr)
             end
+
           when :BinopArithm
             with_accepted(tok, typ) do
               binoptr = BinopArithm.new(tok)
@@ -143,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)
@@ -160,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,19 +1,24 @@
-require_relative './tree.rb'
-module OData
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative './sequel_function_adapter'
+
+module Safrano
   module Filter
     # Base class for Leaves, Trees, RootTrees etc
-    class Node
-    end
+    #    class Node
+    #    end
 
     # Leaves are Nodes with a parent but no children
-    class Leave < Node
-    end
+    #    class Leave < Node
+    #    end
 
     # 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)
@@ -26,57 +31,108 @@ module OData
     end
 
     # For functions... should have a single child---> the argument list
+    # note: Adapter specific function helpers like year() or substringof_sig2()
+    # need to be mixed in on startup (eg. on publish finalize)
     class FuncTree < Tree
       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))
-          elsif args[1].is_a?(QString)
-            # substringof(name, '__Route du Rhum__')  -->
-            # '__Route du Rhum__' contains name as a substring
-            # TODO... check if the database supports instr (how?)
-            # othewise use substr(postgresql) or whatevr?
-            instr_substr_func = if Sequel::Model.db.adapter_scheme == :postgres
-                                  Sequel.function(:strpos, args[1].leuqes(jh), args[0].leuqes(jh))
-                                else
-                                  Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
-                                end
-
-            Sequel::SQL::BooleanExpression.new(:>, instr_substr_func, 0)
+            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
+          args.first.leuqes(jh)
+              .map_result! { |l| year(l) }
+
+        when :month
+          args.first.leuqes(jh)
+              .map_result! { |l| month(l) }
+
+        when :second
+          args.first.leuqes(jh)
+              .map_result! { |l| second(l) }
+
+        when :minute
+          args.first.leuqes(jh)
+              .map_result! { |l| minute(l) }
+
+        when :hour
+          args.first.leuqes(jh)
+              .map_result! { |l| hour(l) }
+
+        when :day
+          args.first.leuqes(jh)
+              .map_result! { |l| day(l) }
+
+        # math functions
+        when :round
+          args.first.leuqes(jh)
+              .map_result! { |l| Sequel.function(:round, l) }
+
+        when :floor
+          args.first.leuqes(jh)
+              .if_valid { |l| floor(l) }
+
+        when :ceiling
+          args.first.leuqes(jh)
+              .if_valid { |l| ceiling(l) }
         else
-          raise OData::FilterParseError
+          Safrano::FilterParseError
         end
       end
     end
@@ -95,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
@@ -123,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
 
@@ -147,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
 
@@ -163,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
@@ -206,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