safrano 0.3.3 → 0.4.3

data/lib/odata/error.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'json'
 require 'rexml/document'
 require 'safrano.rb'
@@ -31,8 +29,8 @@ module OData
     end
   end
 
-  # base module for HTTP errors
-  module Error
+  # base module for HTTP errors, when used as a Error Class
+  module ErrorClass
     def odata_get(req)
       if req.accept?(APPJSON)
         [const_get(:HTTP_CODE), CT_JSON,
@@ -42,9 +40,22 @@ module OData
       end
     end
   end
+
+  # base module for HTTP errors, when used as an Error instance
+  module ErrorInstance
+    def odata_get(req)
+      if req.accept?(APPJSON)
+        [self.class.const_get(:HTTP_CODE), CT_JSON,
+         { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
+      else
+        [self.class.const_get(:HTTP_CODE), CT_TEXT, @msg]
+      end
+    end
+  end
+
   # http Bad Req.
   class BadRequestError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 400
     @msg = 'Bad Request Error'
   end
@@ -59,12 +70,31 @@ module OData
     HTTP_CODE = 400
     @msg = 'Bad Request: $value request for a non-media entity'
   end
+  class BadRequestSequelAdapterError < BadRequestError
+    include ErrorInstance
+    def initialize(err)
+      @msg = err.inner.message
+    end
+  end
 
   # for Syntax error in Filtering
   class BadRequestFilterParseError < BadRequestError
     HTTP_CODE = 400
-    @msg = 'Bad Request: Syntax error in Filter'
+    @msg = 'Bad Request: Syntax error in $filter'
   end
+
+  # for Syntax error in $expand param
+  class BadRequestExpandParseError < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: Syntax error in $expand'
+  end
+
+  # for Syntax error in $orderby param
+  class BadRequestOrderParseError < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: Syntax error in $orderby'
+  end
+
   # for $inlinecount error
   class BadRequestInlineCountParamError < BadRequestError
     HTTP_CODE = 400
@@ -72,36 +102,54 @@ module OData
   end
   # http not found
   class ErrorNotFound
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 404
     @msg = 'The requested ressource was not found'
   end
   # Transition error (Safrano specific)
   class ServerTransitionError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 500
     @msg = 'Server error: Segment could not be parsed'
   end
   # generic http 500 server err
   class ServerError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 500
     @msg = 'Server error'
   end
   # not implemented (Safrano specific)
   class NotImplementedError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 501
   end
   # batch not implemented (Safrano specific)
   class BatchNotImplementedError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 501
     @msg = 'Not implemented: OData batch'
   end
+
   # error in filter parsing (Safrano specific)
   class FilterParseError < BadRequestError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 400
   end
+
+  class FilterFunctionNotImplementedError < BadRequestError
+    extend  ErrorClass
+    include ErrorInstance
+    @msg = 'the requested $filter function is Not implemented'
+    HTTP_CODE = 400
+    def initialize(exception)
+      @msg = exception.to_s
+    end
+  end
+  class FilterInvalidFunctionError < BadRequestError
+    include ErrorInstance
+    HTTP_CODE = 400
+    def initialize(exception)
+      @msg = exception.to_s
+    end
+  end
 end

data/lib/odata/expand.rb

@@ -0,0 +1,123 @@
+require 'odata/error.rb'
+
+# all dataset expanding related classes in our OData module
+# ie  do eager loading
+module OData
+  # base class for expanding
+  class ExpandBase
+    EmptyExpand = new # re-useable empty expanding (idempotent)
+    EMPTYH = {}.freeze
+
+    def self.factory(expandstr)
+      expandstr.nil? ? EmptyExpand : MultiExpand.new(expandstr)
+    end
+
+    # output template
+    attr_reader :template
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def empty?
+      true
+    end
+
+    def parse_error?
+      false
+    end
+
+    def template
+      EMPTYH
+    end
+  end
+
+  # single expand
+  class Expand < ExpandBase
+    # sequel eager arg.
+    attr_reader :arg
+    attr_reader :template
+
+    # used for Sequel eager argument
+    # Recursive array to deep hash
+    # [1,2,3,4]  -->  {1=>{2=>{3=>4}}}
+    # [1] --> 1
+    DEEPH_0 = ->(inp) { inp.size > 1 ? { inp[0] => DEEPH_0.call(inp[1..-1]) } : inp[0] }
+
+    # used for building output template
+    # Recursive array to deep hash
+    # [1,2,3,4]  -->  {1=>{2=>{3=>4}}}
+    # [1] --> { 1 => {} }
+    DEEPH_1 = ->(inp) { inp.size > 1 ? { inp[0] => DEEPH_1.call(inp[1..-1]) } : { inp[0] => {} } }
+
+    NODESEP = '/'.freeze
+
+    def initialize(exstr)
+      exstr.strip!
+      @expandp = exstr
+      @nodes = @expandp.split(NODESEP)
+      build_arg
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def build_arg
+      #   'a/b/c/d'  ==> {a: {b:{c: :d}}}
+      #   'xy'  ==> :xy
+      @arg = DEEPH_0.call(@nodes.map(&:to_sym))
+      @template = DEEPH_1.call(@nodes)
+    end
+
+    def parse_error?
+      # todo
+      false
+    end
+
+    def empty?
+      false
+    end
+  end
+
+  # Multi expanding logic
+  class MultiExpand < ExpandBase
+    COMASPLIT = /\s*,\s*/.freeze
+    attr_reader :template
+
+    def initialize(expandstr)
+      expandstr.strip!
+      @expandp = expandstr
+      @exlist = []
+
+      @exlist = expandstr.split(COMASPLIT).map { |exstr| Expand.new(exstr) }
+      build_template
+    end
+
+    def apply_to_dataset(dtcx)
+      # use eager loading for each used association
+      @exlist.each { |exp| dtcx = dtcx.eager(exp.arg) }
+      dtcx
+    end
+
+    def build_template
+      #   'a/b/c/d,xy'  ==> [ {'a' =>{ 'b' => {'c' => {'d' => {} } }}},
+      #                       { 'xy' => {} }]
+      #
+      @template = @exlist.map(&:template)
+
+      # { 'a'  => { 'b' => {'c' => 'd' }},
+      #   'xy' => {} }
+      @template = @template.inject({}) { |mrg, elmt| mrg.merge elmt }
+    end
+
+    def parse_error?
+      # todo
+      false
+    end
+
+    def empty?
+      false
+    end
+  end
+end

data/lib/odata/filter/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OData
+  module Filter
+    # Base class for Leaves, Trees, RootTrees etc
+    class Node
+    end
+
+    # Leaves are Nodes with a parent but no children
+    class Leave < Node
+    end
+
+    # RootTrees have childrens but no parent
+    class RootTree < Node
+    end
+
+    # Tree's have Parent and children
+    class Tree < RootTree
+    end
+
+    # For functions... should have a single child---> the argument list
+    class FuncTree < Tree
+    end
+
+    # Indentity Func to use as "parent" func of parenthesis expressions
+    # --> allow to handle generically parenthesis always as argument of
+    # some function
+    class IdentityFuncTree < FuncTree
+    end
+
+    # unary op eg. NOT
+    class UnopTree < Tree
+    end
+
+    # Bin ops
+    class BinopTree < Tree
+    end
+
+    class BinopBool < BinopTree
+    end
+
+    class BinopArithm < BinopTree
+    end
+
+    # Arguments or lists
+    class ArgTree < Tree
+    end
+
+    # Numbers (floating point, ints, dec)
+    class FPNumber < Leave
+    end
+
+    # Literals are unquoted words without /
+    class Literal < Leave
+    end
+
+    # Qualit (qualified lits) are words separated by /
+    # path/path/path/attrib
+    class Qualit < Literal
+    end
+
+    # Quoted Strings
+    class QString < Leave
+    end
+  end
+end

data/lib/odata/filter/error.rb

@@ -1,5 +1,28 @@
+require_relative '../error'
+
 module OData
+  class SequelAdapterError < StandardError
+    attr_reader :inner
+    def initialize(err)
+      @inner = err
+    end
+  end
+
+  # exception to OData error bridge
+  module ErrorBridge
+    # return an odata error object wrapping the exception
+    # the odata error object should respond to odata_get for output
+    def odata_error
+      self.class.const_get('ODATA_ERROR_KLASS').new(self)
+    end
+  end
+
   module Filter
+    class FunctionNotImplemented < StandardError
+      ODATA_ERROR_KLASS = OData::FilterFunctionNotImplementedError
+      include ::OData::ErrorBridge
+    end
+
     class Parser
       # Parser errors
       class Error < StandardError
@@ -29,6 +52,16 @@ module OData
       class ErrorWrongColumnName < StandardError
       end
 
+      # attempt to add a child to a Leave
+      class ErrorLeaveChild < StandardError
+      end
+
+      # invalid function error (literal attach to IdentityFuncTree)
+      class ErrorInvalidFunction < StandardError
+        ODATA_ERROR_KLASS = OData::FilterInvalidFunctionError
+        include ::OData::ErrorBridge
+      end
+
       # Invalid function arity
       class ErrorInvalidArity < Error
       end

data/lib/odata/filter/parse.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './token.rb'
 require_relative './tree.rb'
 require_relative './error.rb'
@@ -68,24 +70,18 @@ module OData
         each_typed_token(@input) do |tok, typ|
           case typ
           when :FuncTree
-            with_accepted(tok, typ) do
-              grow_at_cursor(FuncTree.new(tok))
-            end
+            with_accepted(tok, typ) { grow_at_cursor(FuncTree.new(tok)) }
           when :Delimiter
             case tok
             when '('
               with_accepted(tok, typ) do
-                unless @cursor.is_a? FuncTree
-                  grow_at_cursor(IdentityFuncTree.new)
-                end
+                grow_at_cursor(IdentityFuncTree.new) unless @cursor.is_a? FuncTree
                 openarg = ArgTree.new('(')
                 @stack << openarg
                 grow_at_cursor(openarg)
               end
             when ')'
-              unless (@cursor = @stack.pop)
-                break invalid_closing_delimiter_error(tok, typ)
-              end
+              break invalid_closing_delimiter_error(tok, typ) unless (@cursor = @stack.pop)
 
               with_accepted(tok, typ) do
                 @cursor.update_state(tok, typ)
@@ -94,9 +90,7 @@ module OData
             end
 
           when :Separator
-            unless (@cursor = @stack.last)
-              break invalid_separator_error(tok, typ)
-            end
+            break invalid_separator_error(tok, typ) unless (@cursor = @stack.last)
 
             with_accepted(tok, typ) { @cursor.update_state(tok, typ) }
 

data/lib/odata/filter/sequel.rb

@@ -1,19 +1,23 @@
-require_relative './tree.rb'
+# frozen_string_literal: true
+
+require_relative './base.rb'
+require_relative './sequel_function_adapter.rb'
+
 module OData
   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)
-        dtcx = jh.dataset.where(filtexpr).select_all(jh.start_model.table_name)
+        jh.dataset(dtcx).where(filtexpr).select_all(jh.start_model.table_name)
       end
 
       def sequel_expr(jh)
@@ -26,6 +30,8 @@ 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
@@ -38,28 +44,17 @@ module OData
         when :substringof
 
           # there are multiple possible argument types (but all should return edm.string)
-          if (args[0].is_a?(QString))
+          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))
           # special non standard (ui5 client) case ?
