safrano 0.5.3 → 0.6.0

data/lib/odata/complex_type.rb

@@ -12,153 +12,148 @@ module Safrano
       VALUEK = 'value'
       RESULTSK = 'results'
       COLLECTION = 'Collection'
-      
+
       def allowed_transitions
         [Safrano::TransitionEnd]
       end
-      
+
       def transition_end(_match_result)
         Safrano::Transition::RESULT_END
       end
-           
+
       # we will have this on class and instance level for making things simpler first
-      def self.klassmod
-        @klassmod
+      class << self
+        attr_reader :klassmod
       end
-      
+
       # return a subclass of ResultAsComplexType
       def self.asComplexType(klassmod)
         Class.new(ResultAsComplexType) do
           @klassmod = klassmod
         end
       end
-      
+
       # return a subclass of ResultAsComplexType
       def self.asComplexTypeColl(klassmod)
         Class.new(ResultAsComplexTypeColl) do
           @klassmod = klassmod
         end
       end
-      
+
       def self.asPrimitiveType(klassmod)
         Class.new(ResultAsPrimitiveType) do
           @klassmod = klassmod
         end
       end
-      
+
       def self.asPrimitiveTypeColl(klassmod)
         Class.new(ResultAsPrimitiveTypeColl) do
           @klassmod = klassmod
         end
-      end      
-      
+      end
+
       def self.asEntity(klassmod)
         Class.new(ResultAsEntity) do
           @klassmod = klassmod
         end
       end
-      
+
       def self.asEntityColl(klassmod)
         Class.new(ResultAsEntityColl) do
           @klassmod = klassmod
         end
       end
-      
+
       def initialize(value)
         @value = value
       end
-      
+
       def odata_get(req)
         [200, EMPTY_HASH, [to_odata_json(req)]]
       end
+
       def self.type_metadata
         @klassmod.type_name
       end
+
       def type_metadata
         self.class.type_metadata
       end
-      
+
       # needed for ComplexType result
       def to_odata_json(_req)
         "#{DJ_OPEN}#{@value.odata_h.to_json}#{DJ_CLOSE}"
-      end      
-      
-      # wrapper 
+      end
+
+      # wrapper
       # for OData Entity and Collections, return them directly
       # for others, ie ComplexType, Prims etc, return the ResultDefinition-subclass wrapped result
-      def self.do_execute_func_result(result, _req, apply_query_params=false)
-        self.new(result)
+      def self.do_execute_func_result(result, _req, _apply_query_params = false)
+        new(result)
       end
-      
     end
-    
+
     class ResultAsComplexType < ResultDefinition
       def self.type_metadata
         @klassmod.type_name
       end
     end
-    
+
     class ResultAsComplexTypeColl < ResultDefinition
       def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
 
       def to_odata_json(req)
-#        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
+        #        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
         template = self.class.klassmod.output_template
         # TODO: Error handling if database contains binary BLOB data that cant be
         # interpreted as UTF-8 then JSON will fail here
 
         innerh = req.service.get_coll_odata_h(array: @value,
                                               template: template)
-                                              
+
         innerj = innerh.to_json
 
         "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
       end
     end
-    
+
     class ResultAsEntity < ResultDefinition
-    
       def self.type_metadata
         @klassmod.type_name
       end
 
-      
-      # wrapper 
+      # wrapper
       # for OData Entity  return them directly
-      def self.do_execute_func_result(result, _req, apply_query_params=false)
-        # note: Sequel entities instances seem to be thread safe, so we can 
+      def self.do_execute_func_result(result, _req, apply_query_params = false)
+        # note: Sequel entities instances seem to be thread safe, so we can
         # safely add request-dependant data (eg. req.params) there
         apply_query_params ? result : result.inactive_query_params
       end
-      
     end
-    
+
     class ResultAsEntityColl < ResultDefinition
-    
       def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
-      
-      # wrapper 
+
+      # wrapper
       # for OData Entity Collection return them directly
-      def self.do_execute_func_result(result, req, apply_query_params=false)
+      def self.do_execute_func_result(result, req, apply_query_params = false)
         coll = Safrano::OData::Collection.new(@klassmod)
         # instance_exec has other instance variables; @values would be nil in the block below
         # need to pass a local copy
         dtset = result
         coll.instance_exec do
-
-          @params =  apply_query_params ?  req.params : EMPTY_HASH
+          @params = apply_query_params ? req.params : EMPTY_HASH
           initialize_dataset(dtset)
           initialize_uparms
         end
         coll
       end
-
     end
-    
+
     class ResultAsPrimitiveType < ResultDefinition
       def self.type_metadata
         @klassmod.type_name
@@ -169,7 +164,7 @@ module Safrano
                  VALUEK => self.class.klassmod.odata_value(@value) } }.to_json
       end
     end
