safrano 0.4.1 → 0.4.6

data/lib/odata/collection_order.rb

@@ -1,19 +1,36 @@
-require 'odata/error.rb'
+# frozen_string_literal: true
 
-# Ordering with ruby expression
-module OrderWithRuby
-  # this module requires the @fn attribute to exist where it is used
-  def fn=(fnam)
-    @fn = fnam
-    @fn_tab = fnam.split('/').map(&:to_sym)
-  end
-end
+require 'odata/error.rb'
 
 # all ordering related classes in our OData module
-module OData
+module Safrano
   # base class for ordering
-  class Order
+  class OrderBase
+    # re-useable empty ordering (idempotent)
+    EmptyOrder = new.freeze
+
+    # input : the OData order string
+    # returns a Order object that should have a apply_to(cx) method
+    def self.factory(orderstr, jh)
+      orderstr.nil? ? EmptyOrder : MultiOrder.new(orderstr, jh)
+    end
+
+    def empty?
+      true
+    end
+
+    def parse_error?
+      false
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+  end
+
+  class Order < OrderBase
     attr_reader :oarg
+
     def initialize(ostr, jh)
       ostr.strip!
       @orderp = ostr
@@ -21,23 +38,14 @@ module OData
       build_oarg if @orderp
     end
 
-    class << self
-      attr_reader :regexp
-    end
-
-    # input : the filter string
-    # returns a filter object that should have a apply_to(cx) method
-    def self.new_by_parse(orderstr, jh)
-      Order.new_full_match_complexpr(orderstr, jh)
-    end
-
-    # handle  with Sequel
-    def self.new_full_match_complexpr(orderstr, jh)
-      ComplexOrder.new(orderstr, jh)
+    def empty?
+      false
     end
 
     def apply_to_dataset(dtcx)
-      dtcx
+      # Warning, we need order_append, simply order(oarg) overwrites
+      # previous one !
+      dtcx.order_append(@oarg)
     end
 
     def build_oarg
@@ -60,26 +68,31 @@ module OData
   end
 
   # complex ordering logic
-  class ComplexOrder < Order
+  class MultiOrder < Order
     def initialize(orderstr, jh)
       super
       @olist = []
       @jh = jh
-      return unless orderstr
-
-      @olist = orderstr.split(',').map do |ostr|
-        oo = Order.new(ostr, @jh)
-        oo.oarg
-      end
+      @orderstr = orderstr.dup
+      @olist = orderstr.split(',').map { |ostr| Order.new(ostr, @jh) }
     end
 
     def apply_to_dataset(dtcx)
-      @olist.each { |oarg|
-        # Warning, we need order_append, simply order(oarg) overwrites
-        # previous one !
-        dtcx = dtcx.order_append(oarg)
-      }
+      @olist.each { |osingl| dtcx = osingl.apply_to_dataset(dtcx) }
       dtcx
     end
+
+    def parse_error?
+      @orderstr.split(',').each do |pord|
+        pord.strip!
+        qualfn, dir = pord.split(/\s/)
+        qualfn.strip!
+        dir.strip! if dir
+        return true unless @jh.start_model.attrib_path_valid? qualfn
+        return true unless [nil, 'asc', 'desc'].include? dir
+      end
+
+      false
+    end
   end
 end

data/lib/odata/common_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class ODataCommonLogger < CommonLogger
     def call(env)
@@ -5,41 +7,41 @@ module Rack
       super
     end
 
-    # Handle https://github.com/rack/rack/pull/1526 
+    # Handle https://github.com/rack/rack/pull/1526
     # new in Rack 2.2.2 : Format has now 11 placeholders instead of 10
