safrano 0.4.3 → 0.5.1

data/lib/odata/filter/token.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-# top level OData namespace
-module OData
+module Safrano
   module Filter
     class Parser
       # Input tokenizer
@@ -10,14 +9,16 @@ module OData
                        replace substring trim toupper tolower
                        day hour minute month second year
                        round floor ceiling].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
+        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
 
@@ -34,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,13 +1,14 @@
 # frozen_string_literal: true
 
-require_relative './base.rb'
-require_relative './error.rb'
+require_relative './base'
+require_relative './error'
 
-module OData
+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?
@@ -21,15 +22,16 @@ module OData
     # Leaves are Nodes with a parent but no children
     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)
-        # TODO better reporting of error infos
-        raise ErrorLeaveChild
+      def attach(_child)
+        Safrano::Filter::Parser::ErrorLeaveChild
       end
     end
 
@@ -37,6 +39,7 @@ module OData
     class RootTree
       attr_reader :children
       attr_accessor :state
+
       def initialize(val: :root, &block)
         @children = []
         super(val, &block)
@@ -45,6 +48,7 @@ module OData
       def attach(child)
         child.parent = self
         @children << child
+        Contract::OK
       end
 
       def detach(child)
@@ -58,23 +62,27 @@ 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
 
@@ -125,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
@@ -139,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
@@ -158,13 +167,33 @@ module OData
 
       # 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
@@ -203,7 +232,7 @@ 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
@@ -255,6 +284,7 @@ module OData
     # Arguments or lists
     class ArgTree
       attr_reader :type
+
       def initialize(val)
         @type = :expression
         @state = :open
@@ -267,45 +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
+            nil
           elsif @state == :sep
-            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
-          else
-            true
+            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
 
@@ -319,9 +352,9 @@ module OData
       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
 
@@ -336,9 +369,9 @@ module OData
       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
 
@@ -351,8 +384,8 @@ module OData
       # an attempt to use a unknown function, eg. ceil(Total)
       # instead of ceiling(Total)
       def attach(child)
-        if child.kind_of? OData::Filter::IdentityFuncTree
-          raise Parser::ErrorInvalidFunction.new("Error in $filter expr.: invalid function #{self.value}")
+        if child.is_a? Safrano::Filter::IdentityFuncTree
+          Safrano::FilterUnknownFunctionError.new(value)
         else
           super
         end
@@ -365,6 +398,7 @@ module OData
       REGEXP = /((?:\w+\/)+)(\w+)/.freeze
       attr_reader :path
       attr_reader :attrib
+
       def initialize(val)
         super(val)
         # split into path + attrib
@@ -377,8 +411,8 @@ module OData
 
     # Quoted Strings
     class QString
-      DBL_QO = "''".freeze
-      SI_QO = "'".freeze
+      DBL_QO = "''"
+      SI_QO = "'"
       def initialize(val)
         # unescape double quotes
         super(val.gsub(DBL_QO, SI_QO))
@@ -387,9 +421,9 @@ module OData
       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
 