-    
+
     class ResultAsPrimitiveTypeColl < ResultDefinition
       def self.type_metadata
         "Collection(#{@klassmod.type_name})"
@@ -179,7 +174,6 @@ module Safrano
         { D => { METAK => { TYPEK => self.class.type_metadata },
                  RESULTSK => self.class.klassmod.odata_collection(@value) } }.to_json
       end
-    
     end
   end
 
@@ -188,51 +182,51 @@ module Safrano
   # with added OData functionality
   class ComplexType
     attr_reader :values
+
     EMPTYH = {}.freeze
-    
+
     @namespace = nil
-    def self.namespace
-      @namespace
+    class << self
+      attr_reader :namespace
     end
 
-    def self.props
-      @props
+    class << self
+      attr_reader :props
     end
-    
+
     def type_name
       self.class.type_name
     end
-    
+
     def metadata_h
       {   type: type_name }
     end
-    
+
     def casted_values
       # MVP... TODO: handle time mappings like in Entity models
       values
     end
-    
+
     # needed for nested json output
     # this is a simpler version of model_ext#output_template
     def self.default_template
       template = {}
       expand_e = {}
-      
+
       template[:all_values] = EMPTYH
-      @props.each { |prop, kl| 
-        if kl.respond_to? :default_template
-          expand_e[prop] = kl.default_template
-        end
-      }
+      @props.each do |prop, kl|
+        expand_e[prop] = kl.default_template if kl.respond_to? :default_template
+      end
       template[:expand_e] = expand_e
       template
     end
-    
+
     def self.output_template
       default_template
     end
+
     def self.type_name
-      @namespace ? "#{@namespace}.#{self.to_s}" : self.to_s
+      @namespace ? "#{@namespace}.#{self}" : to_s
     end
 
     def initialize
@@ -244,13 +238,13 @@ module Safrano
     def odata_h
       ret = { METAK => { TYPEK => self.class.type_name } }
 
-      @values.each { |k, v|
+      @values.each do |k, v|
         ret[k] = if v.respond_to? :odata_h
                    v.odata_h
                  else
                    v
                  end
-      }
+      end
       ret
     end
 
@@ -276,14 +270,14 @@ module Safrano
     end
   end
 
-  def Safrano.ComplexType(**props)
+  def self.ComplexType(**props)
     Class.new(Safrano::ComplexType) do
       @props = props
-      props.each { |a, klassmod|
+      props.each do |a, _klassmod|
         asym = a.to_sym
-        define_method(asym) do @values[asym] end
-        define_method("#{a}=") do |val| @values[asym] = val end
-      }
+        define_method(asym) { @values[asym] }
+        define_method("#{a}=") { |val| @values[asym] = val }
+      end
       define_method :initialize do |*p, **kwvals|
         super()
         p.zip(props.keys).each { |val, a| @values[a] = val } if p

data/lib/odata/edm/primitive_types.rb

@@ -15,36 +15,108 @@ module Safrano
   # Classes specifying generic types that Sequel will convert to
   # database-specific types.
   DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.freeze
-
+  DB_TYPE_NUMDEC_RGX = /\A(NUMERIC|DECIMAL)\s*(\(\s*((\d+)\s*(,\s*(\d+))?)\s*\))?\s*\z/i.freeze
+  # thank you rubular
+  # Test String: DECIMAL (55,2 )
+  # Match groups
+  # 1	DECIMAL
+  # 2	(55,2 )
+  # 3	55,2
+  # 4	55
+  # 5	,2
+  # 6	2
+
+  DB_TYPE_FLOATP_RGX = /\A\s*(FLOAT)\s*(\(\s*(\d+)\s*\))?\s*\z/i.freeze
+
+  # Note: "char" (quoted!) is postgresql's byte type
+  DB_TYPE_INTLIKE_RGX = /\A\s*(smallserial|smallint|integer|int2|int4|int8|int|mediumint|bigint|serial|bigserial|tinyint)\s*/i.freeze
   # used in $metadata
   # cf. Sequel Database column_schema_default_to_ruby_value
   #                     schema_column_type
   # https://www.odata.org/documentation/odata-version-2-0/overview/