-    
-    MSG_FUNC = if (FORMAT.count('%') == 10)
-      lambda {|env,length,status,began_at|
-        FORMAT % [
-          env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-          env["REMOTE_USER"] || "-",
-          Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-          env[REQUEST_METHOD],
-          env[SCRIPT_NAME] + env[PATH_INFO],
-          env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-          env[SERVER_PROTOCOL],
-          status.to_s[0..3],
-          length,
-          Utils.clock_time - began_at
-        ]
-      } 
-      elsif (FORMAT.count('%') == 11)
-       lambda {|env,length,status,began_at|
-        FORMAT % [
-          env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-          env["REMOTE_USER"] || "-",
-          Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-          env[REQUEST_METHOD],
-          env[SCRIPT_NAME],
-          env[PATH_INFO],
-          env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-          env[SERVER_PROTOCOL],
-          status.to_s[0..3],
-          length,
-          Utils.clock_time - began_at 
-          ]
-        }
-      end
+
+    MSG_FUNC = if FORMAT.count('%') == 10
+                 lambda { |env, length, status, began_at|
+                   FORMAT % [
+                     env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-',
+                     env['REMOTE_USER'] || '-',
+                     Time.now.strftime('%d/%b/%Y:%H:%M:%S %z'),
+                     env[REQUEST_METHOD],
+                     env[SCRIPT_NAME] + env[PATH_INFO],
+                     env[QUERY_STRING].empty? ? '' : "?#{env[QUERY_STRING]}",
+                     env[SERVER_PROTOCOL],
+                     status.to_s[0..3],
+                     length,
+                     Utils.clock_time - began_at
+                   ]
+                 }
+               elsif FORMAT.count('%') == 11
+                 lambda { |env, length, status, began_at|
+                   FORMAT % [
+                     env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-',
+                     env['REMOTE_USER'] || '-',
+                     Time.now.strftime('%d/%b/%Y:%H:%M:%S %z'),
+                     env[REQUEST_METHOD],
+                     env[SCRIPT_NAME],
+                     env[PATH_INFO],
+                     env[QUERY_STRING].empty? ? '' : "?#{env[QUERY_STRING]}",
+                     env[SERVER_PROTOCOL],
+                     status.to_s[0..3],
+                     length,
+                     Utils.clock_time - began_at
+                   ]
+                 }
+               end
 
     def batch_log(env, status, header, began_at)
       length = extract_content_length(header)

data/lib/odata/complex_type.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Safrano
+  module FunctionImport
+    class ResultDefinition
+      D = 'd'
+      DJ_OPEN = '{"d":'
+      DJ_CLOSE = '}'
+      METAK = '__metadata'
+      TYPEK = 'type'
+      VALUEK = 'value'
+      RESULTSK = 'results'
+      COLLECTION = 'Collection'
+
+      def initialize(klassmod)
+        @klassmod = klassmod
+      end
+
+      def to_odata_json(result, _req)
+        "#{DJ_OPEN}#{result.odata_h.to_json}#{DJ_CLOSE}"
+      end
+
+      def type_metadata
+        @klassmod.type_name
+      end
+    end
+    class ResultAsComplexType < ResultDefinition
+    end
+    class ResultAsComplexTypeColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(coll, _req)
+        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
+      end
+    end
+    class ResultAsEntity < ResultDefinition
+      def to_odata_json(result_entity, req)
+        result_entity.instance_exec do
+          copy_request_infos(req)
+          to_odata_json(request: req)
+        end
+      end
+    end
+    class ResultAsEntityColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(result_dataset, req)
+        coll = Safrano::OData::Collection.new(@klassmod)
+        coll.instance_exec do
+          @params = req.params
+          initialize_dataset(result_dataset)
+        end
+        coll.to_odata_json(request: req)
+      end
+    end
+    class ResultAsPrimitiveType < ResultDefinition
+      def to_odata_json(result, _req)
+        { D => { METAK => { TYPEK => type_metadata },
+                 VALUEK => @klassmod.odata_value(result) } }.to_json
+      end
+    end
+    class ResultAsPrimitiveTypeColl < ResultDefinition
+      def type_metadata
+        "Collection(#{@klassmod.type_name})"
+      end
+
+      def to_odata_json(result, _req)
+        { D => { METAK => { TYPEK => type_metadata },
+                 RESULTSK => @klassmod.odata_collection(result) } }.to_json
+      end
+    end
+  end
+
+  # a generic Struct  like ruby's standard Struct, but implemented with a
+  # @values Hash, similar to Sequel models and
+  # with added OData functionality
+  class ComplexType
+    attr_reader :values
+
+    @namespace = nil
+    def self.namespace
+      @namespace
+    end
+
+    def self.props
+      @props
+    end
+
+    def self.type_name
+      "#{@namespace}.#{self.to_s}"
+    end
+
+    def initialize
+      @values = {}
+    end
+    METAK = '__metadata'
+    TYPEK = 'type'
+
+    def odata_h
+      ret = { METAK => { TYPEK => self.class.type_name } }
+      @values.each { |k, v|
+        ret[k] = if v.respond_to? :odata_h
+                   v.odata_h
+                 else
+                   v
+                 end
+      }
+      ret
+    end
+
+    def self.return_as_collection_descriptor
+      FunctionImport::ResultAsComplexTypeColl.new(self)
+    end
+
+    def self.return_as_instance_descriptor
+      FunctionImport::ResultAsComplexType.new(self)
+    end
+
+    # add metadata xml to the passed REXML schema object
+    def self.add_metadata_rexml(schema)
+      ctty = schema.add_element('ComplexType', 'Name' => to_s)
+
+      # with their properties
+      @props.each do |prop, rbtype|
+        attrs = { 'Name' => prop.to_s,
+                  'Type' => rbtype.type_name }
+        ctty.add_element('Property', attrs)
+      end
+      ctty
+    end
+  end
+
+  def Safrano.ComplexType(**props)
+    Class.new(Safrano::ComplexType) do
+      @props = props
+      props.each { |a, klassmod|
+        asym = a.to_sym
+        define_method(asym) do @values[asym] end
+        define_method("#{a}=") do |val| @values[asym] = val end
+      }
+      define_method :initialize do |*p, **kwvals|
+        super()
+        p.zip(props.keys).each { |val, a| @values[a] = val } if p
+        kwvals.each { |a, val| @values[a] = val if props.key?(a) } if kwvals
+      end
+    end
+  end
+end

