eitil 0.3.1 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f822863c972553dc89dca4e80fce4b197c89c27f78456342195f46b920fa07f5
-  data.tar.gz: 0e852adfd5a9127d3d67f349102bb6000121b730a5a42d0628b09beab45723fe
+  metadata.gz: 92cb9e9c82e5a3bfac7cbc0b5f662428bac557a2c3abbca8e30c86d60174363a
+  data.tar.gz: 20c072c5d8b8ce2e055ff0635472a66fdb11ba4155d770ac3cd600be0c0892da
 SHA512:
-  metadata.gz: cc64496f6e70c4d737ddf6bf091988ab01425802852034dd1d0c083bee1cda38ee25381927b498fc74c0094f27c071b71e10b360fc00ac477e81635b509d1915
-  data.tar.gz: ac2c18d0bd040e892caf008de55550cd09322fb69b09d15efd6adf6d147ce399b8e5aff547603af1311c7ebb86f0a8051da40211791d70042ee4e87a57ef23b3
+  metadata.gz: 945e8da34ffe7c89a24c11d2c4f75f2861ed9355ed0ed0c6759cc57d63485d7bb37006be1c4cb4f1fa8c93d13a672b238f4c99ec3110001db917cdc4cc2e02e0
+  data.tar.gz: d0a0641152e75e6f100eda08f83a3b253d8d80dd570fb26d76a2649822180e0f3c834da64012bb5d0e61709163fc81dbc7986ec5fa04d8d74faa8fd6a7f290a9

data/README.md

@@ -13,11 +13,19 @@ Add this line to your application's Gemfile:
 
 ```ruby
 
+gem 'eitil' # check the latest version on https://rubygems.org/gems/eitil
+
+```
+
+Or, if you want a specific branch (requires auth for private branch):
+
+```ruby
+
 gem 'eitil', git: 'https://github.com/eitje-app/eitil_engine', branch: 'production'
 
 ```
 
-Or this line, with your own path correctly set, for development purposes:
+Or, for development purposes:
 
 ```ruby
 
@@ -42,15 +50,21 @@ args_to_ivars(binding, *local_vars)
 # sets specified keywords arguments of the method's local binding to instance variables
 # call as: all_args_to_ivars binding :user_id, :user_name
 
-all_kwargs_to_ivars(binding)
+all_kwargs_to_ivars(local_binding, namespace=:kwargs)
 # sets the method's **kwargs argument to instance variables, with each key as the ivar's "@#{name}" and the value as its value
 # call as: kwargs_to_ivars binding
+# the keywords container name can be overwritten, e.g. the common :attributes
 
 set_ivars(*ivars)
 # sets instance variables named @"#{ivar}" for each symbol passed, by invoking send("set_#{ivar}")
 # e.g. set_ivars(:user) sets @user with the value returned by your local method .set_user
 # call as: set_ivars :user, :authentication, :connection
 
+run_validations(*validations)
+# calls a method for each argument, namespaced as "validate_#{argument}"
+# call as: run_validations(:single_receipt, :single_order)
+# => calls #validate_single_receipt and #validate_single_order
+
 safe_send(method, *args, return_value: nil)
 # a safe version of .send, which in case of an error rescues and returns return_value (default: nil) instead
 
@@ -79,10 +93,12 @@ all_methods(include_ancestors = true, grep: nil)
 ## Module
 
 ```ruby
-include_concerns_of(*directories)
-# includes all models/concerns/{sub_directory}/* within a module or class
+include_concerns_of(*directories, namespace: nil)
+# includes models/concerns/{directories}/* if no namespace if given, or all concerns within the given namespace
 # call as: include_concerns_of :user, :mail 
 # => includes all modules of models/concerns/user/* and models/oncerns/mail/*
+# or call as: include_concerns_of :request_service, namespace: Eivid::Concerns
+# tip: call Class.included_modules to view all included modules 
 ```
 
 
@@ -109,6 +125,16 @@ slice_params(*args)
 
 
 
+## ApplicationRecord
+
+```ruby
+self.all_associations
+# returns all associations for a given model
+# call as: Environment.all_associations
+```
+
+
+
 ## DateTime
 
 ```ruby
