eitil 1.4.1 → 2.0.3

data/eitil_wrapper/lib/eitil_wrapper/decorators/controller_decorator.rb

@@ -1,72 +0,0 @@
-module EitilWrapper
-  module ControllerDecorator
-
-    private
-
-    def decorate(dec_item, dec_method: nil, dec_class: nil, **dec_kwargs)
-      all_args_to_ivars binding
-      set_ivars :dec_class, :decorator, :dec_method
-      send_to_decorator
-
-      rescue NameError => e
-        puts "EitilWrapper::ControllerDecorator => rescuing uninitialised constant #{e.name}, returning the object's default JSON instead."
-        return dec_item.as_json
-    end
-
-    def send_to_decorator
-       @decorator.send(@dec_method, @dec_item)
-     
-      rescue NoMethodError => e       
-        inform_no_method_for_decorator_error
-        @dec_item
-    end
-
-    def inform_no_method_for_decorator_error
-      message = "Warning: NoMethodError for #{@dec_class}##{@dec_method}, returned @dec_item instead."
-      Logger.new("#{Rails.root}/log/decorator_log.log").warn message
-      warn message
-    end
-
-    def set_dec_method
-      @dec_method = @dec_method || derived_dec_method || :base
-    end
-
-    def derived_dec_method
-      return unless respond_to? :params      
-      return :app if @decorator.respond_to?(:app) && params["isMobile"]
-      return :web if @decorator.respond_to?(:web) && params["isWeb"]
-    end
-
-    def set_dec_class
-      @dec_class = @dec_class ? manual_set_dec_class : derived_dec_class
-    end
-
-    def manual_set_dec_class
-      "#{@dec_class}Decorator".constantize
-    end
-
-    def derived_dec_class
-      "#{@dec_item.class.name}Decorator".constantize
-    end
-
-    def set_decorator
-      @dec_class.new **ivars
-    end
-
-    # Converts the controller_ivars, given in your main application's configuration,
-    # into an hash. If no controller_ivars, continue with converting, in order to avoid
-    # issues due to differing data types.
-    def controller_ivars
-      return {} unless Eitil.controller_ivars.any?
-
-      Eitil.controller_ivars.map do |ivar|
-        { ivar => instance_variable_get("@#{ivar.to_s}") }
-      end.inject &:merge
-    end
-
-    def ivars
-       @dec_kwargs.any? ? controller_ivars.merge(@dec_kwargs) : controller_ivars
-    end
-
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/decorators.rb

@@ -1,3 +0,0 @@
-
-require "eitil_wrapper/decorators/application_decorator"
-require "eitil_wrapper/decorators/controller_decorator"

data/eitil_wrapper/lib/eitil_wrapper/jobs/new_job.rb

@@ -1,34 +0,0 @@
-
-# require "eitil_wrapper/jobs/new_job"
-
-require "eitil_wrapper/jobs/single_method_job"
-
-Kernel.module_eval do
-
-  # BEWARE: _self is currently not accepted in perform_later jobs due to serialization errors
-
-  # The cases of 'id' and '_self' both handle instances, with the difference 
-  # being that 'id' works for objects that have a database record, while '_self'
-  # works for non database supported instanes, such as an Exporter instance.
-
-  def new_job(_method, *args, **kwargs)
-
-    if instance_methods(false).include? _method
-      define_method "#{_method}_job" do |_self = nil, *args, **kwargs|
-        
-        EitilWrapper::SingleMethodJob.perform_later(
-          *args, _class: self.class.to_s, _method: _method.to_s, id: safe_send(:id), _self: self.to_json, **kwargs
-        )
-      end
-
-    elsif singleton_methods(false).include? _method      
-      define_singleton_method "#{_method}_job" do |*args, **kwargs|
-       
-        EitilWrapper::SingleMethodJob.perform_later(
-          *args, _class: to_s, _method: _method.to_s, **kwargs
-        )
-      end
-    end 
-  end
-
-end

data/eitil_wrapper/lib/eitil_wrapper/jobs/new_job_now.rb

