safrano 0.4.2 → 0.5.0

data/lib/odata/collection_filter.rb

@@ -1,56 +1,26 @@
-require 'odata/error.rb'
+# frozen_string_literal: true
 
-require_relative 'filter/parse.rb'
-require_relative 'filter/sequel.rb'
+require 'odata/error'
 
-# a few helper method
-class String
-  MASK_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
-  UNMASK_RGX = /'(%?)(\$\d+)(%?)'/.freeze
-  def with_mask_quoted_substrings!
-    cnt = 0
-    repl = {}
-    gsub!(MASK_RGX) do |_m|
-      cnt += 1
-      repl["$#{cnt}"] = Regexp.last_match(1)
-      "'$#{cnt}'"
-    end
-    yield self
-
-    gsub!(UNMASK_RGX) do |_m|
-      k = Regexp.last_match(2).to_s
-      "'#{Regexp.last_match(1)}#{repl[k]}#{Regexp.last_match(3)}'"
-    end
-  end
-
-  def with_mask_quoted_substrings
-    cnt = 0
-    repl = {}
-    tmpstr = gsub(MASK_RGX) do |_m|
-      cnt += 1
-      repl["$#{cnt}"] = Regexp.last_match(1)
-      "'$#{cnt}'"
-    end
-    yield tmpstr
-  end
-end
+require_relative 'filter/parse'
+require_relative 'filter/sequel'
 
 # filter base class and subclass in our OData namespace
-module OData
+module Safrano
   class FilterBase
     # re-useable empty filtering (idempotent)
-    EmptyFilter = new
+    EmptyFilter = new.freeze
 
     def self.factory(filterstr)
       filterstr.nil? ? EmptyFilter : FilterByParse.new(filterstr)
     end
 
     def apply_to_dataset(dtcx)
-      dtcx
+      Contract.valid(dtcx)
     end
 
     # finalize
-    def finalize(jh) end
+    def finalize(_jh) Contract::OK end
 
     def empty?
       true
@@ -60,12 +30,14 @@ module OData
       false
     end
   end
+
   # should handle everything by parsing
   class FilterByParse < FilterBase
     attr_reader :filterstr
+
     def initialize(filterstr)
       @filterstr = filterstr.dup
-      @ast = OData::Filter::Parser.new(@filterstr).build
+      @ast = Safrano::Filter::Parser.new(@filterstr).build
     end
 
     # this build's up the Sequel Filter Expression, and as a side effect,
@@ -73,16 +45,20 @@ module OData
     # the join-helper is shared by the order-by object and was potentially already
     # partly built on order-by object creation.
     def finalize(jh)
-      @filtexpr = @ast.sequel_expr(jh)
+      @filtexpr = @ast.if_valid { |ast| ast.sequel_expr(jh) }
     end
 
     def apply_to_dataset(dtcx)
       #     normally finalize is called before, and thus @filtexpr is set
-      dtcx.where(@filtexpr)
+      @filtexpr.map_result! { |f| dtcx.where(f) }
     end
 
+    # Note: this is really only *parse* error, ie the error encounterd while
+    # trying to build the AST
+    # Later when evaluating the AST, there can be other errors, they shall
+    # be tracked with @error
     def parse_error?
-      @ast.is_a? StandardError
+      @ast.error
     end
 
     def empty?

data/lib/odata/collection_media.rb

@@ -1,26 +1,42 @@
+# frozen_string_literal: true
+
 require 'rack'
 require 'fileutils'
-require_relative './navigation_attribute.rb'
+require_relative './navigation_attribute'
 
-module OData
+module Safrano
   module Media
     # base class for Media Handler
     class Handler
+      def check_before_create(data:,
+                              entity:,
+                              filename:)
+        Contract::OK
+      end
     end
 
     # Simple static File/Directory based media store handler
     # similar to Rack::Static
     # with a flat directory structure
     class Static < Handler
-      def initialize(root: nil)
+      def initialize(root: nil, mediaklass:)
         @root = File.absolute_path(root || Dir.pwd)
         @file_server = ::Rack::File.new(@root)
+        @media_class = mediaklass
+        @media_dir_name = mediaklass.to_s
+        register
+      end
+
+      def register
+        @abs_klass_dir = File.absolute_path(@media_dir_name, @root)
+      end
+
+      def create_abs_class_dir
+        FileUtils.makedirs @abs_klass_dir unless Dir.exist?(@abs_klass_dir)
       end
 
-      # TODO: testcase and better abs_klass_dir design
-      def register(klass)
-        abs_klass_dir = File.absolute_path(klass.type_name, @root)
-        FileUtils.makedirs abs_klass_dir unless Dir.exist?(abs_klass_dir)
+      def finalize
+        create_abs_class_dir
       end
 
       # minimal working implementation...