-          elsif (args[0].is_a?(Literal) && args[1].is_a?(Literal))
+          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)
-
+          elsif args[1].is_a?(QString)
+            substringof_sig2(jh) # adapter specific
           else
             # TODO... actually not supported?
             raise OData::Filter::Parser::ErrorFunctionArgumentType
@@ -75,6 +70,26 @@ module OData
           Sequel.function(:upper, args.first.leuqes(jh))
         when :tolower
           Sequel.function(:lower, args.first.leuqes(jh))
+        # all datetime funcs are adapter specific (because sqlite does not have extract)
+        when :year
+          year(jh)
+        when :month
+          month(jh)
+        when :second
+          second(jh)
+        when :minute
+          minute(jh)
+        when :hour
+          hour(jh)
+        when :day
+          day(jh)
+        # math functions
+        when :round
+          Sequel.function(:round, args.first.leuqes(jh))
+        when :floor
+          floor(jh)
+        when :ceiling
+          ceiling(jh)
         else
           raise OData::FilterParseError
         end
@@ -167,26 +182,24 @@ module OData
       end
 
       def leuqes_starts_like(_jh)
-        "#{@value.to_s}%"
+        "#{@value}%"
       end
 
       def leuqes_ends_like(_jh)
-        "%#{@value.to_s}"
+        "%#{@value}"
       end
 
       def leuqes_substringof_sig1(_jh)
-        "%#{@value.to_s}%"
+        "%#{@value}%"
       end
     end
 
     # Literals are unquoted words
     class Literal
       def leuqes(jh)
-        if jh.start_model.db_schema.has_key?(@value.to_sym)
-          Sequel[jh.start_model.table_name][@value.to_sym]
-        else
-          raise OData::Filter::Parser::ErrorWrongColumnName
-        end
+        raise OData::Filter::Parser::ErrorWrongColumnName unless jh.start_model.db_schema.key?(@value.to_sym)
+
+        Sequel[jh.start_model.table_name][@value.to_sym]
       end
 
       # non stantard extensions to support things like