safrano 0.5.3 → 0.6.0

data/lib/odata/model_ext.rb

@@ -5,6 +5,7 @@
 # Thus Below we have called that "EntityClass". It's meant as "Collection"
 
 require 'json'
+require 'base64'
 require 'rexml/document'
 require 'bigdecimal'
 require_relative '../safrano/core'
@@ -32,9 +33,14 @@ module Safrano
     attr_reader :default_template
     attr_reader :uri
     attr_reader :odata_upk_parts
-    attr_reader :time_cols
-    attr_reader :decimal_cols
+    attr_reader :casted_cols
     attr_reader :namespace
+    # store cols metata here in the model (sub)-class. Initially we stored this infos (eg. edm_types etc)
+    # directly into sequels db_schema hash. But this hash is on the upper Sequel::Model(table) class
+    # and is shared by all subclasses.
+    # By storing it separately here we are less dependant from Sequel, and have less issues with
+    # testing with multiples models class derived from same Sequel::Model(table)
+    attr_reader :cols_metadata
 
     # initialising block of code to be executed at end of
     # ServerApp.publish_service after all model classes have been registered
@@ -75,7 +81,7 @@ module Safrano
       @uparms = nil
       @params = nil
       @cx = nil
-#      @@time_cols = nil
+      @cols_metadata = {}
     end
 
     def build_uri(uribase)
@@ -96,11 +102,10 @@ module Safrano
 
     # Factory json-> Model Object instance
     def new_from_hson_h(hash)
-      #enty = new
-      #enty.set_fields(hash, data_fields, missing: :skip)
-      enty = create(hash)
-      #enty.set(hash)
-      enty
+      # enty = new
+      # enty.set_fields(hash, data_fields, missing: :skip)
+      create(hash)
+      # enty.set(hash)
     end
 
     def attrib_path_valid?(path)
@@ -178,13 +183,14 @@ module Safrano
              end
       # with their properties
       db_schema.each do |pnam, prop|
+        metadata = @cols_metadata[pnam]
         if prop[:primary_key] == true
           enty.add_element('Key').add_element('PropertyRef',
                                               'Name' => pnam.to_s)
         end
         attrs = { 'Name' => pnam.to_s,
                   #                  'Type' => Safrano.get_edm_type(db_type: prop[:db_type]) }
-                  'Type' => prop[:odata_edm_type] }
+                  'Type' => metadata[:edm_type] }
         attrs['Nullable'] = 'false' if prop[:allow_null] == false
         enty.add_element('Property', attrs)
       end
@@ -346,30 +352,82 @@ module Safrano
 
     def build_default_template
       @default_template = { all_values: EMPTYH }