@@ -36,27 +52,20 @@ module OData
         fsret
       end
 
-      # TODO: [perf] this can be precalculated and cached on MediaModelKlass level
-      #            and passed as argument to save_file
-      # eg. /@root/Photo
-      def abs_klass_dir(entity)
-        File.absolute_path(entity.klass_dir, @root)
-      end
-
       # this is relative to @root
       # eg. Photo/1
       def media_path(entity)
-        File.join(entity.klass_dir, media_directory(entity))
+        File.join(@media_dir_name, media_directory(entity))
       end
 
       # relative to @root
-      # eg Photo/1/pommes-topaz.jpg
+      # eg Photo/1/1
       def filename(entity)
         Dir.chdir(abs_path(entity)) do
           # simple design: one file per directory, and the directory
           # contains the media entity-id --> implicit link between the media
           # entity
-          File.join(media_path(entity), Dir.glob('*').first)
+          File.join(media_path(entity), Dir.glob('*').max)
         end
       end
 
@@ -65,6 +74,11 @@ module OData
         File.absolute_path(media_path(entity), @root)
       end
 
+      # absolute filename
+      def abs_filename(entity)
+        File.absolute_path(filename(entity), @root)
+      end
+
       # this is relative to abs_klass_dir(entity) eg to /@root/Photo
       # simplest implementation is media_directory = entity.media_path_id
       # --> we get a 1 level depth flat directory structure
@@ -81,7 +95,7 @@ module OData
       end
 
       def odata_delete(entity:)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
             Dir.glob('*').each { |oldf| File.delete(oldf) }
           end
@@ -90,7 +104,7 @@ module OData
 
       # Here as well, MVP implementation
       def save_file(data:, filename:, entity:)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
             filename = '1'
             File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
@@ -102,19 +116,19 @@ module OData
       # after each upload, so that clients get informed about new versions
       # of the same media ressource
       def ressource_version(entity)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
-            Dir.glob('*').last
+            Dir.glob('*').max
           end
         end
       end
 
       # Here as well, MVP implementation
       def replace_file(data:, filename:, entity:)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
             version = nil
-            Dir.glob('*').each do |oldf|
+            Dir.glob('*').sort.each do |oldf|
               version = oldf
               File.delete(oldf)
             end
@@ -138,15 +152,14 @@ module OData
 
       # this is relative to abs_klass_dir(entity) eg to /@root/Photo
       # tree-structure
-      #  media_path_ids = 1  -->  1
-      #  media_path_ids = 15  -->  1/5
-      #  media_path_ids = 555  -->  5/5/5
-      #  media_path_ids = 5,5,5  -->  5/00/5/00/5
-      #  media_path_ids = 5,00,5  -->  5/00/0/0/00/5
-      #  media_path_ids = 5,xyz,5  -->  5/00/x/y/z/00/5
+      #  media_path_ids = 1  -->  1/v
+      #  media_path_ids = 15  -->  1/5/v
+      #  media_path_ids = 555  -->  5/5/5/v
+      #  media_path_ids = 5,5,5  -->  5/00/5/00/5/v
+      #  media_path_ids = 5,00,5  -->  5/00/0/0/00/5/v
+      #  media_path_ids = 5,xyz,5  -->  5/00/x/y/z/00/5/v
       def media_directory(entity)
         StaticTree.path_builder(entity.media_path_ids)
-        #        entity.media_path_ids.map{|id| id.to_s.chars.join('/')}.join(@sep)
       end
 
       def in_media_directory(entity)
@@ -156,9 +169,9 @@ module OData
       end
 
       def odata_delete(entity:)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
-            Dir.glob('*').each { |oldf| File.delete(oldf) if File.file?(oldf) }
+            Dir.glob('*').sort.each { |oldf| File.delete(oldf) if File.file?(oldf) }
           end
         end
       end
@@ -174,10 +187,10 @@ module OData
       #      end
       # Here as well, MVP implementation
       def replace_file(data:, filename:, entity:)
-        Dir.chdir(abs_klass_dir(entity)) do
+        Dir.chdir(@abs_klass_dir) do
           in_media_directory(entity) do
             version = nil
-            Dir.glob('*').each do |oldf|
+            Dir.glob('*').sort.each do |oldf|
               version = oldf
               File.delete(oldf)
             end
@@ -197,15 +210,21 @@ module OData
     # API method for defining the media handler
     # eg.
     # publish_media_model photos do
-    #   use OData::Media::Static, :root => '/media_root'
+    #   use Safrano::Media::Static, :root => '/media_root'
     # end
 
     def set_default_media_handler
-      @media_handler = OData::Media::Static.new
+      @media_handler = Safrano::Media::Static.new(mediaklass: self)
+    end
+
+    def finalize_media
+      @media_handler.finalize
     end
 
     def use(klass, args)