@@ -1,37 +0,0 @@
-
-# require "eitil_wrapper/jobs/new_job_now"
-
-require "eitil_wrapper/jobs/single_method_job"
-
-# BEWARE: This is an exact copy of the .new_job method, except for .perform_now instead of .perform_later and the method's name.
-# The reason for not using helper methods is to not unnecessarily fill and potentially fuck up the Kernel environment.
-
-Kernel.module_eval do
-
-  # BEWARE: _self is currently not accepted in perform_later jobs due to serialization errors
-
-  # The cases of 'id' and '_self' both handle instances, with the difference 
-  # being that 'id' works for objects that have a database record, while '_self'
-  # works for non database supported instanes, such as an Exporter instance.
-
-  def new_job_now(_method, *args, **kwargs)
-
-    if instance_methods(false).include? _method
-      define_method "#{_method}_job_now" do |_self = nil, *args, **kwargs|
-        
-        EitilWrapper::SingleMethodJob.perform_now(
-          *args, _class: self.class.to_s, _method: _method.to_s, id: safe_send(:id), _self: self.to_json, **kwargs
-        )
-      end
-
-    elsif singleton_methods(false).include? _method      
-      define_singleton_method "#{_method}_job_now" do |*args, **kwargs|
-       
-        EitilWrapper::SingleMethodJob.perform_now(
-          *args, _class: to_s, _method: _method.to_s, **kwargs
-        )
-      end
-    end 
-  end
-
-end

data/eitil_wrapper/lib/eitil_wrapper/jobs/single_method_job.rb

@@ -1,11 +0,0 @@
-# ISSUE: this code is currently defined eitil_wrapper/railtie.rb, since module inclusion 
-# somehow leads to errors in the initialization process. Ideally, this code would be
-# defined in eitil_wrapper/jobs/single_method_job.rb and dispatched in eitil_wrapper/railtie.rb
-
-# require "eitil_wrapper/railtie" to run the dynamic dispatch as an init hook during boot
-require "eitil_wrapper/railtie"
-
-module EitilWrapper
-  module CreateSingleMethodJob
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/jobs.rb

@@ -1,4 +0,0 @@
-
-require "eitil_wrapper/jobs/new_job"
-require "eitil_wrapper/jobs/new_job_now"
-require "eitil_wrapper/jobs/single_method_job"

data/eitil_wrapper/lib/eitil_wrapper/railtie.rb

@@ -1,94 +0,0 @@
-
-module EitilWrapper
-
-  class Railtie < Rails::Railtie
-
-    # Dynamic dispatching after initialization of Rails classes.
-
-    initializer "my_railtie.configure_rails_initialization", options: :after do |app|
-
-      if Object.const_defined?('EitilWrapper::Records::DefaultCalculators')
-        ::ApplicationRecord.send(:extend, EitilWrapper::Records::DefaultCalculators)
-      end
-
-      if Object.const_defined?('EitilWrapper::Records::DefaultScopes')
-        ::ApplicationRecord.send(:extend, EitilWrapper::Records::DefaultScopes)
-      end
-
-      if Object.const_defined?('EitilWrapper::Records::DefaultSorts')
-        ::ApplicationRecord.send(:extend, EitilWrapper::Records::DefaultSorts)
-      end
-
-      if Object.const_defined?('EitilWrapper::Callbacks::HelperMethods')
-        ::ApplicationRecord.send(:extend, EitilWrapper::Callbacks::HelperMethods)
-      end
-
-      if Object.const_defined?('EitilWrapper::CreateSingleMethodJob')
-        
-        # ISSUE: this code is currently defined eitil_wrapper/railtie.rb, since module inclusion 
-        # somehow leads to errors in the initialization process. Ideally, this code would be
-        # defined in eitil_wrapper/jobs/single_method_job.rb and dispatched in eitil_wrapper/railtie.rb
-
-        # BEWARE: _self is currently not accepted in perform_later jobs due to serialization errors
-
-        # BEWARE: The cases of 'id' and '_self' both handle instances, with the difference 
-        # being that 'id' works for objects that have a database record, while '_self'
-        # works for non database supported instanes, such as an Exporter instance.
-
-        module ::EitilWrapper
-          
-          class ::ApplicationJob < ActiveJob::Base
-          end
-
-          class SingleMethodJob < ::ApplicationJob
-            def perform(*args, _class:, _method:, id: nil, _self: nil, **kwargs)      
-              object = 
-                if id
-                  _class.constantize.find(id)
-                elsif _self
-                  _self
-                else
-                  _class.constantize
-                end
-
-              if args.present? and kwargs.present?
-                object.send _method, *args, **kwargs
-
-              elsif args.present?
-                object.send _method, *args
-
-              elsif kwargs.present?
-                object.send _method, **kwargs
-
-              else
-                object.send _method
-              end
-
-      end; end; end; end
-
-
-      if Object.const_defined?('EitilWrapper::RequestLogger::CreateLoggerJob')
-
-        module ::EitilWrapper
-          module RequestLogger
-            class LoggerJob < ::ApplicationJob
-
-            def perform(logger_object)
-              
-            # set path for logger
-            $request_logger_path ||= "#{Rails.root}/log/request_logger.log"
-
-            # create logger, if not present
-            if Dir[$request_logger_path].blank? || $request_logger.blank?
-              $request_logger = Logger.new($request_logger_path)
-            end
-
-            # add logger_object to logger
-            $request_logger.info(logger_object) 
-
-      end; end; end; end; end
-
-    end
-
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/records/default_calculators.rb