@@ -151,7 +177,7 @@ decorate(dec_item, dec_method: nil, dec_class: nil, **dec_kwargs)
 # initializers/eitil.rb
 
 Eitil.set_config do |config|
-  config.get_controller_ivars_method = 'API::VerlofVerzoekenController.controller_ivars' # => [:user, :env]
+  config.get_controller_ivars_method = 'API::BaseController.controller_ivars' # => [:user, :env]
 end
 ```
 
@@ -201,14 +227,18 @@ The router wrapper is a single module which is automatically included into your
 
 ### Info
 
-The Eitil jobs wrapper enables you to create perform_later jobs on the fly, without the need to create a new class and file. The macro new_job accepts a :method as argument and defines a new method :method_job. The newly defined :method_job, when called, performs the orginal :method in the background. The new_job macro accepts both instance methods and singleton methods, which are defined within there own method scope.
+The Eitil jobs wrapper enables you to create perform_now and perform_later jobs on the fly, without the need to create a new class and file. The macro new_job accepts a :method as argument and defines a new method :method_job. The newly defined :method_job, when called, performs the orginal :method in the background. The new_job macro accepts both instance methods and singleton methods, which are defined within there own method scope. In contrast, the new_job_debugger macro defines a new :method_job_debugger method, which performs in the foreground.
 
 ### Job Macro
 
 ```ruby
-new_job(_method)
-# assuming a method :print_hello_world, call as: new_job :hello_world
-# => method :hello_world_job
+new_job(_method, *args, **kwargs)
+# assuming a method :hello_world, call as: new_job :hello_world
+# => defines :hello_world_job
+
+new_job_debugger(_method, *args, **kwargs)
+# assuming a method :hello_world, call as: new_job_debugger :hello_world
+# => defines :hello_world_job_debugger
 ```
 
 - method is 
@@ -223,15 +253,7 @@ The new_job macro is monkey patched into Kernel, therefore no configuration is r
 
 ### Info
 
-The Eitil scopes wrapper creates various default scopes for a model, simply through including 'use_eitil_scopes' in the top of your model file, for example:
-
-```ruby
-# models/user.rb
-
-class User < ApplicationRecord
-  use_eitil_scopes
-end
-```
+The Eitil scopes wrapper creates various default scopes for a model.
 
 ### The Scopes
 
@@ -263,6 +285,22 @@ Scopes are generated through the columns of your model's database table. Which s
 .{column_name}_between_dates(start_date, end_date)
 .{column_name}_oldest_first
 .{column_name}_newest_first
+
+# columns of datatype: integer
+.{column_name}_equal_to(number)      
+.{column_name}_lower_than(number)
+.{column_name}_higher_than(number)
+.{column_name}_between(min, max)
+.{column_name}_ascending
+.{column_name}_descending
+
+# columns of datatype: float
+.{column_name}_equal_to(number)      
+.{column_name}_lower_than(number)
+.{column_name}_higher_than(number)
+.{column_name}_between(min, max)
+.{column_name}_ascending
+.{column_name}_descending
 ```
 
 ### Configuration
@@ -270,3 +308,31 @@ Scopes are generated through the columns of your model's database table. Which s
 Your models should inherit the module Eitil::DefaultScopes through inclusion in a superclass, such as ApplicationRecord.
 
 
+
+# Modules
+
+
+
+## Eitil::Dir
+
+### Info
+
+The Eitil::Dir module provides methods which help you introspect your Rails project.
+
+### Methods
+
+```ruby
+Eitil::Dir.contents(directory='app')
+# returns all files and subdirectories of a given directory
+
+Eitil::Dir.files(directory='app')
+# returns all files of a given directory
+
+Eitil::Dir.subdirs(directory='app')
+# returns all subdirectories of a given directory
+
+Eitil::Dir.lines(directory='app')
+# returns the total amount of lines of all files of a given directory
+```
+
+

data/config/initializers/modules/dir.rb

@@ -0,0 +1,21 @@
+module Eitil::Dir
+  class << self
+
+    def contents(directory='app')
+      Dir[File.join(directory, '**', '*')]
+    end
+
+    def files(directory='app')
+      contents(directory).select { |file| File.file?(file) }
+    end
+
+    def subdirs(directory='app')
+      contents(directory).select { |file| File.directory?(file) }
+    end
+
+    def lines(directory='app')
+      files(directory).map { |file| File.open(file).count }.sum
+    end
+
+  end
+end