+      args[:mediaklass] = self
       @media_handler = klass.new(**args)
+      @media_handler.create_abs_class_dir
     end
 
     # API method for setting the model field mapped to SLUG on upload
@@ -214,11 +233,7 @@ module OData
     end
 
     def api_check_media_fields
-      raise(OData::API::MediaModelError, self) unless db_schema.key?(:content_type)
-
-      #      unless self.db_schema.has_key?(:media_src)
-      #        raise OData::API::MediaModelError, self
-      #      end
+      raise(Safrano::API::MediaModelError, self) unless db_schema.key?(:content_type)
     end
 
     #  END API methods
@@ -237,11 +252,11 @@ module OData
     # NOTE: we will implement this first in a MVP way. There will be plenty of
     #       potential future enhancements (performance, scallability, flexibility... with added complexity)
     # 4. create relation to parent if needed
-    def odata_create_entity_and_relation(req, assoc, parent)
+    def odata_create_entity_and_relation(req, assoc = nil, parent = nil)
       req.with_media_data do |data, mimetype, filename|
         ## future enhancement: validate allowed mimetypes ?
         # if (invalid = invalid_media_mimetype(mimetype))
-        #  ::OData::Request::ON_CGST_ERROR.call(req)
+        #  ::Safrano::Request::ON_CGST_ERROR.call(req)
         #  return [422, {}, ['Invalid mime type: ', invalid.to_s]]
         # end
 
@@ -256,20 +271,39 @@ module OData
                                   missing: :skip)
           end
 
-          # to_one rels are create with FK data set on the parent entity
-          if parent
-            odata_create_save_entity_and_rel(req, new_entity, assoc, parent)
-          else
-            # in-changeset requests get their own transaction
-            new_entity.save(transaction: !req.in_changeset)
-          end
+          # call before_create_entity media hook
+          new_entity.before_create_media_entity(data: data, mimetype: mimetype) if new_entity.respond_to? :before_create_media_entity
+
+          media_handler.check_before_create(data: data,
+                                            entity: new_entity,
+                                            filename: filename).if_valid { |_ret|
+            # to_one rels are create with FK data set on the parent entity
+            if parent
+              odata_create_save_entity_and_rel(req, new_entity, assoc, parent)
+            else
+              # in-changeset requests get their own transaction
+              new_entity.save(transaction: !req.in_changeset)
+            end
+
+            req.register_content_id_ref(new_entity)
+            new_entity.copy_request_infos(req)
+
+            # call before_create_media hook
+            new_entity.before_create_media if new_entity.respond_to? :before_create_media
+
+            media_handler.save_file(data: data,
+                                    entity: new_entity,
+                                    filename: filename)
 
-          req.register_content_id_ref(new_entity)
-          new_entity.copy_request_infos(req)
+            # call after_create_media hook
+            new_entity.after_create_media if new_entity.respond_to? :after_create_media
 
-          media_handler.save_file(data: data, entity: new_entity, filename: filename)
+            # json is default content type so we dont need to specify it here again
+            #           Contract.valid([201, EMPTY_HASH, new_entity.to_odata_post_json(service: req.service)])
+            # TODO quirks array mode !
+            Contract.valid([201, EMPTY_HASH, new_entity.to_odata_create_json(request: req)])
+          }.tap_error { |e| return e.odata_get(req) }.result
 
-          [201, CT_JSON, new_entity.to_odata_post_json(service: req.service)]
         else # TODO: other formats
           415
         end
@@ -277,3 +311,26 @@ module OData
     end
   end
 end
+
+# deprecated
+# REMOVE 0.6
+module OData
+  module Media
+    class Static < ::Safrano::Media::Static
+      def initialize(root: nil, mediaklass:)
+        ::Safrano::Deprecation.deprecate('OData::Media::Static',
+                                         'Use Safrano::Media::Static instead')
+
+        super
+      end
+    end
+    class StaticTree < ::Safrano::Media::StaticTree
+      def initialize(root: nil, mediaklass:)
+        ::Safrano::Deprecation.deprecate('OData::Media::StaticTree',
+                                         'Use Safrano::Media::StaticTree instead')
+
+        super
+      end
+    end
+  end
+end

data/lib/odata/collection_order.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'odata/error.rb'
 
 # all ordering related classes in our OData module
-module OData
+module Safrano
   # base class for ordering
   class OrderBase
     # re-useable empty ordering (idempotent)
-    EmptyOrder = new
+    EmptyOrder = new.freeze
 
     # input : the OData order string
     # returns a Order object that should have a apply_to(cx) method
@@ -28,6 +30,7 @@ module OData
 
   class Order < OrderBase
     attr_reader :oarg
+
     def initialize(ostr, jh)
       ostr.strip!
       @orderp = ostr

data/lib/odata/common_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class ODataCommonLogger < CommonLogger
     def call(env)

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