eitil 2.0.1 → 2.0.5

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,8 +0,0 @@
-
-require "eitil_wrapper"
-
-require "eitil_wrapper/jobs"
-require "eitil_wrapper/records"
-require "eitil_wrapper/routes"
-require "eitil_wrapper/callbacks"
-require "eitil_wrapper/request_logger"

data/spec/eitil_wrapper/callbacks/helper_methods_spec.rb

@@ -1,34 +0,0 @@
-
-RSpec.describe "EitilWrapper::Callbacks" do
-
-  let(:callbacks) { User.instance_methods(false) }
-
-  context "for columns of datatype: boolean" do
-
-    it "should create the callback .{column_name}_became_true" do
-      expect(callbacks).to include(:confirmed_became_true)
-    end
-
-    it "should create the callback .{column_name}_becomes_true" do
-      expect(callbacks).to include(:confirmed_becomes_true)
-    end
-
-    it "should create the callback .{column_name}_to_true (works for both become and became)" do
-      expect(callbacks).to include(:confirmed_to_true)
-    end
-
-    it "should create the callback .{column_name}_became_false" do
-      expect(callbacks).to include(:confirmed_became_false)
-    end
-
-    it "should create the callback .{column_name}_becomes_false" do
-      expect(callbacks).to include(:confirmed_becomes_false)
-    end
-
-    it "should create the callback .{column_name}_to_false (works for both become and became)" do
-      expect(callbacks).to include(:confirmed_to_false)
-    end
-
-  end
-  
-end

data/spec/eitil_wrapper/jobs/single_method_job_spec.rb

@@ -1,72 +0,0 @@
-
-RSpec.describe "EitilWrapper::Jobs" do
-
-  let(:user) { User.create(first_name: "Donald", last_name: "Duck") }
-
-  it "should create a new method, if the new_job (perform_later) is used for a singleton method" do
-    expect(User.methods).to include(:this_is_a_singleton_method_job)
-  end
-
-  it "should create a new method, if the new_job (perform_later) is used for an instance method" do
-    expect(User.instance_methods).to include(:this_is_an_instance_method_job)
-  end
-
-  it "should create a new method, if the new_job_now (perform_now) is used for a singleton method" do
-    expect(User.methods).to include(:this_is_a_singleton_method_job_now)
-  end
-
-  it "should create a new method, if the new_job_now (perform_now) is used for an instance method" do
-    expect(User.instance_methods).to include(:this_is_an_instance_method_job_now)
-  end
-
-  it "should allow us to perform the created singleton perform_later method" do
-    begin
-      User.this_is_a_singleton_method_job
-      status = 'passed'
-    rescue
-      status = 'failed'
-    end
-    expect(status).to eq 'passed'
-  end
-
-  it "should allow us to perform the created instance perform_later method" do
-    begin
-      user.this_is_an_instance_method_job
-      status = 'passed'
-    rescue
-      status = 'failed'
-    end
-    expect(status).to eq 'passed'
-  end
-
-  it "should allow us to perform the created singleton perform_now method" do
-    begin
-      User.this_is_a_singleton_method_job_now
-      status = 'passed'
-    rescue
-      status = 'failed'
-    end
-    expect(status).to eq 'passed'
-  end
-
-  it "should allow us to perform the created instance perform_now method" do
-    begin
-      user.this_is_an_instance_method_job_now
-      status = 'passed'
-    rescue
-      status = 'failed'
-    end
-    expect(status).to eq 'passed'
-  end
-
-  it "should accept positional arguments" do
-    return_value = User.this_is_a_singleton_method_job_now("positional_argument")   
-    expect(return_value).to eq "positional_argument"
-  end
-
-  it "should accept keyword arguments " do
-    return_value = User.this_is_a_singleton_method_job_now(keyword_value: "keyword_argument")   
-    expect(return_value).to eq "keyword_argument"
-  end
-
-end

data/spec/eitil_wrapper/routes/extended_resources_spec.rb

@@ -1,16 +0,0 @@
-
-# NOT YET IMPLEMENTED, SINCE THIS PART OF EITIL IS NOT YET IN USE.
-# FIRST HOOK UP INTO EITJE_API, SINCE THAT MAY CHANGE THE FUNCTIONALITY.
-
-# RSpec.describe "EitilWrapper::Routes" do
-
-#   before do
-#     @pretty_routes = `cd spec/dummy_app && rails routes`
-#     @routes = @pretty_routes.gsub(/[ \t]+/, ' ')
-#   end
-
-#   it "should " do
-#     expect(@routes).to include('POST /users(.:format) users#create')
-#   end
-
-# end