-  def self.default_edm_type(ruby_type:, db_type: )
-    case ruby_type
-    when :integer
-      'Edm.Int32'
-    when :string
-      'Edm.String'
-    when :date
-      'Edm.DateTime'
-    when :datetime
-      'Edm.DateTime'
-    when :time
-      'Edm.Time'
-    when :boolean
-      'Edm.Boolean'
-    when :float
-      'Edm.Double'
-    when :decimal
-      'Edm.Decimal'
-    when :blob
-      'Edm.Binary'
-    else  # try with db_type:
-      if ( db_type =~ /\ANUMERIC/ )
-        'Edm.Decimal'
-      end
-    end
+
+  # type mappings are hard, especially between "Standards" like SQL and OData V2 (might be a bit better in V4 ?)
+  # this is all best effort/try to make it work  logic
+  def self.add_edm_types(metadata, props)
+    # try num/dec with db_type:
+    metadata[:edm_type] = if (md = DB_TYPE_NUMDEC_RGX.match(props[:db_type]))
+                            prec = md[4]
+                            scale = md[6]
+                            if scale && prec
+                              if scale == '0' # dont force default scale to 0 like SQL standard
+                                metadata[:edm_precision] = prec
+                                "Edm.Decimal(#{prec})"
+                              else
+                                # we have precision and scale
+                                metadata[:edm_scale] = scale
+                                metadata[:edm_precision] = prec
+                                "Edm.Decimal(#{prec},#{scale})"
+                              end
+                            elsif prec
+                              # we have precision only
+                              metadata[:edm_precision] = prec
+                              "Edm.Decimal(#{prec})"
+                            else
+                              'Edm.Decimal'
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try float(prec) with db_type:
+    metadata[:edm_type] = if (md = DB_TYPE_FLOATP_RGX.match(props[:db_type]))
+                            # FLOAT( 22) match groups
+                            # 1	FLOAT
+                            # 2	(22 )
+                            # 3	22
+
+                            if (prec = md[3])
+                              # we have precision only
+                              metadata[:edm_precision] = prec
+                              'Edm.Double'
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try int-like with db_type:
+    # smallint|int|integer|bigint|serial|bigserial
+    metadata[:edm_type] = if (md = DB_TYPE_INTLIKE_RGX.match(props[:db_type]))
+
+                            if (itype = md[1])
+                              case itype.downcase
+                              when 'smallint', 'int2', 'smallserial'
+                                'Edm.Int16'
+                              when 'int', 'integer', 'serial', 'mediumint', 'int4'
+                                'Edm.Int32'
+                              when 'bigint', 'bigserial', 'int8'
+                                'Edm.Int64'
+                              when 'tinyint'
+                                'Edm.Byte'
+                              end
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try with Sequel(ruby) type
+    metadata[:edm_type] = case props[:type]
+                          when :integer
+                            'Edm.Int32'
+                          when :string
+                            'Edm.String'
+                          when :date
+                            'Edm.DateTime'
+                          when :datetime
+                            'Edm.DateTime'
+                          when :time
+                            'Edm.Time'
+                          when :boolean
+                            'Edm.Boolean'
+                          when :float
+                            'Edm.Double'
+                          when :decimal
+                            'Edm.Decimal'
+                          when :blob
+                            'Edm.Binary'
+                          end
   end
 
   # use Edm twice so that we can do include Safrano::Edm and then
@@ -69,12 +141,12 @@ module Safrano
       class Null < NilClass
         extend OutputClassMethods
         # nil --> null convertion is done by to_json
-        def self.odata_value(instance)
+        def self.odata_value(_instance)
           nil
         end
 
         def self.convert_from_urlparam(v)
-          return Contract::NOK unless (v == 'null')
+          return Contract::NOK unless v == 'null'
 
           Contract.valid(nil)
         end
@@ -94,7 +166,7 @@ module Safrano
       #  or false([nil, false])
       class Boolean < Object
         extend OutputClassMethods
-        def Boolean.odata_value(instance)
+        def self.odata_value(instance)
           instance ? true : false
         end
 
@@ -103,7 +175,7 @@ module Safrano
         end
 
         def self.convert_from_urlparam(v)
-          return Contract::NOK unless ['true', 'false'].include?(v)
+          return Contract::NOK unless %w[true false].include?(v)
 
           Contract.valid(v == 'true')
         end
@@ -115,7 +187,7 @@ module Safrano
         extend OutputClassMethods
 
         def self.convert_from_urlparam(v)
-          return Contract::NOK unless ((bytev = v.to_i) < 256)
+          return Contract::NOK unless (bytev = v.to_i) < 256
 
           Contract.valid(bytev)
         end
@@ -123,7 +195,7 @@ module Safrano
 
       class DateTime < ::DateTime
         extend OutputClassMethods
-        def DateTime.odata_value(instance)
+        def self.odata_value(instance)
           instance.to_datetime
         end
 
@@ -132,11 +204,9 @@ module Safrano
         end
 
         def self.convert_from_urlparam(v)
-          begin
-            Contract.valid(DateTime.parse(v))
-          rescue
-            return convertion_error(v)
-          end
+          Contract.valid(DateTime.parse(v))
+        rescue StandardError
+          convertion_error(v)
         end
       end
 
@@ -172,11 +242,9 @@ module Safrano
         extend OutputClassMethods
 
         def self.convert_from_urlparam(v)
-          begin
-            Contract.valid(v.to_f)
-          rescue
-            return Contract::NOK
-          end
+          Contract.valid(v.to_f)
+        rescue StandardError
+          Contract::NOK
         end
       end
     end