-      if @nav_entity_attribs || @nav_collection_attribs
-        @default_template[:deferr] = (@nav_entity_attribs&.keys || []) + (@nav_collection_attribs&.keys || EMPTY_ARRAY)
+      @default_template[:deferr] = (@nav_entity_attribs&.keys || []) + (@nav_collection_attribs&.keys || EMPTY_ARRAY) if @nav_entity_attribs || @nav_collection_attribs
+    end
+
+    def build_casted_cols(service)
+      # cols needed catsting before final json output
+      @casted_cols = {}
+      db_schema.each do |col, props|
+        # first check if we have user-defined type mapping
+        usermap = nil
+        dbtyp = props[:db_type]
+        metadata = @cols_metadata[col]
+        if service.type_mappings.values.find { |map| usermap = map.match(dbtyp) }
+
+          metadata[:edm_type] = usermap.edm_type
+
+          @casted_cols[col] = usermap.castfunc
+          next # this will override our rules below !
+        end
+
+        if metadata[:edm_precision] && (metadata[:edm_type] =~ /\AEdm.Decimal\(/i)
+          # we save the precision and/or scale in the lambda (binding!)
+
+          @casted_cols[col] = if metadata[:edm_scale]
+                                lambda { |x|
+                                  # not sure if these copies are really needed, but feels better that way
+                                  # output  decimal with precision and scale
+                                  x&.toDecimalPrecisionScaleString(metadata[:edm_precision], metadata[:edm_scale])
+                                }
+                              else
+                                lambda { |x|
+                                  # not sure if these copies are really needed, but feels better that way
+                                  # output  decimal with precision only
+                                  x&.toDecimalPrecisionString(metadata[:edm_precision])
+                                }
+                              end
+
+          next
+        end
+        if metadata[:edm_type] == 'Edm.Decimal'
+          @casted_cols[col] = ->(x) { x&.toDecimalString }
+          next
+        end
+        # Odata V2 Spec:
+        # Edm.Binary	Base64 encoded value of an EDM.Binary value represented as a JSON string
+        # See for example https://services.odata.org/V2/Northwind/Northwind.svc/Categories(1)?$format=json
+        if metadata[:edm_type] == 'Edm.Binary'
+          @casted_cols[col] = ->(x) { Base64.encode64(x) unless x.nil? } # Base64
+          next
+        end
+        # TODO: check this more in details
+        # NOTE: here we use :type which is the sequel defined ruby-type
+        if props[:type] == :datetime || props[:type] == :date
+          #          @casted_cols[col] = ->(x) { x&.iso8601 }
+          @casted_cols[col] = ->(x) { x&.to_edm_json }
+        end
       end
     end
 
-    def finalize_publishing
+    def finalize_publishing(service)
       build_type_name
 
       # build default output template structure
       build_default_template
 
-      # Time columns
-      @time_cols = db_schema.select { |_c, v| v[:type] == :datetime }.map { |c, _v| c }
-
-      
-
-      # add edm_types into schema
-      db_schema.each do |_col, props|
-        props[:odata_edm_type] = Safrano.default_edm_type(ruby_type: props[:type],
-                                                          db_type: props[:db_type])
+      # add edm_types into metadata store
+      @cols_metadata = {}
+      db_schema.each do |col, props|
+        metadata = @cols_metadata.key?(col) ? @cols_metadata[col] : (@cols_metadata[col] = {})
+        Safrano.add_edm_types(metadata, props)
       end
-      # Edm.Decimal cols
-      @decimal_cols = db_schema.select { |_c, v| v[:odata_edm_type] == 'Edm.Decimal' }.map { |c, _v| c }
-      
+
+      build_casted_cols(service)
+      # unless @casted_cols.empty?
+      # require 'pry'
+      # binding.pry
+      # end
       # and finally build the path lists and allowed tr's
       build_attribute_path_list
       build_expand_path_list
@@ -379,7 +437,7 @@ module Safrano
       build_entity_allowed_transitions
 
       # for media
-      finalize_media if self.respond_to? :finalize_media
+      finalize_media if respond_to? :finalize_media
     end
 
     KEYPRED_URL_REGEXP = /\A\(\s*'?([\w=,'\s]+)'?\s*\)(.*)/.freeze
@@ -388,7 +446,7 @@ module Safrano
         @pk_names = []
         @pk_cast_from_string = {}
         odata_upk_build = []
-        primary_key.each { |pk|
+        primary_key.each do |pk|
           @pk_names << pk.to_s
           kvpredicate = case db_schema[pk][:type]
                         when :integer
@@ -398,19 +456,19 @@ module Safrano
                           "'?'"
                         end
           odata_upk_build << "#{pk}=#{kvpredicate}"
-        }
+        end
         @odata_upk_parts = odata_upk_build.join(',').split('?')
 
         # regex parts for unordered matching
-        @iuk_rgx_parts = primary_key.map { |pk|
+        @iuk_rgx_parts = primary_key.map do |pk|
           kvpredicate = case db_schema[pk][:type]
                         when :integer
-                          "(\\d+)"
+                          '(\\d+)'
                         else
                           "'(\\w+)'"
                         end
           [pk, "#{pk}=#{kvpredicate}"]
-        }.to_h
+        end.to_h
 
         # single regex assuming the key fields are ordered !
         @iuk_rgx = /\A#{@iuk_rgx_parts.values.join(',\s*')}\z/
