safrano 0.3.4 → 0.4.4

data/lib/odata/collection_filter.rb

@@ -1,61 +1,68 @@
+# frozen_string_literal: true
+
 require 'odata/error.rb'
 
 require_relative 'filter/parse.rb'
 require_relative 'filter/sequel.rb'
 
-# 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}'"
+# filter base class and subclass in our OData namespace
+module Safrano
+  class FilterBase
+    # re-useable empty filtering (idempotent)
+    EmptyFilter = new.freeze
+
+    def self.factory(filterstr)
+      filterstr.nil? ? EmptyFilter : FilterByParse.new(filterstr)
+    end
+
+    def apply_to_dataset(dtcx)
+      Contract.valid(dtcx)
     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)}'"
+    # finalize
+    def finalize(_jh) Contract::OK end
+
+    def empty?
+      true
     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}'"
+    def parse_error?
+      false
     end
-    yield tmpstr
   end
-end
 
-# filter base class and subclass in our OData namespace
-module OData
   # should handle everything by parsing
-  class FilterByParse
-    def initialize(filterstr, jh)
+  class FilterByParse < FilterBase
+    attr_reader :filterstr
+
+    def initialize(filterstr)
       @filterstr = filterstr.dup
-      @ast = OData::Filter::Parser.new(@filterstr).build
-      @jh = jh
+      @ast = Safrano::Filter::Parser.new(@filterstr).build
     end
 
-    def apply_to_dataset(dtcx)
-      filtexpr = @ast.sequel_expr(@jh)
-      dtcx = @jh.dataset(dtcx).where(filtexpr).select_all(@jh.start_model.table_name)
+    # this build's up the Sequel Filter Expression, and as a side effect,
+    # it also finalizes the join helper that we need for the start dataset join
+    # 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.if_valid do |ast| ast.sequel_expr(jh) end
     end
 
-    def sequel_expr
-      @ast.sequel_expr(@jh)
+    def apply_to_dataset(dtcx)
+      #     normally finalize is called before, and thus @filtexpr is set
+      @filtexpr.map_result! do |f| dtcx.where(f) end
     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.kind_of? StandardError
+      @ast.error
+    end
+
+    def empty?
+      false
     end
   end
 end

data/lib/odata/collection_media.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'rack'
+require 'fileutils'
 require_relative './navigation_attribute.rb'
 
-module OData
+module Safrano
   module Media
     # base class for Media Handler
     class Handler
@@ -9,61 +12,173 @@ module OData
 
     # 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)
+        FileUtils.makedirs @abs_klass_dir unless Dir.exist?(@abs_klass_dir)
       end
 
       # minimal working implementation...
       #  Note: @file_server works relative to @root directory
       def odata_get(request:, entity:)
         media_env = request.env.dup
-        relpath = Dir.chdir(abs_path(entity)) do
+        media_env['PATH_INFO'] = filename(entity)
+        fsret = @file_server.call(media_env)
+        if fsret.first == 200
+          # provide own content type as we keep it in the media entity
+          fsret[1]['Content-Type'] = entity.content_type
+        end
+        fsret
+      end
+
+      # this is relative to @root
+      # eg. Photo/1
+      def media_path(entity)
+        File.join(@media_dir_name, media_directory(entity))
+      end
+
+      # relative to @root
+      # eg Photo/1/pommes-topaz.jpg
+      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
-          filename = Dir.glob('*').first
-
-          File.join(path(entity), filename)
+          File.join(media_path(entity), Dir.glob('*').sort.first)
         end
-        media_env['PATH_INFO'] = relpath
-        @file_server.call(media_env)
       end
 
-      # TODO perf: this can be precalculated and cached on MediaModelKlass level
-      #            and passed as argument to save_file
-      def abs_klass_dir(entity)
-        File.absolute_path(entity.klass_dir, @root)
+      # /@root/Photo/1
+      def abs_path(entity)
+        File.absolute_path(media_path(entity), @root)
       end
 
-      def abs_path(entity)
-        File.absolute_path(path(entity), @root)
+      # 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
+      def media_directory(entity)
+        entity.media_path_id
       end
 
-      # this is relative to @root
-      def path(entity)
-        File.join(entity.klass_dir, entity.media_path_id)
+      def in_media_directory(entity)
+        mpi = media_directory(entity)
+        Dir.mkdir mpi unless Dir.exist?(mpi)
+        Dir.chdir mpi do
+          yield
+        end
+      end
+
+      def odata_delete(entity:)
+        Dir.chdir(@abs_klass_dir) do
+          in_media_directory(entity) do
+            Dir.glob('*').each { |oldf| File.delete(oldf) }
+          end
+        end
       end
 
       # Here as well, MVP implementation
       def save_file(data:, filename:, entity:)