@@ -1,104 +0,0 @@
-
-# require "eitil_wrapper/records/default_calculators"
-
-# require "eitil_wrapper/railtie" to run the dynamic dispatch as an init hook during boot
-require "eitil_wrapper/railtie"
-
-module EitilWrapper
-  module Records
-    module DefaultCalculators
-
-      Eitil::ApplicationRecordModules << self
-
-      SharableNumberCalculators = -> (_class, column) {
-        _class.eitil_calculator :"#{column}_max", -> { _class.maximum(column) }
-        _class.eitil_calculator :"#{column}_min", -> { _class.minimum(column) }
-        _class.eitil_calculator :"#{column}_sum", -> { _class.sum(column) }
-        _class.eitil_calculator :"#{column}_avg", -> { _class.average(column) }
-      }
-
-      SharableIterableCalculators = -> (_class, column) {   
-        _class.eitil_calculator :"#{column}_sum",   -> { _class.pluck(column).flatten!.uniq }
-        _class.eitil_calculator :"#{column}_sum_i", -> { _class.pluck(column).flatten!.uniq.map(&:to_i) }
-        _class.eitil_calculator :"#{column}_sum_f", -> { _class.pluck(column).flatten!.uniq.map(&:to_f) }
-        _class.eitil_calculator :"#{column}_sum_d", -> { _class.pluck(column).flatten!.uniq.map(&:to_d) }
-      }
-
-      def inherited(subclass)
-        super
-        return if Eitil.skip_default_calculators_for_models.include?(subclass.to_s.to_sym)
-        
-        # Set the proper table_names for namespaced models. Without setting this,
-        # Rails run into problems due to the fact that the first call to the model's
-        # constant triggers this initializer first, and only thereafter the model file 
-        # which sets the correct table_name through a macro.
-        
-        namespaced_class    = subclass.to_s.include?('::')
-        subclass.table_name = subclass.to_s.gsub('::', '_').downcase.pluralize if namespaced_class
-
-        subclass.use_eitil_calculators
-
-        rescue => e
-          puts "default calculators failed for class '#{subclass}' with expected table '#{subclass.table_name}' because of #{e.class} and '#{e.to_s.split(' ').first}'"
-      end
-
-      def use_eitil_calculators 
-        return if abstract_class?
-        
-        # text[]           is postgresql's datatype for serialized arrays
-        # numeric          is postgresql's datatype for decimals
-        # double precision is postgresql's datatype for floats
-
-
-        %w[integer bigint double\ precision numeric].each do |_type| 
-          send :"create_eitil_#{_type.gsub(' ','_')}_calculators"
-        end
-
-        create_array_calculators
-      end
-
-      def eitil_calculator(_name, _proc)
-        # skip calculator methods for primary and foreign key columns
-        return if _name.to_s =~ /^id_[a-z]{1,}$/ || _name.to_s =~ /_id_[a-z]{1,}$/
-        
-        define_singleton_method(_name) { _proc.call } unless respond_to? _name
-      end
-    
-      def calculator_columns_of_type(data_type)
-        columns_hash.select { |column,v| v.sql_type == data_type }
-      end
-
-      def create_eitil_integer_calculators
-        calculator_columns_of_type("integer")&.map do |column, object|
-          SharableNumberCalculators.call self, column
-        end
-      end
-
-      def create_eitil_bigint_calculators
-        calculator_columns_of_type("bigint")&.map do |column, object|
-          SharableNumberCalculators.call self, column
-        end
-      end
-
-      def create_eitil_double_precision_calculators
-        calculator_columns_of_type("double\ precision")&.map do |column, object|
-          SharableNumberCalculators.call self, column
-        end
-      end
-
-      def create_eitil_numeric_calculators
-        calculator_columns_of_type("numeric")&.map do |column, object|
-          SharableNumberCalculators.call self, column
-        end
-      end
-
-      def create_array_calculators
-        columns = columns_hash.select { |column,v| v.sql_type == "text" && v.default == "{}" }
-        columns&.map do |column, object|
-          SharableIterableCalculators.call self, column
-        end
-      end
-            
-    end
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/records/default_scopes.rb