@@ -424,7 +482,7 @@ module Safrano
         kvpredicate = case db_schema[primary_key][:type]
                       when :integer
                         @pk_cast_from_string = ->(str) { Integer(str) }
-                        "(\\d+)"
+                        '(\\d+)'
                       else
                         "'(\\w+)'"
                       end
@@ -556,14 +614,14 @@ module Safrano
         scan_rgx_parts = @iuk_rgx_parts.dup
         mdch = {}
 
-        mid.split(/\s*,\s*/).each { |midpart|
+        mid.split(/\s*,\s*/).each do |midpart|
           mval = nil
-          mpk, mrgx = scan_rgx_parts.find { |pk, rgx|
+          mpk, mrgx = scan_rgx_parts.find do |_pk, rgx|
             if (md = rgx.match(midpart))
               mval = md[1]
             end
-          }
-          if mpk and mval
+          end
+          if mpk && mval
             mdch[mpk] = if (pk_cast = @pk_cast_from_string[mpk])
                           pk_cast.call(mval)
                         else
@@ -573,7 +631,7 @@ module Safrano
           else
             return Contract::NOK
           end
-        }
+        end
         # normally arriving here we have mdch filled with key values pairs,
         # but not in the model key ordering. lets just re-order the values
         mdc = @iuk_rgx_parts.keys.map { |pk| mdch[pk] }
@@ -592,7 +650,7 @@ module Safrano
 
     def parse_odata_key(rawid)
       if (md = @iuk_rgx.match(rawid))
-        if (@pk_cast_from_string)
+        if @pk_cast_from_string
           Contract.valid(@pk_cast_from_string.call(md[1]))
         else
           Contract.valid(md[1]) # no cast needed, eg for string
@@ -616,7 +674,7 @@ module Safrano
     # 2. Create relationship if needed
     def odata_create_entity_and_relation(req, assoc = nil, parent = nil)
       # TODO: this is for v2 only...
-      req.with_parsed_data do |data|
+      req.with_parsed_data(self) do |data|
         data.delete('__metadata')
 
         # validate payload column names

data/lib/odata/request/json.rb

