safrano 0.3.3 → 0.4.3

data/lib/odata/filter/sequel_function_adapter.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative './tree.rb'
+require_relative './sequel.rb'
+
+module OData
+  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()
+
+        substr_func = Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
+
+        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+      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(jh)
+        Sequel.function(:strftime, '%Y', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def month(jh)
+        Sequel.function(:strftime, '%m', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def second(jh)
+        Sequel.function(:strftime, '%S', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def minute(jh)
+        Sequel.function(:strftime, '%M', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def hour(jh)
+        Sequel.function(:strftime, '%H', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def day(jh)
+        Sequel.function(:strftime, '%d', args.first.leuqes(jh)).cast(:integer)
+      end
+
+      def floor(jh)
+        raise OData::Filter::FunctionNotImplemented, "$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"
+      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))
+      end
+
+      def ceiling(jh)
+        Sequel.function(:ceil, args.first.leuqes(jh))
+      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)
+      end
+
+      def month(jh)
+        args.first.leuqes(jh).extract(:month)
+      end
+
+      def second(jh)
+        args.first.leuqes(jh).extract(:second)
+      end
+
+      def minute(jh)
+        args.first.leuqes(jh).extract(:minute)
+      end
+
+      def hour(jh)
+        args.first.leuqes(jh).extract(:hour)
+      end
+
+      def day(jh)
+        args.first.leuqes(jh).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
+        substr_func = Sequel.function(:strpos, args[1].leuqes(jh), args[0].leuqes(jh))
+
+        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+      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
+        substr_func = Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
+
+        Sequel::SQL::BooleanExpression.new(:>, substr_func, 0)
+      end
+
+      # XYZ uses extract() ?
+      include DateTimeFuncTreeExtract
+
+      # ... assume SQL
+      include MathFloorCeilFuncTree
+    end
+  end
+end

data/lib/odata/filter/token.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # top level OData namespace
 module OData
   module Filter
@@ -5,7 +7,9 @@ module OData
       # Input tokenizer
       module Token
         FUNCNAMES = %w[concat substringof endswith startswith length indexof
-                       replace substring trim toupper tolower].freeze
+                       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

data/lib/odata/filter/tree.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require_relative './base.rb'
 require_relative './error.rb'
 
 module OData
@@ -16,17 +19,22 @@ module OData
     end
 
     # Leaves are Nodes with a parent but no children
-    class Leave < Node
+    class Leave
       attr_accessor :parent
       def accept?(tok, typ)
         [false, Parser::ErrorInvalidToken(tok, typ)]
       end
 
       def check_types; end
+
+      def attach(child)
+        # TODO better reporting of error infos
+        raise 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)
@@ -71,7 +79,7 @@ module OData
     end
 
     # Tree's have Parent and children
-    class Tree < RootTree
+    class Tree
       attr_accessor :parent
 
       def initialize(val)
@@ -80,7 +88,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
@@ -143,7 +151,7 @@ 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
@@ -160,7 +168,7 @@ module OData
     end
 
     # unary op eg. NOT
-    class UnopTree < Tree
+    class UnopTree
       def initialize(val)
         super(val.downcase.to_sym)
       end
@@ -187,7 +195,7 @@ module OData
     end
 
     # Bin ops
-    class BinopTree < Tree
+    class BinopTree
       def initialize(val)
         @state = :open
         super(val.downcase.to_sym)
@@ -201,7 +209,7 @@ module OData
       end
     end
 
-    class BinopBool < BinopTree
+    class BinopBool
       # reference:
       # OData v4 par 5.1.1.9 Operator Precedence
       def precedence
@@ -224,7 +232,7 @@ module OData
       end
     end
 
-    class BinopArithm < BinopTree
+    class BinopArithm
       # reference:
       # OData v4 par 5.1.1.9 Operator Precedence
       def precedence
@@ -238,14 +246,14 @@ 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
@@ -279,12 +287,10 @@ module OData
         when :Separator
           if @value == '(' && tok == ',' && @state == :val
             true
+          elsif @state == :sep
+            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
           else
-            if (@state == :sep)
-              [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
-            else
-              true
-            end
+            true
           end
         when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
           if (@state == :open) || (@state == :sep)
@@ -309,7 +315,7 @@ module OData
     end
 
     # Numbers (floating point, ints, dec)
-    class FPNumber < Leave
+    class FPNumber
       def accept?(tok, typ)
         case typ
         when :Delimiter, :Separator, :BinopBool, :BinopArithm
@@ -326,7 +332,7 @@ module OData
     end
 
     # Literals are unquoted words without /
-    class Literal < Leave
+    class Literal
       def accept?(tok, typ)
         case typ
         when :Delimiter, :Separator, :BinopBool, :BinopArithm
@@ -339,33 +345,43 @@ module OData
       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.kind_of? OData::Filter::IdentityFuncTree
+          raise Parser::ErrorInvalidFunction.new("Error in $filter expr.: invalid function #{self.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 = "''".freeze
+      SI_QO = "'".freeze
       def initialize(val)
         # unescape double quotes
-        super(val.gsub(DoubleQuote, SingleQuote))
+        super(val.gsub(DBL_QO, SI_QO))
       end
 
       def accept?(tok, typ)

data/lib/odata/navigation_attribute.rb

@@ -1,11 +1,29 @@
 require 'json'
-require_relative '../safrano_core.rb'
+require_relative '../safrano/core.rb'
 require_relative './entity.rb'
 
 module OData
+  # remove the relation between entity and parent by clearing
+  # the FK field(s) (if allowed)
+  def self.remove_nav_relation(assoc, parent)
+    return unless assoc
+
+    return unless assoc[:type] == :many_to_one
+
+    # removes/clear the FK values in parent
+    # thus deleting the "link" between the entity and the parent
+    # Note: This is called if we have to delete the child--> can only be
+    # done after removing the FK in parent (if allowed!)
+    lks = [assoc[:key]].flatten
+    lks.each do |lk|
+      parent.set(lk => nil)
+      parent.save(transaction: false)
+    end
+  end
+
   # link newly created entities(child) to an existing parent
   # by following the association_reflection rules
-  def OData.create_nav_relation(child, assoc, parent)
+  def self.create_nav_relation(child, assoc, parent)
     return unless assoc
 
     # Note: this coding shares some bits from our sequel/plugins/join_by_paths,
@@ -24,16 +42,16 @@ module OData
       lks = [leftm.primary_key].flatten
       rks = [assoc[:key]].flatten
       join_cond = rks.zip(lks).to_h
-      join_cond.each { |rk, lk|
+      join_cond.each do |rk, lk|
         if child.values[rk] # FK in new entity from payload not nil, only check consistency
           # with the parent - id(s)
-          if (child.values[rk] != parent.pk_hash[lk]) # error...
-            # TODO
-          end
+          # if (child.values[rk] != parent.pk_hash[lk]) # error...
+          # TODO
+          # end
         else # we can set the FK value, thus creating the "link"
           child.set(rk => parent.pk_hash[lk])
         end
-      }
+      end
     when :many_to_one
       # sets the FK values in parent to corresponding related child key-values
       # thus creating the "link" between the new entity and the parent
@@ -42,31 +60,37 @@ module OData
       lks = [assoc[:key]].flatten
       rks = [child.class.primary_key].flatten
       join_cond = rks.zip(lks).to_h
-      join_cond.each { |rk, lk|
+      join_cond.each do |rk, lk|
         if parent.values[lk] # FK in parent not nil, only check consistency
           # with the child - id(s)
-          if (parent.values[lk] != child.pk_hash[rk]) # error...
-            # TODO
-          end
+          # if parent.values[lk] != child.pk_hash[rk] # error...
+          # TODO
+          # end
         else # we can set the FK value, thus creating the "link"
           parent.set(lk => child.pk_hash[rk])
         end
-      }
+      end
+    end
+  end
+
+  module EntityBase
+    module NavigationInfo
+      attr_reader :nav_parent
+      attr_reader :navattr_reflection
+      attr_reader :nav_name
+      def set_relation_info(parent, name)
+        @nav_parent = parent
+        @nav_name = name
+        @navattr_reflection = parent.class.association_reflections[name.to_sym]
+        @nav_klass = @navattr_reflection[:class_name].constantize
+      end
     end
   end
 
   # Represents a named but nil-valued navigation-attribute of an Entity
   # (usually resulting from a NULL FK db value)
   class NilNavigationAttribute
-    attr_reader :name
-    attr_reader :parent
-    def initialize(parent, name)
-      @parent = parent
-      @name = name
-      @navattr_reflection = parent.class.association_reflections[name.to_sym]
-      @klass = @navattr_reflection[:class_name].constantize
-    end
-
+    include EntityBase::NavigationInfo
     def odata_get(req)
       if req.walker.media_value
         OData::ErrorNotFound.odata_get
@@ -80,23 +104,30 @@ module OData
     # create the nav. entity
     def odata_post(req)
       # delegate to the class method
-      @klass.odata_create_entity_and_relation(req, @navattr_reflection, @parent)
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
     end
 
     # create the nav. entity
     def odata_put(req)
+      #      if req.walker.raw_value
       # delegate to the class method
-      @klass.odata_create_entity_and_relation(req, @navattr_reflection, @parent)
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
+      #      else
+      #      end
     end
 
     # empty output as OData json (v2)
     def to_odata_json(*)
-      { 'd' => {} }.to_json
+      { 'd' => EMPTY_HASH }.to_json
     end
 
     # for testing purpose (assert_equal ...)
     def ==(other)
-      (@parent == other.parent) && (@name == other.name)
+      (@nav_parent == other.nav_parent) && (@nav_name == other.nav_name)
     end
 
     # methods related to transitions to next state (cf. walker)
@@ -109,9 +140,11 @@ module OData
         [self, :end_with_value]
       end
 
+      ALLOWED_TRANSITIONS = [Safrano::TransitionEnd,
+                             Safrano::TransitionValue].freeze
+
       def allowed_transitions
-        [Safrano::TransitionEnd,
-         Safrano::TransitionValue]
+        ALLOWED_TRANSITIONS
       end
     end
     include Transitions