@@ -1,95 +0,0 @@
-
-# require "eitil_wrapper/records/default_scopes"
-
-# require "eitil_wrapper/railtie" to run the dynamic dispatch as an init hook during boot
-require "eitil_wrapper/railtie"
-
-module EitilWrapper
-  module Records
-    module DefaultScopes
-
-      Eitil::ApplicationRecordModules << self
-
-      SharableDateScopes = -> (_class, column) {
-        _class.eitil_scope :"#{column}_today",          -> { where("#{column} = ?", Date.today) }
-        _class.eitil_scope :"#{column}_past",           -> { where("#{column} < ?", Date.today) }
-        _class.eitil_scope :"#{column}_future",         -> { where("#{column} > ?", Date.today) }
-        
-        _class.eitil_scope :"#{column}_on_date",        -> (date) { where("#{column} = ?", date) }
-        _class.eitil_scope :"#{column}_before_date",    -> (date) { where("#{column} = ?", date) }
-        _class.eitil_scope :"#{column}_after_date",     -> (date) { where("#{column} = ?", date) }
-        _class.eitil_scope :"#{column}_between_dates",  -> (from, till) { where("#{column} >= ? and #{column} <= ?", from, till) }
-      }
-
-      SharableNumScopes = -> (_class, column) {
-        _class.eitil_scope :"#{column}_equal_to",       -> (number) { where("#{column} = ?", number) }
-        _class.eitil_scope :"#{column}_lower_than",     -> (number) { where("#{column} = <", number) }
-        _class.eitil_scope :"#{column}_higher_than",    -> (number) { where("#{column} = >", number) }
-        _class.eitil_scope :"#{column}_between",        -> (min, max) { where("#{column} >= ? and #{column} <= ?", min, max) }
-      }
-
-      def inherited(subclass)
-        super
-        return if Eitil.skip_default_scopes_for_models.include?(subclass.to_s.to_sym)
-        
-        # Set the proper table_names for namespaced models. Without setting this,
-        # Rails run into problems due to the fact that the first call to the model's
-        # constant triggers this initializer first, and only thereafter the model file 
-        # which sets the correct table_name through a macro.
-        
-        namespaced_class    = subclass.to_s.include?('::')
-        subclass.table_name = subclass.to_s.gsub('::', '_').downcase.pluralize if namespaced_class
-
-        subclass.use_eitil_scopes
-
-        rescue => e
-          puts "default scopes failed for class '#{subclass}' with expected table '#{subclass.table_name}' because of #{e.class} and '#{e.to_s.split(' ').first}'"
-      end
-
-      def use_eitil_scopes  
-        return if abstract_class?
-        %i[boolean datetime date integer float].each { |_type| send :"create_eitil_#{_type}_scopes" }
-      end
-
-      def eitil_scope(_name, _proc)
-        scope _name, _proc unless respond_to? _name
-      end
-    
-      def columns_of_type(data_type)
-        columns_hash.select { |column,v| v.sql_type_metadata.type == data_type }
-      end
-
-      def create_eitil_boolean_scopes
-        columns_of_type(:boolean)&.map do |column, object|      
-          eitil_scope :"#{column}_true",     -> { where(column => true) }
-          eitil_scope :"#{column}_false", -> { where(column => [false, nil]) }
-        end
-      end
-
-      def create_eitil_datetime_scopes
-        columns_of_type(:datetime)&.map do |column, object|
-          SharableDateScopes.call self, column
-        end
-      end
-
-      def create_eitil_date_scopes
-        columns_of_type(:date)&.map do |column, object|
-          SharableDateScopes.call self, column
-        end
-      end
-
-      def create_eitil_integer_scopes
-        columns_of_type(:integer)&.map do |column, object|
-          SharableNumScopes.call self, column
-        end
-      end
-
-      def create_eitil_float_scopes
-        columns_of_type(:float)&.map do |column, object|
-          SharableNumScopes.call self, column
-        end
-      end
-            
-    end
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/records/default_sorts.rb