data/lib/odata/edm/primitive_types.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Safrano
+  # Type mapping DB --> Edm
+  #  TypeMap = {"INTEGER" => "Edm.Int32" , "TEXT" => "Edm.String",
+  # "STRING" => "Edm.String"}
+  # Todo: complete mapping... this is just for the most common ones
+
+  # TODO: use Sequel GENERIC_TYPES: -->
+  # Constants
+  # GENERIC_TYPES = %w'String Integer Float Numeric BigDecimal Date DateTime
+  # Time File TrueClass FalseClass'.freeze
+  # Classes specifying generic types that Sequel will convert to
+  # database-specific types.
+  DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.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:)
+    case ruby_type
+    when :integer
+      'Edm.Int32'
+    when :string
+      'Edm.String'
+    when :date, :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
+  # have Edm::Int32 etc... availabe
+  # and we can have Edm::String different from ::String
+  module Edm
+    module Edm
+      module OutputClassMethods
+        def type_name
+          "Edm.#{name.split('::').last}"
+        end
+
+        def odata_collection(array)
+          array
+        end
+
+        def odata_value(instance)
+          instance
+        end
+      end
+
+      class Null < NilClass
+        extend OutputClassMethods
+        # nil --> null convertion is done by to_json
+        def self.odata_value(instance)
+          nil
+        end
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (v == 'null')
+
+          Contract.valid(nil)
+        end
+      end
+
+      # Binary is a String with the BINARY encoding
+      class Binary < String
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          Contract.valid(v.dup.force_encoding('BINARY'))
+        end
+      end
+
+      # an object alwys evaluates to
+      #  true ([true, anything not false & not nil objs])
+      #  or false([nil, false])
+      class Boolean < Object
+        extend OutputClassMethods
+        def Boolean.odata_value(instance)
+          instance ? true : false
+        end
+
+        def self.odata_collection(array)
+          array.map { |v| odata_value(v) }
+        end
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless ['true', 'false'].include?(v)
+
+          Contract.valid(v == 'true')
+        end
+      end
+
+      # Bytes are usualy represented as Intger in ruby,
+      # eg.String.bytes --> Array of ints
+      class Byte < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless ((bytev = v.to_i) < 256)
+
+          Contract.valid(bytev)
+        end
+      end
+
+      class DateTime < ::DateTime
+        extend OutputClassMethods
+        def DateTime.odata_value(instance)
+          instance.to_datetime
+        end
+
+        def self.odata_collection(array)
+          array.map { |v| odata_value(v) }
+        end
+
+        def self.convert_from_urlparam(v)
+          begin
+            Contract.valid(DateTime.parse(v))
+          rescue
+            return convertion_error(v)
+          end
+        end
+      end
+
+      class String < ::String
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          Contract.valid(v)
+        end
+      end
+
+      class Int32 < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (ret = number_or_nil(v))
+
+          Contract.valid(ret)
+        end
+      end
+
+      class Int64 < Integer
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          return Contract::NOK unless (ret = number_or_nil(v))
+
+          Contract.valid(ret)
+        end
+      end
+
+      class Double < Float
+        extend OutputClassMethods
+
+        def self.convert_from_urlparam(v)
+          begin
+            Contract.valid(v.to_f)
+          rescue
+            return Contract::NOK
+          end
+        end
+      end
+    end
+  end
+end
+
+# include Safrano
+
+# x = Edm::String.new('xxx')
+
+# pp x