@@ -0,0 +1,171 @@
+require 'json'
+require 'time'
+
+# client parsing functionality to ease testing
+
+module Safrano
+  module OData
+    # this is used to parse inbound json payload on POST / PUT & co
+    # it does not do symbolize but proper (hopefully) type casting when needed
+    module JSON
+      # def self.parse(*args)
+      #  ::JSON.parse(*args)
+      # end
+
+      def self.cast_values_in(resd, typ)
+        typ.db_schema.each do |f, props|
+          metadata = typ.cols_metadata[f]
+
+          case props[:type]
+          when :datetime, :date
+            fstr = f.to_s
+            # resd[fstr] = Time.parse(resd[f]) if resd[fstr]
+            resd[fstr] = Sequel.datetime_class.from_edm_json(resd[fstr]) if resd[fstr]
+          end
+        end
+
+        resd
+      end
+
+      def self.parse_one(*args, type)
+        cast_values_in(::JSON.parse(*args), type)
+      end
+    end
+  end
+  # This is used from the Test-suite code !
+  # it does recursive / deep symbolize additionally to inbound casting
+  module XJSON
+    def self.get_class_from_meta(meta)
+      # type is normally namespaced !  --> split.last is the class
+      meta[:type].split('.').last.constantize
+    end
+
+    # symbolise keys and cast/parse values back to the proper ruby type;
+    # proper type meaning the one that Sequel chooses when loading data from the DB
+    # apply recursively to nested navigation attributes sub-structures
+    def self.cast_values_in(resd)
+      resd.symbolize_keys!
+
+      if (defered = resd[:__deferred])
+        defered.symbolize_keys!
+      elsif meta = resd[:__metadata]
+        meta.symbolize_keys!
+
+        # type is normally namespaced !  --> split.last is the class
+        typ = get_class_from_meta(meta)
+
+        typ.db_schema.each do |f, props|
+          metadata = typ.cols_metadata[f]
+          case props[:type]
+          when :datetime
+            #              resd[f] = Time.parse(resd[f]) if resd[f]
+            #              resd[f] = DateTime.strptime(resd[f], '/Date(%Q)').to_time if resd[f]
+            resd[f] = Sequel.datetime_class.from_edm_json(resd[f]) if resd[f]
+          when :decimal
+            resd[f] = BigDecimal(resd[f])
+          when :float
+            resd[f] = Float(resd[f])
+          else
+            # TODO: better typ-system
+            # Currently Sequel loads Numeric(x,y) as Float
+            resd[f] = Float(resd[f]) if metadata[:edm_type] =~ /\A\s*Edm.Decimal/
+          end
+        end
+
+        if typ.nav_entity_attribs
+          typ.nav_entity_attribs.each_key do |nattr|
+            cast_values_in(resd[nattr.to_sym]) if resd[nattr.to_sym]
+          end
+        end
+
+        if typ.nav_collection_attribs
+          typ.nav_collection_attribs.each_key do |ncattr|
+            if (resd_attr = resd[ncattr.to_sym])
+              if (defered = resd_attr['__deferred'])
+                defered.symbolize_keys! if defered
+              else
+                resd_attr.symbolize_keys! #  'results' --> :results
+                resd_attr[:results].each { |enty| cast_values_in(enty) }
+              end
+            end
+          end
+        end
+      end
+      resd
+    end
+
+    # symbolise attrib names (h-keys)
+    # apply recursively to nested navigation attributes sub-structures
+    def self.symbolize_attribs_in(resd)
+      resd.symbolize_keys!
+
+      if (defered = resd[:__deferred])
+        defered.symbolize_keys!
+      elsif meta = resd[:__metadata]
+        meta.symbolize_keys!
+
+        typ = get_class_from_meta(meta)
+
+        if typ.nav_entity_attribs
+          typ.nav_entity_attribs.each_key do |nattr|
+            symbolize_attribs_in(resd[nattr.to_sym])
+          end
+        end
+
+        if typ.nav_collection_attribs
+          typ.nav_collection_attribs.each_key do |ncattr|
+            if (defered = resd[ncattr.to_sym]['__deferred'])
+              defered.symbolize_keys!
+            else
+              resd[ncattr.to_sym].each { |enty| symbolize_attribs_in(enty) }
+            end
+          end
+        end
+
+      end
+      resd
+    end
+
+    def self.parse_one_nocast(*args)
+      resh = ::JSON.parse(*args)
+      symbolize_attribs_in(resh['d'])
+    end
+
+    def self.parse_one(*args)
+      resh = ::JSON.parse(*args)
+      cast_values_in(resh['d'])
+    end
+
+    def self.v1_parse_coll(*args)
+      resh = ::JSON.parse(*args)
+
+      resh['d'].map! { |currd| cast_values_in(currd) }
+
+      resh['d']
+    end
+
+    def self.parse_coll(*args)
+      resh = ::JSON.parse(*args)
+
+      resh['d']['results'].map! { |currd| cast_values_in(currd) }
+
+      resh['d']
+    end
+
+    def self.v1_parse_coll_nocast(*args)
+      resh = ::JSON.parse(*args)
+
+      resh['d'].map! { |currd| symbolize_attribs_in(currd) }
+
+      resh['d']
+    end
+
+    def self.parse_coll_nocast(*args)
+      resh = ::JSON.parse(*args)
+
+      resh['d']['results'].map! { |currd| symbolize_attribs_in(currd) }
+
+      resh['d']
+    end
+  end
+end

data/lib/odata/transition.rb

@@ -6,14 +6,14 @@ require_relative 'error'
 module Safrano
   # represents a state transition when navigating/parsing the url path
   # from left to right