@@ -1,81 +0,0 @@
-
-# require "eitil_wrapper/records/default_sorts"
-
-# require "eitil_wrapper/railtie" to run the dynamic dispatch as an init hook during boot
-require "eitil_wrapper/railtie"
-
-
-module EitilWrapper
-  module Records
-    module DefaultSorts
-
-      Eitil::ApplicationRecordModules << self
-
-      SharableDateSorts = -> (_class, column) {
-        _class.eitil_sort :"#{column}_oldest_first", -> { _class.order("#{column} ASC") }
-        _class.eitil_sort :"#{column}_newest_first", -> { _class.order("#{column} DESC") }
-      }
-
-      SharableNumSorts = -> (_class, column) {
-        _class.eitil_sort :"#{column}_ascending",    -> { _class.order("#{column} ASC") }
-        _class.eitil_sort :"#{column}_descending",   -> { _class.order("#{column} DESC") }
-      }
-
-      def inherited(subclass)
-        super
-        return if Eitil.skip_default_sorts_for_models.include?(subclass.to_s.to_sym)
-        
-        # Set the proper table_names for namespaced models. Without setting this,
-        # Rails run into problems due to the fact that the first call to the model's
-        # constant triggers this initializer first, and only thereafter the model file 
-        # which sets the correct table_name through a macro.
-        
-        namespaced_class    = subclass.to_s.include?('::')
-        subclass.table_name = subclass.to_s.gsub('::', '_').downcase.pluralize if namespaced_class
-
-        subclass.use_eitil_sorts
-
-        rescue => e
-          puts "default sorts failed for class '#{subclass}' with expected table '#{subclass.table_name}' because of #{e.class} and '#{e.to_s.split(' ').first}'"
-      end
-
-      def use_eitil_sorts  
-        return if abstract_class?
-        %i[datetime date integer float].each { |_type| send :"create_eitil_#{_type}_sorts" }
-      end
-
-      def eitil_sort(_name, _proc)
-        define_singleton_method(_name) { _proc.call } unless respond_to? _name 
-      end
-    
-      def sort_columns_of_type(data_type)
-        columns_hash.select { |column,v| v.sql_type_metadata.type == data_type }
-      end
-
-      def create_eitil_datetime_sorts
-        columns_of_type(:datetime)&.map do |column, object|
-          SharableDateSorts.call self, column
-        end
-      end
-
-      def create_eitil_date_sorts
-        columns_of_type(:date)&.map do |column, object|
-          SharableDateSorts.call self, column
-        end
-      end
-
-      def create_eitil_integer_sorts
-        columns_of_type(:integer)&.map do |column, object|
-          SharableNumSorts.call self, column
-        end
-      end
-
-      def create_eitil_float_sorts
-        columns_of_type(:float)&.map do |column, object|
-          SharableNumSorts.call self, column
-        end
-      end
-
-    end
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/records.rb

@@ -1,4 +0,0 @@
-
-require "eitil_wrapper/records/default_scopes"
-require "eitil_wrapper/records/default_calculators"
-require "eitil_wrapper/records/default_sorts"