data/config/initializers/monkeys/application_controller.rb

@@ -1,4 +1,4 @@
-module ApplicationMonkey
+module ApplicationControllerMonkey
   extend ActiveSupport::Concern 
   included do
 
@@ -11,4 +11,4 @@ module ApplicationMonkey
   end
 end
 
-ApplicationController.send :include, ApplicationMonkey
+ApplicationController.send :include, ApplicationControllerMonkey

data/config/initializers/monkeys/application_record.rb

@@ -0,0 +1,16 @@
+require "#{Eitil::Engine.root.to_s}/config/initializers/wrappers/scopes/default_scopes.rb"
+
+module ApplicationRecordMonkey
+  extend ActiveSupport::Concern 
+  included do
+
+    def self.all_associations
+      reflect_on_all_associations.map do |assoc|
+        { assoc.name => assoc.association_class.to_s.demodulize }
+      end.inject &:merge
+    end
+
+  end
+end
+
+ApplicationRecord.send :include, ApplicationRecordMonkey

data/config/initializers/monkeys/hash.rb

@@ -8,7 +8,7 @@ class Hash
       return answer if answer
     end
 
-    false
+    nil
   end
 
 end

data/config/initializers/monkeys/kernel.rb

@@ -12,8 +12,8 @@ Kernel.module_eval do
     end
   end
 
-  def all_kwargs_to_ivars(local_binding)
-    local_binding.local_variable_get(:kwargs).each do |name, value|
+  def all_kwargs_to_ivars(local_binding, namespace=:kwargs)
+    local_binding.local_variable_get(namespace).each do |name, value|
       instance_variable_set "@#{name}", value
     end
   end
@@ -24,6 +24,10 @@ Kernel.module_eval do
     end
   end
 
+  def run_validations(*validations)
+    validations.each { |v| eval "validate_#{v}" }
+  end
+
   def safe_call(*args, return_value: nil, &block)
     block.call self, *args
     rescue

data/config/initializers/monkeys/module.rb

@@ -1,7 +1,7 @@
 class Module
 
-  def include_concerns_of(*directories)
-    directories.map! { |dir| dir.to_s.camelcase }
+  def include_concerns_of(*directories, namespace: nil)
+    directories.map! { |dir| "#{namespace}::#{dir.to_s.camelcase}" }
 
     directories.each do |dir|
       konstants = dir.constantize.constants(false)

data/config/initializers/wrappers/jobs/active_job_macros.rb

@@ -1,18 +1,52 @@
 Kernel.module_eval do
 
-  def new_job(_method)
+  # 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
-        Eitil::SingleMethodJob.perform_later(_class: self.class.to_s, _method: _method.to_s, id: id)
+      define_method "#{_method}_job" do |_self = nil, *args, **kwargs|
+        
+        Eitil::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
-        Eitil::SingleMethodJob.perform_later(_class: to_s, _method: _method.to_s)
+    elsif singleton_methods(false).include? _method      
+      define_singleton_method "#{_method}_job" do |*args, **kwargs|
+       
+        Eitil::SingleMethodJob.perform_later(
+          *args, _class: to_s, _method: _method.to_s, **kwargs
+        )
       end
-    end  
+    end 
+  end
+
+  # BEWARE: This is an exact copy of the above 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.
+
+  def new_job_debugger(_method, *args, **kwargs)
 
+    if instance_methods(false).include? _method
+      define_method "#{_method}_job_debugger" do |_self = nil, *args, **kwargs|
+        
+        Eitil::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_debugger" do |*args, **kwargs|
+       
+        Eitil::SingleMethodJob.perform_now(
+          *args, _class: to_s, _method: _method.to_s, **kwargs
+        )
+      end
+    end 
   end
 
 end

data/config/initializers/wrappers/jobs/single_method_job.rb

@@ -2,9 +2,23 @@ module Eitil
   class SingleMethodJob < ApplicationJob
     queue_as :default
 