data/lib/odata/entity.rb

@@ -2,8 +2,8 @@
 
 require 'json'
 require 'rexml/document'
-require 'safrano.rb'
-require 'odata/model_ext.rb' # required for  self.class.entity_type_name ??
+require 'safrano'
+require 'odata/model_ext' # required for  self.class.entity_type_name ??
 require_relative 'navigation_attribute'
 
 module Safrano
@@ -86,9 +86,9 @@ module Safrano
       "#{self.class.uri}#{@odata_pk}"
     end
 
-    D = 'd'.freeze
-    DJ_OPEN = '{"d":'.freeze
-    DJ_CLOSE = '}'.freeze
+    D = 'd'
+    DJ_OPEN = '{"d":'
+    DJ_CLOSE = '}'
 
     # Json formatter for a single entity (probably OData V1/V2 like)
     def to_odata_json(request:)
@@ -151,11 +151,12 @@ module Safrano
       @uparms.check_all.tap_valid { return odata_get_output(req) }
              .tap_error { |e| return e.odata_get(req) }
     end
+
     def inactive_query_params
       @inactive_query_params = true
       self # chaining
     end
-    
+
     DELETE_REL_AND_ENTY = lambda do |entity, assoc, parent|
       Safrano.remove_nav_relation(assoc, parent)
       entity.destroy(transaction: false)
@@ -175,7 +176,7 @@ module Safrano
         destroy(transaction: false)
       end
     rescue StandardError => e
-      raise SequelAdapterError.new(e)
+      raise SequelAdapterError, e
     end
 
     # TODO: differentiate between POST/PUT/PATCH/MERGE
@@ -202,7 +203,7 @@ module Safrano
       if req.walker.media_value
         odata_media_value_put(req)
       elsif req.accept?(APPJSON)
-        data = JSON.parse(req.body.read)
+        data = Safrano::OData::JSON.parse_one(req.body.read, self.class)
         data.delete('__metadata')
 
         if req.in_changeset
@@ -219,7 +220,7 @@ module Safrano
     end
 
     def odata_patch(req)
-      req.with_parsed_data do |data|
+      req.with_parsed_data(self.class) do |data|
         data.delete('__metadata')
 
         # validate payload column names
@@ -310,40 +311,6 @@ module Safrano
     end
   end
 
-  module MappingBeforeOutput
-    # needed for proper datetime or Decimal output
-    def casted_values(cols = nil)
-      vals = case cols
-             when nil
-               # we need to dup the model values as we need to change it before passing to_json,
-               # but we dont want to interfere with Sequel's owned data
-               # (eg because then in worst case it could happen that we write back changed values to DB)
-               values_for_odata.dup
-             else
-               selected_values_for_odata(cols)
-             end
-      # TODO better design (perf/ do more during startup and less during request runtime )    
-      # TODO replace the quick and dirty BigDecimal hack with something better      
-      self.class.decimal_cols.each { |dc| vals[dc] = BigDecimal(vals[dc].to_s).to_s('F') if vals.key?(dc) }
-             
-      self.class.time_cols.each { |tc| vals[tc] = vals[tc]&.iso8601 if vals.key?(tc) }
-      vals
-    end
-  end
-  module NoMappingBeforeOutput
-    # current model does not have eg. Time fields--> no special mapping, just to_json is fine
-    # --> we can use directly the model.values (values_for_odata) withoud dup'ing it as we dont
-    # need to change it, just output as is
-    def casted_values(cols = nil)
-      case cols
-      when nil
-        values_for_odata
-      else
-        selected_values_for_odata(cols)
-      end
-    end
-  end
-
   module MediaEntity
     # media entity metadata for json h
     def metadata_h
@@ -434,9 +401,9 @@ module Safrano
     include Entity
     def pk_uri
       pku = +''
-      self.class.odata_upk_parts.each_with_index { |upart, i|
+      self.class.odata_upk_parts.each_with_index do |upart, i|
         pku = "#{pku}#{upart}#{pk[i]}"
-      }
+      end
       pku
     end
 
@@ -452,7 +419,7 @@ module Safrano
   module EntityCreateStandardOutput
     # Json formatter for a create  entity POST call / Standard version; return as json object
     def to_odata_create_json(request:)
-      # TODO Perf: reduce method call overhead
+      # TODO: Perf: reduce method call overhead
       # we added this redirection for readability and flexibility
       to_odata_json(request: request)
     end
@@ -461,7 +428,7 @@ module Safrano
   module EntityCreateArrayOutput
     # Json formatter for a create  entity POST call Array version
     def to_odata_create_json(request:)
-      # TODO Perf: reduce method call overhead
+      # TODO: Perf: reduce method call overhead
       # we added this redirection for readability and flexibility
       to_odata_array_json(request: request)
     end