data/eitil_wrapper/lib/eitil_wrapper/request_logger/controller_mixin.rb

@@ -1,48 +0,0 @@
-
-# require "eitil_wrapper/request_logger/controller_mixin"
-
-require_relative "logger_job"
-
-module EitilWrapper
-  module RequestLogger
-    module ControllerMixin
-
-      private
-
-      def log_request
-        $request_logger_path ||= "#{Rails.root}/log/request_logger.log"
-        EitilWrapper::RequestLogger::LoggerJob.perform_later(request_logger_object)
-      end
-      
-      def request_logger_object
-        
-        log_request = {
-          path:       request.env["REQUEST_PATH"],
-          method:     request.env["REQUEST_METHOD"],
-          query_str:  request.env["QUERY_STRING"], 
-        }
-       
-        log_params = {
-          params:     params.as_json
-        }
-
-        log_attributes = {
-          time:       Time.now.strftime("%Y-%m-%d %H:%M:%S")
-        }
-
-        log = {
-          request:    log_request,
-          params:     log_params,
-          attributes: log_attributes
-        }
-
-        log_time = log_attributes[:time]
-        log_strf = log.deep_symbolize_keys.to_s   
-        # log_strf may be hashed through eval(log_strf)
-
-        return log_strf
-      end    
-   
-    end
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/request_logger/logger_job.rb

@@ -1,17 +0,0 @@
-
-# require "eitil_wrapper/request_logger/logger_job"
-
-# require "eitil_wrapper/railtie" to run the dynamic dispatch as an init hook during boot
-require "eitil_wrapper/railtie"
-
-# ISSUE: this code is currently defined eitil_wrapper/railtie.rb, since module inclusion 
-# somehow leads to errors in the initialization process. Ideally, this code would be
-# defined in eitil_wrapper/request_logger/logger_job.rb and dispatched in eitil_wrapper/railtie.rb
-
-module EitilWrapper
-  module RequestLogger
-    module CreateLoggerJob
-
-    end
-  end
-end

data/eitil_wrapper/lib/eitil_wrapper/request_logger.rb

@@ -1,5 +0,0 @@
-
-# require "eitil_wrapper/request_logger"
-
-require_relative "request_logger/controller_mixin"
-require_relative "request_logger/logger_job"

data/eitil_wrapper/lib/eitil_wrapper/routes/extended_resources.rb

@@ -1,40 +0,0 @@
-module EitilWrapper
-  module ExtendedResources
-
-    RESOURCEFUL_ACTIONS = %i$ index new create show edit update destroy $  
-
-    private
-
-    def extended_resources(controller, **kwargs)
-      all_args_to_ivars binding
-
-      resources(controller, **resource_args) do
-        extended_routes&.each { |route| send(route).call controller }
-        yield if block_given?
-      end 
-    end
-
-    def resource_args
-      duplicate = @kwargs.dup
-      duplicate[:only] = resourceful_routes 
-      duplicate
-    end
-
-    def resourceful_routes
-      @kwargs.dig(:only) - extended_routes
-    end
-
-    def extended_routes
-      @kwargs.dig(:only) - RESOURCEFUL_ACTIONS
-    end
-
-    def new_route(verb, _method, action, scope)
-      self.class.send :define_method, _method do
-        -> (controller) { send(verb, _method, to: "#{controller}##{action}", on: scope) }
-      end
-    end
-
-  end
-end
-
-ActionDispatch::Routing::Mapper.__send__ :include, EitilWrapper::ExtendedResources

data/eitil_wrapper/lib/eitil_wrapper/routes.rb

@@ -1,2 +0,0 @@
-
-require "eitil_wrapper/routes/extended_resources"

data/eitil_wrapper/lib/eitil_wrapper.rb

@@ -1,9 +0,0 @@
-
-require "eitil_wrapper"
-
-require "eitil_wrapper/jobs"
-require "eitil_wrapper/records"
-require "eitil_wrapper/routes"
-require "eitil_wrapper/callbacks"
-require "eitil_wrapper/decorators"
-require "eitil_wrapper/request_logger"