-    def perform(_class:, _method:, id: nil)
-      object = id ? _class.constantize.find(id) : _class.constantize
-      object.send _method
+    # 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 perform(*args, _class:, _method:, id: nil, _self: nil, **kwargs)      
+      object = 
+        if id
+          _class.constantize.find(id)
+        elsif _self
+          _self
+        else
+          _class.constantize
+        end
+
+      object.send _method, *args, **kwargs
     end
   end
 end

data/config/initializers/wrappers/scopes/default_scopes.rb

@@ -2,59 +2,82 @@ module Eitil
   module DefaultScopes
     extend ActiveSupport::Concern
     included do
-      
-      SharableDateScopes = -> (column) {
-        eitil_scope :"#{column}_today",         -> { where("#{column} = ?", Date.today) }
-        eitil_scope :"#{column}_past",          -> { where("#{column} < ?", Date.today) }
-        eitil_scope :"#{column}_future",        -> { where("#{column} > ?", Date.today) }
-        
-        eitil_scope :"#{column}_on_date",       -> (date) { where("#{column} = ?", date) }
-        eitil_scope :"#{column}_before_date",   -> (date) { where("#{column} = ?", date) }
-        eitil_scope :"#{column}_after_date",    -> (date) { where("#{column} = ?", date) }
+      class << self
 
-        eitil_scope :"#{column}_between_dates", -> (from, till) { where("#{column} >= ? and #{column} <= ?", from, till) }
+          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) }
 
-        eitil_scope :"#{column}_oldest_first",  -> { order("#{column} ASC") }
-        eitil_scope :"#{column}_newest_first",  -> { order("#{column} DESC") }
-      }
+            _class.eitil_scope :"#{column}_oldest_first",   -> { order("#{column} ASC") }
+            _class.eitil_scope :"#{column}_newest_first",   -> { order("#{column} DESC") }
+          }
 
-      class << self
+          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) }
+
+            _class.eitil_scope :"#{column}_ascending",      -> { order("#{column} ASC") }
+            _class.eitil_scope :"#{column}_descending",     -> { order("#{column} DESC") }
+          }
+
+          def inherited(subclass)
+            super
+            subclass.use_eitil_scopes
+          end
+
+          def use_eitil_scopes  
+            return if abstract_class?
+            %i[boolean datetime date integer float].each { |_type| send :"create_eitil_#{_type}_scopes" }
+          end
 
-        private
+          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 use_eitil_scopes  
-          %i[boolean datetime date].each { |_type| send :"create_eitil_#{_type}_scopes" }
-        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 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_datetime_scopes
+            columns_of_type(:datetime)&.map do |column, object|
+              SharableDateScopes.call self, column
+            end
+          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]) }
+          def create_eitil_date_scopes
+            columns_of_type(:date)&.map do |column, object|
+              SharableDateScopes.call self, column
+            end
           end
-        end
 
-        def create_eitil_datetime_scopes
-          columns_of_type(:datetime).map do |column, object|
-            SharableDateScopes.call column
+          def create_eitil_integer_scopes
+            columns_of_type(:integer)&.map do |column, object|
+              SharableNumScopes.call self, column
+            end
           end
-        end
 
-        def create_eitil_date_scopes
-          columns_of_type(:date).map do |column, object|
-            SharableDateScopes.call column
+          def create_eitil_float_scopes
+            columns_of_type(:float)&.map do |column, object|
+              SharableNumScopes.call self, column
+            end
           end
-        end
 
       end
-
     end
   end
 end

data/lib/eitil/version.rb

@@ -1,3 +1,3 @@
 module Eitil
-  VERSION = '0.3.1'
+  VERSION = '0.3.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eitil
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.6
 platform: ruby
 authors:
 - Jurriaan Schrofer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-26 00:00:00.000000000 Z
+date: 2021-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,7 +52,9 @@ files:
 - app/jobs/eitil/application_job.rb
 - app/mailers/eitil/application_mailer.rb
 - app/models/eitil/application_record.rb
+- config/initializers/modules/dir.rb
 - config/initializers/monkeys/application_controller.rb
+- config/initializers/monkeys/application_record.rb
 - config/initializers/monkeys/date_time.rb
 - config/initializers/monkeys/hash.rb
 - config/initializers/monkeys/kernel.rb