data/lib/odata/function_import.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative 'complex_type'
+require_relative 'edm/primitive_types'
+require_relative 'transition'
+
+module Safrano
+  def self.FunctionImport(name)
+    FunctionImport::Function.new(name)
+  end
+
+  module FunctionImport
+    class Function
+      @allowed_transitions = [Safrano::TransitionEnd]
+      attr_reader :name
+      attr_reader :proc
+
+      def initialize(name)
+        @name = name
+        @http_method = 'GET'
+      end
+
+      def allowed_transitions
+        [Safrano::TransitionEnd]
+      end
+
+      def input(**parmtypes)
+        @input = {}
+        parmtypes.each do |k, t|
+          @input[k] = case t.name
+                      when 'Integer'
+                        Safrano::Edm::Edm::Int32
+                      when 'String'
+                        Safrano::Edm::Edm::String
+                      when 'Float'
+                        Safrano::Edm::Edm::Double
+                      when 'DateTime'
+                        Safrano::Edm::Edm::DateTime
+                      else
+                        t
+                      end
+        end
+        self
+      end
+
+      def return(klassmod, &proc)
+        raise('Please provide a code block') unless block_given?
+
+        @returning = if klassmod.respond_to? :return_as_instance_descriptor
+                       klassmod.return_as_instance_descriptor
+                     else
+                       # if it's neither a ComplexType nor a Model-Entity
+                       # --> assume it is a Primitive
+                       ResultAsPrimitiveType.new(klassmod)
+                     end
+        @proc = proc
+        self
+      end
+
+      def return_collection(klassmod, &proc)
+        raise('Please provide a code block') unless block_given?
+
+        @returning = if klassmod.respond_to? :return_as_collection_descriptor
+                       klassmod.return_as_collection_descriptor
+                     else
+                       # if it's neither a ComplexType nor a Modle-Entity
+                       # --> assume it is a Primitive
+                       ResultAsPrimitiveTypeColl.new(klassmod)
+                     end
+        @proc = proc
+        self
+      end
+      #      def initialize_params
+      #        @uparms = UrlParameters4Func.new(@model, @params)
+      #      end
+
+      def check_missing_params
+        # do we have all parameters provided ?  use Set difference to check
+        pkeys = @params.keys.map(&:to_sym).to_set
+        unless (idiff = @input.keys.to_set - pkeys).empty?
+
+          Safrano::ServiceOperationParameterMissing.new(
+            missing: idiff.to_a,
+            sopname: @name
+          )
+        else
+          Contract::OK
+        end
+      end
+
+      def check_url_func_params
+        @funcparams = {}
+        return nil unless @input # anything to check ?
+
+        # do we have all parameters provided ?
+        check_missing_params.tap_error { |error| return error }
+        # ==> all params were provided
+
+        # now we shall check the content and type of the parameters
+        @input.each do |ksym, typ|
+          typ.convert_from_urlparam(v = @params[ksym.to_s])
+             .tap_valid do |retval|
+            @funcparams[ksym] = retval
+          end
+             .tap_error do
+            # return is really needed here, or we end up returning nil below
+            return parameter_convertion_error(ksym, typ, v)
+          end
+        end
+        nil
+      end
+
+      def parameter_convertion_error(param, type, val)
+        Safrano::ServiceOperationParameterError.new(type: type,
+                                                    value: val,
+                                                    param: param,
+                                                    sopname: @name)
+      end
+
+      def add_metadata_rexml(ec)
+        ## https://services.odata.org/V2/OData/Safrano.svc/$metadata
+        # <FunctionImport Name="GetProductsByRating" EntitySet="Products" ReturnType="Collection(ODataDemo.Product)" m:HttpMethod="GET">
+        # <Parameter Name="rating" Type="Edm.Int32" Mode="In"/>
+        # </FunctionImport>
+        funky = ec.add_element('FunctionImport',
+                               'Name' => @name.to_s,
+                               #                       EntitySet= @entity_set ,
+                               'ReturnType' => @returning.type_metadata,
+                               'm:HttpMethod' => @http_method)
+        @input.each do |iname, type|
+          funky.add_element('Parameter',
+                            'Name' => iname.to_s,
+                            'Type' => type.type_name,
+                            'Mode' => 'In')
+        end if @input
+        funky
+      end
+
+      def with_validated_get(req)
+        #        initialize_params
+        return yield unless (@error = check_url_func_params)
+
+        @error.odata_get(req) if @error
+      end
+
+      def to_odata_json(req)
+        result = @proc.call(**@funcparams)
+        @returning.to_odata_json(result, req)
+      end
+
+      def odata_get_output(req)
+        [200, EMPTY_HASH, [to_odata_json(req)]]
+      end
+
+      def odata_get(req)
+        @params = req.params
+
+        with_validated_get(req) do
+          odata_get_output(req)
+        end
+      end
+
+      def transition_end(_match_result)
+        Transition::RESULT_END
+      end
+    end
+  end
+end