-        mpi = entity.media_path_id
-        Dir.chdir(abs_klass_dir(entity)) do
-          Dir.mkdir mpi unless Dir.exists?(mpi)
-          Dir.chdir mpi do
+        Dir.chdir(@abs_klass_dir) do
+          in_media_directory(entity) do
+            filename = '1'
             File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
           end
         end
       end
 
+      # needed for having a changing media ressource "source" metadata
+      # 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) do
+          in_media_directory(entity) do
+            Dir.glob('*').sort.last
+          end
+        end
+      end
+
       # Here as well, MVP implementation
       def replace_file(data:, filename:, entity:)
-        mpi = entity.media_path_id
-        Dir.chdir(abs_klass_dir(entity)) do
-          Dir.mkdir mpi unless Dir.exists?(mpi)
-          Dir.chdir mpi do
-            Dir.glob('*').each { |oldf| File.delete(oldf) }
+        Dir.chdir(@abs_klass_dir) do
+          in_media_directory(entity) do
+            version = nil
+            Dir.glob('*').sort.each do |oldf|
+              version = oldf
+              File.delete(oldf)
+            end
+            filename = (version.to_i + 1).to_s
+            File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
+          end
+        end
+      end
+    end
+    # Simple static File/Directory based media store handler
+    # similar to Rack::Static
+    # with directory Tree structure
+
+    class StaticTree < Static
+      SEP = '/00/'.freeze
+      VERS = '/v'.freeze
+
+      def self.path_builder(ids)
+        ids.map { |id| id.to_s.chars.join('/') }.join(SEP) << VERS
+      end
+
+      # 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
+      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)
+        mpi = media_directory(entity)
+        FileUtils.makedirs mpi unless Dir.exist?(mpi)
+        Dir.chdir(mpi) { yield }
+      end
+
+      def odata_delete(entity:)
+        Dir.chdir(@abs_klass_dir) do
+          in_media_directory(entity) do
+            Dir.glob('*').sort.each { |oldf| File.delete(oldf) if File.file?(oldf) }
+          end
+        end
+      end
+
+      # Here as well, MVP implementation
+      #      def replace_file(data:, filename:, entity:)
+      #        Dir.chdir(abs_klass_dir(entity)) do
+      #          in_media_directory(entity) do
+      #            Dir.glob('*').each { |oldf| File.delete(oldf) if File.file?(oldf) }
+      #            File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
+      #          end
+      #        end
+      #      end
+      # Here as well, MVP implementation
+      def replace_file(data:, filename:, entity:)
+        Dir.chdir(@abs_klass_dir) do
+          in_media_directory(entity) do
+            version = nil
+            Dir.glob('*').sort.each do |oldf|
+              version = oldf
+              File.delete(oldf)
+            end
+            filename = (version.to_i + 1).to_s
             File.open(filename, 'wb') { |f| IO.copy_stream(data, f) }
           end
         end
@@ -74,33 +189,36 @@ module OData
   # special handling for media entity
   module EntityClassMedia
     attr_reader :media_handler
+    attr_reader :slug_field
 
     # 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 use(klass, args)
+      args[:mediaklass] = self
+      @media_handler = klass.new(**args)
     end
 
-    def use(klass, *args)
-      @media_handler = klass.new(*args)
+    # API method for setting the model field mapped to SLUG on upload
+    def slug(inp)
+      @slug_field = inp
     end
 
     def api_check_media_fields
-      unless self.db_schema.has_key?(:content_type)
-        raise OData::API::MediaModelError, self
-      end
-      #      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
+
     def new_media_entity(mimetype:)
-      nh = {}
-      nh['content_type'] = mimetype
+      nh = { 'content_type' => mimetype }
       new_from_hson_h(nh)
     end
 
@@ -113,11 +231,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
 
@@ -125,6 +243,13 @@ module OData
 
           new_entity = new_media_entity(mimetype: mimetype)
 
+          if slug_field
+
+            new_entity.set_fields({ slug_field => filename },
+                                  data_fields,
+                                  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)
@@ -136,9 +261,11 @@ module OData
           req.register_content_id_ref(new_entity)
           new_entity.copy_request_infos(req)
 
-          media_handler.save_file(data: data, entity: new_entity, filename: filename)
-
-          [201, CT_JSON, new_entity.to_odata_post_json(service: req.service)]
+          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
+          [201, EMPTY_HASH, new_entity.to_odata_post_json(service: req.service)]
         else # TODO: other formats
           415
         end
@@ -146,3 +273,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,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