safrano 0.4.1 → 0.4.2

data/lib/odata/collection_filter.rb

@@ -37,25 +37,56 @@ end
 
 # filter base class and subclass in our OData namespace
 module OData
+  class FilterBase
+    # re-useable empty filtering (idempotent)
+    EmptyFilter = new
+
+    def self.factory(filterstr)
+      filterstr.nil? ? EmptyFilter : FilterByParse.new(filterstr)
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    # finalize
+    def finalize(jh) end
+
+    def empty?
+      true
+    end
+
+    def parse_error?
+      false
+    end
+  end
   # 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
     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.sequel_expr(jh)
     end
 
-    def sequel_expr
-      @ast.sequel_expr(@jh)
+    def apply_to_dataset(dtcx)
+      #     normally finalize is called before, and thus @filtexpr is set
+      dtcx.where(@filtexpr)
     end
 
     def parse_error?
-      @ast.kind_of? StandardError
+      @ast.is_a? StandardError
+    end
+
+    def empty?
+      false
     end
   end
 end

data/lib/odata/collection_media.rb

@@ -12,18 +12,17 @@ module OData
     # similar to Rack::Static
     # with a flat directory structure
     class Static < Handler
-    
       def initialize(root: nil)
         @root = File.absolute_path(root || Dir.pwd)
         @file_server = ::Rack::File.new(@root)
       end
 
-      # TODO testcase and better abs_klass_dir design
+      # 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.exists?(abs_klass_dir)
+        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:)
@@ -37,7 +36,7 @@ module OData
         fsret
       end
 
-      # TODO perf: this can be precalculated and cached on MediaModelKlass level
+      # 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)
@@ -49,7 +48,7 @@ module OData
       def media_path(entity)
         File.join(entity.klass_dir, media_directory(entity))
       end
-      
+
       # relative to @root
       # eg Photo/1/pommes-topaz.jpg
       def filename(entity)
@@ -60,7 +59,7 @@ module OData
           File.join(media_path(entity), Dir.glob('*').first)
         end
       end
-      
+
       # /@root/Photo/1
       def abs_path(entity)
         File.absolute_path(media_path(entity), @root)
@@ -75,18 +74,18 @@ module OData
 
       def in_media_directory(entity)
         mpi = media_directory(entity)
-        Dir.mkdir mpi unless Dir.exists?(mpi)
+        Dir.mkdir mpi unless Dir.exist?(mpi)
         Dir.chdir mpi do
           yield
         end
       end
 
-      def odata_delete(request:, entity:)
+      def odata_delete(entity:)
         Dir.chdir(abs_klass_dir(entity)) do
           in_media_directory(entity) do
             Dir.glob('*').each { |oldf| File.delete(oldf) }
           end
-        end      
+        end
       end
 
       # Here as well, MVP implementation
@@ -105,17 +104,20 @@ module OData
       def ressource_version(entity)
         Dir.chdir(abs_klass_dir(entity)) do
           in_media_directory(entity) do
-            Dir.glob('*').last 
+            Dir.glob('*').last
           end
-        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
             version = nil
-            Dir.glob('*').each { |oldf| version = oldf; File.delete(oldf) }
+            Dir.glob('*').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
@@ -125,15 +127,15 @@ module OData
     # Simple static File/Directory based media store handler
     # similar to Rack::Static
     # with directory Tree structure
-    
+
     class StaticTree < Static
-      
-      SEP = '/00/'
-           
-      def StaticTree.path_builder(ids)
-        ids.map{|id| id.to_s.chars.join('/')}.join(SEP) + '/v'
+      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
@@ -144,55 +146,54 @@ module OData
       #  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)
+        #        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.exists?(mpi)
-        Dir.chdir mpi do
-          yield
-        end
+        FileUtils.makedirs mpi unless Dir.exist?(mpi)
+        Dir.chdir(mpi) { yield }
       end
 
-      def odata_delete(request:, entity:)
+      def odata_delete(entity:)
         Dir.chdir(abs_klass_dir(entity)) do
           in_media_directory(entity) do
             Dir.glob('*').each { |oldf| File.delete(oldf) if File.file?(oldf) }
           end
-        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(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(entity)) do
           in_media_directory(entity) do
             version = nil
-            Dir.glob('*').each { |oldf| version = oldf; File.delete(oldf) }
+            Dir.glob('*').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
-    
   end
 
   # 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
@@ -209,23 +210,21 @@ module OData
 
     # API method for setting the model field mapped to SLUG on upload
     def slug(inp)
-      @slug_field = inp 
+      @slug_field = inp
     end
-    
+
     def api_check_media_fields
-      unless self.db_schema.has_key?(:content_type)
-        raise OData::API::MediaModelError, self
-      end
+      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
     end
 
-#  END API methods
+    #  END API methods
 
     def new_media_entity(mimetype:)
-      nh = {}
-      nh['content_type'] = mimetype
+      nh = { 'content_type' => mimetype }
       new_from_hson_h(nh)
     end
 
@@ -252,11 +251,11 @@ module OData
 
           if slug_field
 
-            new_entity.set_fields({ slug_field =>  filename}, 
-                              data_fields, 
-                              missing: :skip)
+            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)

data/lib/odata/collection_order.rb

@@ -1,18 +1,32 @@
 require 'odata/error.rb'
 
-# 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
-
 # all ordering related classes in our OData module
 module OData
   # base class for ordering
-  class Order
+  class OrderBase
+    # re-useable empty ordering (idempotent)
+    EmptyOrder = new
+
+    # 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!
@@ -21,23 +35,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 +65,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

@@ -5,41 +5,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)