-  class Transition 
+  class Transition
     attr_accessor :trans
     attr_accessor :match_result
     attr_accessor :rgx
     attr_reader :remain_idx
 
-    EMPTYSTR = ''.freeze
-    SLASH = '/'.freeze
+    EMPTYSTR = ''
+    SLASH = '/'
 
     RESULT_BAD_REQ_ERR = [nil, :error, ::Safrano::BadRequestError].freeze
     RESULT_NOT_FOUND_ERR = [nil, :error, ::Safrano::ErrorNotFound].freeze
@@ -52,26 +52,30 @@ module Safrano
       ctx.method(@trans).call(@match_result)
     end
   end
-    
-  #Transition that does not move/change the input 
-  class InplaceTransition < Transition 
-    def initialize(trans: )
+
+  # Transition that does not move/change the input
+  class InplaceTransition < Transition
+    def initialize(trans:)
       @trans = trans
     end
+
     def do_match(str)
       @str = str
     end
+
     def path_remain
-      @str 
+      @str
     end
+
     def path_done
       EMPTYSTR
     end
+
     def do_transition(ctx)
       ctx.method(@trans).call(@str)
     end
   end
-     
+
   TransitionEnd = Transition.new('\A(\/?)\z', trans: 'transition_end')
   TransitionExecuteFunc = InplaceTransition.new(trans: 'transition_execute_func')
   TransitionMetadata = Transition.new('\A(\/\$metadata)(.*)',

data/lib/odata/url_parameters.rb

@@ -68,20 +68,20 @@ module Safrano
       return Contract::OK unless @params['$top']
 
       itop = number_or_nil(@params['$top'])
-      (itop.nil? || itop.zero?) ? BadRequestError : Contract::OK
+      itop.nil? || itop.zero? ? BadRequestError : Contract::OK
     end
 
     def check_skip
       return Contract::OK unless @params['$skip']
 
       iskip = number_or_nil(@params['$skip'])
-      (iskip.nil? || iskip.negative?) ? BadRequestError : Contract::OK
+      iskip.nil? || iskip.negative? ? BadRequestError : Contract::OK
     end
 
     def check_inlinecount
       return Contract::OK unless (icp = @params['$inlinecount'])
 
-      ((icp == 'allpages') || (icp == 'none')) ? Contract::OK : BadRequestInlineCountParamError
+      (icp == 'allpages') || (icp == 'none') ? Contract::OK : BadRequestInlineCountParamError
     end
 
     def check_filter

data/lib/odata/walker.rb

@@ -29,24 +29,24 @@ module Safrano
 
     # are $links requested ?
     attr_reader :do_links
-    
-    attr_reader :request 
+
+    attr_reader :request
 
     NIL_SERVICE_FATAL = 'Walker is called with a nil service'
     EMPTYSTR = ''
     SLASH = '/'
 
-    def initialize(service, path, request, content_id_refs = nil )
+    def initialize(service, path, request, content_id_refs = nil)
       raise NIL_SERVICE_FATAL unless service
 
       path = URI.decode_www_form_component(path)
       @context = service
       @content_id_refs = content_id_refs
-      
+
       # needed because for function import we need access to the url parameters (req.params)
       # who contains the functions params
       @request = request
-      
+
       @contexts = [@context]
 
       @path_start = @path_remain = if service
@@ -115,16 +115,16 @@ module Safrano
       end
     end
 
-    # execute function import with request parameters 
+    # execute function import with request parameters
     # input: @context containt the function to exectute,
     #        @request.params should normally contain the params
-    # result: validate the params for the given function, execute the function and 
+    # result: validate the params for the given function, execute the function and
     #          return it's result back into @context,
     #          and finaly set status :end   (or error if anyting went wrong )
     def do_run_with_execute_func
       @context, @status, @error = @context.do_execute_func(@request)
     end
-   
+
     # little hacks... depending on returned state, set some attributes
     def state_mappings
       case @status
@@ -183,7 +183,7 @@ module Safrano
     end
 
     def finalize
-      (@status == :end) ? Contract.valid(@end_context) : @error
+      @status == :end ? Contract.valid(@end_context) : @error
     end
   end
 end

data/lib/safrano/multipart.rb

@@ -411,9 +411,7 @@ module MIME
 
         def unparse(bodyonly = false)
           b = +String.new
-          unless bodyonly
-            b << "#{Safrano::CONTENT_TYPE}: #{@hd[CTT_TYPE_LC]}#{CRLF}"
-          end
+          b << "#{Safrano::CONTENT_TYPE}: #{@hd[CTT_TYPE_LC]}#{CRLF}" unless bodyonly
 
           b << crbdcr = "#{CRLF}--#{@boundary}#{CRLF}"
           b << @content.map(&:unparse).join(crbdcr)

data/lib/safrano/rack_app.rb

@@ -10,7 +10,7 @@ module Safrano
   module MethodHandlers
     def odata_options
       @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid do |context|
+             .if_valid do |_context|
         # cf. stackoverflow.com/questions/22924678/sinatra-delete-response-headers
         headers.delete('Content-Type')
         @response.headers.delete('Content-Type')
@@ -119,7 +119,7 @@ module Safrano
         @response = Safrano::Response.new
 
         before.tap_error { |err| dispatch_error(err) }
-              .tap_valid { |res| dispatch }
+              .tap_valid { |_res| dispatch }
 
       # handle remaining Sequel errors that we couldnt prevent with our
       # own pre-checks
@@ -161,15 +161,3 @@ module Safrano
     end
   end
 end
-
-# deprecated
-# REMOVE 0.6
-module OData
-  class ServerApp < Safrano::ServerApp
-    def self.publish_service(&block)
-      ::Safrano::Deprecation.deprecate('OData::ServerApp',
-                                       'Use Safrano::ServerApp instead')
-      super
-    end
-  end
-end

data/lib/safrano/rack_builder.rb

@@ -17,18 +17,3 @@ module Rack
     end
   end
 end
-
-# deprecated
-# REMOVE 0.6
-module Rack
-  module OData
-    class Builder < ::Rack::Safrano::Builder
-      def initialize(default_app = nil, &block)
-        ::Safrano::Deprecation.deprecate('Rack::OData::Builder',
-                                         'Use Rack::Safrano::Builder instead')
-
-        super
-      end
-    end
-  end
-end

data/lib/safrano/request.rb

@@ -144,11 +144,11 @@ module Safrano
       end
     end
 
-    def with_parsed_data
+    def with_parsed_data(type)
       if content_type == APPJSON
         # Parse json payload
         begin
-          data = JSON.parse(body.read)
+          data = Safrano::OData::JSON.parse_one(body.read, type)
         rescue JSON::ParserError => e
           ON_CGST_ERROR.call(self)
           return [400, EMPTY_HASH, ['JSON Parser Error while parsing payload : ',
@@ -239,7 +239,7 @@ module Safrano
         get_minversion.if_valid do |minv|
           return MAX_LT_MIN_DTSV_ERROR if minv > maxv
 
-          get_version.if_valid do |v|
+          get_version.if_valid do |_v|
             @service = nil
             @service = case maxv
                        when '1'

data/lib/safrano/response.rb

@@ -18,8 +18,8 @@ module Safrano
     end
 
     def body=(value)
-      value = value.body while ::Rack::Response === value
-      @body = String === value ? [value.to_str] : value
+      value = value.body while value.is_a?(::Rack::Response)
+      @body = value.is_a?(String) ? [value.to_str] : value
     end
 
     def each
@@ -51,7 +51,7 @@ module Safrano
     private
 
     def calculate_content_length?
-      headers['Content-Type'] && !headers['Content-Length'] && (Array === body)
+      headers['Content-Type'] && !headers['Content-Length'] && body.is_a?(Array)
     end
 
     def calculated_content_length