eitil 0.3.7 → 1.0.1.e.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24a0dccf0357bf5e01f41be73b6b1d4c840cbb8efa233ab772ad1c6c8bd94cff
-  data.tar.gz: 7dc80a7a0268a68302fa74ddc1e0f371a83fba8a77dee2cb38a5ad03c08b3688
+  metadata.gz: 9e69ced77b66d59f27e9099a7797a456cde74b16c6335ef8b5a2ac97c66b5682
+  data.tar.gz: 46b8fe67b5ff1565a08c0e9305890f60af39706da8f7c32a63641ebef6273666
 SHA512:
-  metadata.gz: 6d4a5e8baadfbd18962a5452e42b2051dff922765fbd2a53dcbe15a415a8e805a031efe18defc70d7360f52701d12b2ddcbbc07a96dc8ae2cffd3c33e121a636
-  data.tar.gz: 83a19e9611e3553faf36663b5676c1abb3bc81af22052014cc250f8230665ce36b98a606a4a834923d2c24d81f7c347fa27ab91171a1cd74ca25a871e81d4e7a
+  metadata.gz: 24a0162b9243e07c02fe243a69f13ade1b2e94ecf27b6f23178439ade082078ca7c4fa6e2c651a5452fa56496b25eeed820b689e34cd244c29e78f6d95a1654a
+  data.tar.gz: f5ddd6a9820025ac558361761132d0da305f511d0b8f9edca3c2469aa49a1a98e09f63382a8463f293756556ac6a5fc9084ad6f155712211f348c2d52b0d60ae

data/README.md

@@ -1,365 +1,100 @@
 
 
 
-# Eitil (Eitje Util)
+# Eitil
 
-Never stops increasing your life's efficacy and productivity, yay!
+Eitil (eitje utility) never stops increasing your life's efficacy and productivity, yay!
 
+Our gem currently exists of five seperate layers (Railties), which can be integrated as standalone gems. This design is very much like that of rails, thus affinity with integrating rails should make eitil feel familiar.
 
 
-## Installation
-
-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, for development purposes:
+## Layers
 
-```ruby
-
-gem 'eitil', path: "/Users/jurriaanschrofer/Documents/eitil"
+- EitilCore, [docs](/eitil_core) > extends the core classes of Ruby and rails.
+- EitilSupport, [docs](/eitil_support) > provides utility through stand-alone classes and modules.
+- EitilWrapper, [docs](/eitil_wrapper) > wraps core rails operations with extended utilities – such as routing, jobs and decoraters.
+- EitilStore, [docs](/eitil_store) > stores data in containers, such as Regexp instances.
+- EitilIntegrate, [docs](/eitil_integrate) > provides seamless integrations with select gems and API's, through helper methods stored in PORO's. 
 
-```
 
 
+## Cherry picking utilities
 
-# Monkey patches
+Eitil has an extremely modular setup, which gives you fine-grained control over which monkey patches and rails wrappers you want to include into your project. Going from fine to coarse, there are 4 levels on which you can integrate eitil within your project:
 
 
+### 1. include a single method
 
-## Kernel
+Almost each eitil method has it's own file, which you can easily require by it's path. To make things easy, both the docs and source code of the given method specify which path you should require.
 
 ```ruby
-all_args_to_ivars(binding)
-# sets all keywords arguments of the method's local binding to instance variables
-# call as: all_args_to_ivars binding
-
-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(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
-
-safe_call(*args, return_value: nil, &block)
-# a safe version of .call, which in case of an error rescues and returns return_value (default: nil) instead
-# accepts either a proc argument or a block
-
-raise_error(_class_name, message = nil)
-# creates an error class if currently undefined, inheriting from StandardError, and raises the error with the given message
-# call as: raise_error "SomethingWentWrongError", "check your code, bro!"
-# => SomethingWentWrongError (check your code, bro!)
-```
 
+require "eitil_core/hash/auto_dig"
 
+# This will simply add the patched Hash#auto_dig into your main application.
 
-## Object
-
-```ruby
-all_methods(include_ancestors = true, grep: nil)
-# pretty prints all methods for any object, grouped per type (e.g. private_methods, public_instance_methods)
-# call as: Class.all_methods false, grep: /json/
 ```
 
 
+### 2. include a collection of methods
 
-## Module
+All single method files are combined into collections, which you can efficiently include at once. For example, the previous auto_dig method can also be included by:
 
 ```ruby
-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 
-```
 
+require "eitil_core/hash"
 
+# This will add all Hash patches into your project.
 
-## Hash
-
-```ruby
-auto_dig(_hash = self, _key)
-# finds the value for the given hash key, irregardless of the amount of nested layers 
-# call as: {a: 1, b: {c: 2, d: {e: 3}}}.auto_dig :e
-# => 3
 ```
 
 
+### 3. include a whole layer
 
-## ApplicationController
-
-```ruby
-slice_params(*args)
-# slices request params, converts them to JSON and symbolizes the keys
-# call as: slice_params :id, :user
-# => { id: 1, user: 69 }
-```
-
-
+A whole layer, for example all utilities provided by EitilCore, can be included at once in your application.rb file:
 
-## ApplicationRecord
 
 ```ruby
-self.all_associations
-# returns all associations for a given model
-# call as: Environment.all_associations
 
-self.where_like(_hash)
-# runs .where with your string field made into a wildcard and case insensitive
-# call as: User.where_like(name: 'jurriaan')
+# config/application.rb
 
-self.find_by_like(_hash)
-# runs .find_by with your string field made into a wildcard and case insensitive
-# call as: User.find_by_like(name: 'jurriaan')
-```
-
-
-
-## DateTime
-
-```ruby
-prettify
-# formats DateTime instances into a pretty, simple and filename friendly format
-# call as: DateTime.now.prettify 
-# => "2021-04-21.17:51:42"
-```
-
-
-
-# Wrappers
-
-
-
-## Decorators
-
-### Info
-
-The Eitil decorator wrappers help you to standardize the calling of the right decorator method from within your controller action. Basically it provides you with a decorate macro in each controller.
-
-### Decorate Macro
-
-```ruby
-decorate(dec_item, dec_method: nil, dec_class: nil, **dec_kwargs)
-```
-
-- dec_item is the instance that will be decorated
-- dec_method enabled you to set the desired decorator method. If not provided, it will look into the request params: if params["isMobile"] is present it will call .app, if params["isWeb"] is present it will call :app. If neither is provided in the params, it will call the default method :base.
-- dec_class enables you to overwrite the decorator class that will be called. If not provided, the decorator class will be inferred from the instance model's classname (User => UserDecorator).
-- dec_kwargs enables you to provide additional arguments, which will be passed to your decorator method.
-
-### Configuration
-
-1. Your decorator classes should inherit from Eitil::ApplicationDecorator.
-2. Your controllers should inherit the module Eitil::ControllerDecorator, through inclusion in a superclass.
-3. If you set controller ivars for each request, you can make them available in your decorators by providing Eitil a method which returns the names of your ivars as an array of symbols:
-
-```ruby
-# initializers/eitil.rb
-
-Eitil.set_config do |config|
-  config.get_controller_ivars_method = 'API::BaseController.controller_ivars' # => [:user, :env]
+module MyApplication
+  class Application < Rails::Application   
+    require 'eitil/eitil_core'
+  end
 end
+    
 ```
 
 
 
-## Router
-
-### Info
-
-The Eitil router wrapper enables you to easily create new routes that can be shared among controllers. In that sense, it is as a custom extension of the built-in resourceful routes.
+### 4. include all alyers
 
-### Create New Route Macro
+Just like you can include a single eitil layer, you can also include them all at once:
 
-The first macro, new_route, enables you to create new route objects which may be called and used by different controllers.
 
 ```ruby
-# config/routes.rb
 
-new_route(verb, _method, action, scope)
-# call as: new_route :post, :attachment, "add_attachment", :member
-```
-
-- verb refers to the http_verb, e.g. :put.
-- method refers to the given http method (e.g. 'users/:id'). Additionally, this is the name you will refer to in order to include the route into a controller. Therefore the argument should be unique among all other routes.
-- action refers to the controller action to which you want to redirect to request, e.g. :update_user.
-- scope refers to the url and can be set to either :member or :collection.
-
-### Add Routes Macro
-
-The second macro, extended_resources, enables you to create all standard resources for a controller and add your own standardized routes. This macro works the same as the built-in :resources, except that you can pass more arguments to only: [], which adds the routes to your controller.
-
-```ruby
-# config/routes.rb
-
-extended_resources(controller, **kwargs)
-# call as: extended_resources :posts, only: [:create, :update, :attachment]
-
-```
-
-### Configuration
-
-The router wrapper is a single module which is automatically included into your application's router file, therefore no configuration is required.
-
-
-
-## Jobs
-
-### Info
-
-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, *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 
-
-### Configuration
-
-The new_job macro is monkey patched into Kernel, therefore no configuration is required.
-
-
-
-## Scopes
+# config/application.rb
 
-### Info
-
-The Eitil scopes wrapper creates various default scopes for a model.
-
-### The Scopes
-
-Scopes are generated through the columns of your model's database table. Which scopes are generated depends on the datatype of a column. For example, if your User model with table users has a column is_manager, a scope :is_manager_true is generated for your User model. A scope method is defined only if it does not already responds to another method of the same name. The scopes generated are:
-
-```ruby
-# columns of datatype: boolean
-.{column_name}_true
-.{column_name}_false
-
-# columns of datatype: datetime
-.{column_name}_today      
-.{column_name}_past       
-.{column_name}_future             
-.{column_name}_on_date(date)    
-.{column_name}_before_date(date)
-.{column_name}_after_date(date) 
-.{column_name}_between_dates(start_date, end_date)
-.{column_name}_oldest_first
-.{column_name}_newest_first
-
-# columns of datatype: date
-.{column_name}_today      
-.{column_name}_past       
-.{column_name}_future             
-.{column_name}_on_date(date)    
-.{column_name}_before_date(date)
-.{column_name}_after_date(date) 
-.{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
+module MyApplication
+  class Application < Rails::Application   
+    require 'eitil/all'
+  end
+end
+    
 ```
 
-### Configuration
-
-Your models should inherit the module Eitil::DefaultScopes through inclusion in a superclass, such as ApplicationRecord.
 
 
 
-# Modules & Classes
-
-
-
-## Eitil::Dir
-
-### Info
-
-The Eitil::Dir module provides methods which help you introspect your Rails project.
+## Installation
 
-### Methods
+Add eitil to your gemfile:
 
 ```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
+gem 'eitil', '1.0.0' # check the latest version on https://rubygems.org/gems/eitil
 
-Eitil::Dir.lines(directory='app')
-# returns the total amount of lines of all files of a given directory
 ```
 
-
-
-## Eitil::StackTrace
-
-### Info
-
-The two classes Eitil::StackTrace::Stack and Eitil::StackTrace::Call, and the single module Eitil::StackTrace::Audit, provide the utility of easily viewing and storing the current stacktrace anywhere in your code. By initializing stack = Eitil::StackTrace::Stack.new, you can call methods as stack.report (returns the stacktrace as array), stack.show (pretty prints the stacktrace) and stack.find (accepts a block to find a call).
-
-You can also store the stacktrace of a record's update action into its audit. In order to do so, you need 1) to include Eitil::StackTrace::Audit into your model, and 2) add a :stacktrace column to your audits through the following migration.
-
-### Migration
-
-```ruby
-def change
-	add_column :audits, :stacktrace, :text, array: true, default: [] 
-end
-```
-
-
-

data/lib/eitil.rb

@@ -1,6 +1,6 @@
 require "eitil/version"
 require "eitil/engine"
+require "eitil/railtie"
 
 module Eitil
-  # Your code goes here...
 end

data/lib/eitil/all.rb

@@ -0,0 +1,18 @@
+
+require "rails"
+require "eitil"
+
+Eitil::Layers.each do |layer|
+  
+  begin
+    require "#{layer}/railtie"
+    puts "succesfully required #{layer}/railtie"
+
+  rescue LoadError => e    
+    puts "failed to require #{layer}/railtie"
+    puts "message: #{e.message}"
+    puts "backtrace: #{e.backtrace}"
+    binding.pry
+    
+  end
+end

data/lib/eitil/engine.rb

@@ -1,8 +1,32 @@
+
+require 'eitil/railtie'
+
+
+# Constants
+
 module Eitil
   
+  # preferably find a less hacky way to retrieve the gem's root path, perhaps with Kernel#pwd?
+  Root   = $LOAD_PATH.find { |x| x.match /eitil/ }.chomp('/lib')
+  Layers = %w( eitil_core eitil_support eitil_wrapper eitil_store eitil_integrate )
+
+end
+
+
+# Configuration
+
+module Eitil
+
   class Engine < ::Rails::Engine   
+    
     isolate_namespace Eitil
     config.generators.api_only = true
+   
+    # Add lib dirs to $LOAD_PATH, making them available in your main app.
+    Eitil::Layers.each do |layer|
+      $LOAD_PATH << "#{Eitil::Root}/#{layer}/lib"
+    end
+
   end
 
   mattr_accessor :get_controller_ivars_method

data/lib/eitil/railtie.rb

@@ -0,0 +1,6 @@
+module Eitil
+  
+  class Railtie < ::Rails::Railtie
+  end
+
+end

data/lib/eitil/version.rb

@@ -1,3 +1,5 @@
 module Eitil
-  VERSION = '0.3.7'
+  
+  VERSION = '1.0.1.e.1'
+  
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eitil
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 1.0.1.e.1
 platform: ruby
 authors:
 - Jurriaan Schrofer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-07 00:00:00.000000000 Z
+date: 2021-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,7 +38,11 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.9.2
-description: Description of Eitil.
+description: "Eitil (eitje utility) never stops increasing your life's efficacy and
+  productivity, yay!\n                      Our gem currently exists of five seperate
+  layers (Railties), which can be integrated as standalone gems. \n                      This
+  design is very much like that of rails, thus affinity with integrating rails should
+  make eitil feel familiar."
 email:
 - jschrofer@gmail.com
 executables: []
@@ -48,39 +52,19 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/controllers/eitil/application_controller.rb
-- app/jobs/eitil/application_job.rb
-- app/mailers/eitil/application_mailer.rb
-- app/models/eitil/application_record.rb
-- app/models/eitil/stack_trace/audit.rb
-- app/models/eitil/stack_trace/call.rb
-- app/models/eitil/stack_trace/stack.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
-- config/initializers/monkeys/module.rb
-- config/initializers/monkeys/object.rb
-- config/initializers/wrappers/decorators/application_decorator.rb
-- config/initializers/wrappers/decorators/controller_decorator.rb
-- config/initializers/wrappers/jobs/active_job_macros.rb
-- config/initializers/wrappers/jobs/single_method_job.rb
-- config/initializers/wrappers/routes/extended_resources.rb
-- config/initializers/wrappers/scopes/default_scopes.rb
-- config/routes.rb
 - lib/eitil.rb
+- lib/eitil/all.rb
 - lib/eitil/engine.rb
+- lib/eitil/railtie.rb
 - lib/eitil/version.rb
 - lib/tasks/eitil_tasks.rake
-homepage: https://eitje.app
+homepage: https://github.com/eitje-app/eitil_engine
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://eitje.app
-  source_code_uri: https://eitje.app
-  changelog_uri: https://eitje.app
+  homepage_uri: https://github.com/eitje-app/eitil_engine
+  source_code_uri: https://github.com/eitje-app/eitil_engine
+  changelog_uri: https://github.com/eitje-app/eitil_engine
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -92,12 +76,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
-summary: Summary of Eitil.
+summary: Eitil (eitje utility) never stops increasing your life's efficacy and productivity,
+  yay!
 test_files: []

data/app/controllers/eitil/application_controller.rb

@@ -1,4 +0,0 @@
-module Eitil
-  class ApplicationController < ActionController::API
-  end
-end

data/app/jobs/eitil/application_job.rb

@@ -1,4 +0,0 @@
-module Eitil
-  class ApplicationJob < ActiveJob::Base
-  end
-end

data/app/mailers/eitil/application_mailer.rb

@@ -1,6 +0,0 @@
-module Eitil
-  class ApplicationMailer < ActionMailer::Base
-    default from: 'from@example.com'
-    layout 'mailer'
-  end
-end

data/app/models/eitil/application_record.rb

@@ -1,5 +0,0 @@
-module Eitil
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-  end
-end

data/app/models/eitil/stack_trace/audit.rb

@@ -1,15 +0,0 @@
-module Eitil::StackTrace::Audit
-  extend ActiveSupport::Concern
-  included do
-
-    private
-    
-    after_update :add_stacktrace_to_audit
-
-    def add_stacktrace_to_audit
-      stacktrace = Eitil::StackTrace::Stack.new.report
-      self.audits.last.update(stacktrace: stacktrace)
-    end
-
-  end
-end

data/app/models/eitil/stack_trace/call.rb

@@ -1,17 +0,0 @@
-module Eitil::StackTrace
-  class Call
-
-    attr_reader :program, :line, :meth
-
-    CALL_RE = /(.*):(\d+):in `(.*)'/
-
-    def initialize(string)
-      @program, @line, @meth = CALL_RE.match(string).captures
-    end
-
-    def to_s
-      "#{"#{meth}".ljust(50)} #{"(#{line})".ljust(6)} #{program}"
-    end
-
-  end
-end

data/app/models/eitil/stack_trace/stack.rb

@@ -1,28 +0,0 @@
-module Eitil::StackTrace
-  class Stack
-
-  attr_reader :stack, :backtrace
-
-  def initialize
-    @stack     = caller[1..]
-    @backtrace = stack.map { |call| Eitil::StackTrace::Call.new(call) }
-  end
-
-  def report
-    backtrace.map(&:to_s)
-  end
-
-  def show
-    ap report
-  end
-
-  def find(&block)
-    backtrace.find(&block)
-  end
-
-  def self.parse(array_as_string)
-    array_as_string.sub('[', ' ').reverse.sub(']','').reverse.split(',').flatten
-  end
-
-  end
-end

data/config/initializers/modules/dir.rb

@@ -1,21 +0,0 @@
-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,14 +0,0 @@
-module ApplicationControllerMonkey
-  extend ActiveSupport::Concern 
-  included do
-
-    private
-
-    def slice_params(*args)
-      params.slice(*args).as_json.symbolize_keys
-    end
-
-  end
-end
-
-ApplicationController.send :include, ApplicationControllerMonkey

data/config/initializers/monkeys/application_record.rb

@@ -1,30 +0,0 @@
-require "#{Eitil::Engine.root.to_s}/config/initializers/wrappers/scopes/default_scopes.rb"
-
-module ApplicationRecordMonkey
-  extend ActiveSupport::Concern 
-  included do
-
-    class << self
-
-      def all_associations
-        reflect_on_all_associations.map do |assoc|
-          { assoc.name => assoc.association_class.to_s.demodulize }
-        end.inject &:merge
-      end
-
-      def where_like(_hash)
-        column, like = _hash.first
-        where("LOWER(#{column}) LIKE ?", "%#{like.downcase}%")
-      end
-
-      def find_by_like(_hash)
-        column, like = _hash.first
-        find_by("LOWER(#{column}) LIKE ?", "%#{like.downcase}%")
-      end
-
-    end
-
-  end
-end
-
-ApplicationRecord.send :include, ApplicationRecordMonkey

data/config/initializers/monkeys/date_time.rb

@@ -1,7 +0,0 @@
-class DateTime
-
-  def prettify
-    strftime "%Y-%m-%d.%H:%M:%S"
-  end
-
-end

data/config/initializers/monkeys/hash.rb

@@ -1,14 +0,0 @@
-class Hash
-
-    def auto_dig(_hash = self, _key)
-    return _hash[_key] if _hash.fetch(_key, false)
-
-    _hash.keys.each do |k|
-      answer = auto_dig(_hash[k], _key) if _hash[k].is_a? Hash
-      return answer if answer
-    end
-
-    nil
-  end
-
-end

data/config/initializers/monkeys/kernel.rb

@@ -1,48 +0,0 @@
-Kernel.module_eval do
-
-  def all_args_to_ivars(local_binding)
-    local_binding.local_variables.each do |lvar|
-      instance_variable_set("@#{lvar}", local_binding.local_variable_get(lvar))
-    end
-  end
-
-  def args_to_ivars(local_binding, *local_vars)
-    local_vars.each do |lvar|
-      instance_variable_set("@#{lvar}", local_binding.local_variable_get(lvar))
-    end
-  end
-
-  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
-
-  def set_ivars(*ivars)
-    ivars.each do |ivar|
-      instance_variable_set("@#{ivar}", send("set_#{ivar}"))
-    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
-      return_value
-  end
-
-  def safe_send(method, *args, return_value: nil)
-    self.send method, *args
-    rescue
-      return_value
-  end
-
-  def raise_error(_class_name, message = nil)   
-    Object.const_set(_class_name, Class.new(StandardError)) unless Object.const_defined?(_class_name)
-    raise _class_name.constantize.new message
-  end
-
-end

data/config/initializers/monkeys/module.rb

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

data/config/initializers/monkeys/object.rb

@@ -1,29 +0,0 @@
-require "awesome_print"
-
-class Object
-
-  def all_methods(include_ancestors = true, grep: nil)
-
-    _introspection_methods = %i$
-      methods
-      singleton_methods
-      instance_methods
-      private_methods
-      public_methods
-      protected_methods
-      private_instance_methods
-      public_instance_methods
-      protected_instance_methods
-    $
-
-    _introspection_methods.map! do |_m|
-      _methods = safe_send _m, include_ancestors
-      _methods = grep ? _methods&.grep(grep) : _methods
-      { _m => _methods }
-    end
-
-    ap _introspection_methods.inject &:merge
-    
-  end
-
-end

data/config/initializers/wrappers/decorators/application_decorator.rb

@@ -1,19 +0,0 @@
-module Eitil
-  class ApplicationDecorator
-
-    include ActiveModel::Model
-
-    def initialize(attributes={}, **kwargs)      
-      super attributes
-      all_kwargs_to_ivars binding
-    end
-
-    def self.method_missing(method_name, *args, **kwargs)
-      if %i$ web app $.include?(method_name.to_sym)
-        kwargs.any? ? send(:base, *args, **kwargs) : send(:base, *args)
-      end
-      super
-    end
-
-  end
-end

data/config/initializers/wrappers/decorators/controller_decorator.rb

@@ -1,63 +0,0 @@
-module Eitil
-  module ControllerDecorator
-    extend ActiveSupport::Concern 
-    included do
-
-      private
-
-      def decorate(dec_item, dec_method: nil, dec_class: nil, **dec_kwargs)
-        all_args_to_ivars binding
-        set_ivars :dec_class, :dec_method, :decorator
-        send_to_decorator
-      end
-
-      def send_to_decorator
-        @dec_kwargs.any? ? @decorator.send(@dec_method, @dec_item, @dec_kwargs)
-                         : @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 params["isMobile"]
-        return :web if 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
-        @decorator = @dec_class.new controller_ivars
-      end
-
-      def controller_ivars
-        eval(Eitil.get_controller_ivars_method).map do |ivar|
-          { ivar => instance_variable_get("@#{ivar.to_s}") }
-        end.inject &:merge
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-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|
-        
-        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 |*args, **kwargs|
-       
-        Eitil::SingleMethodJob.perform_later(
-          *args, _class: to_s, _method: _method.to_s, **kwargs
-        )
-      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

@@ -1,24 +0,0 @@
-module Eitil
-  class SingleMethodJob < ApplicationJob
-    queue_as :default
-
-    # 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/routes/extended_resources.rb

@@ -1,40 +0,0 @@
-module Eitil
-  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, Eitil::ExtendedResources

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

@@ -1,83 +0,0 @@
-module Eitil
-  module DefaultScopes
-    extend ActiveSupport::Concern
-    included do
-      class << 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) }
-
-            _class.eitil_scope :"#{column}_oldest_first",   -> { order("#{column} ASC") }
-            _class.eitil_scope :"#{column}_newest_first",   -> { order("#{column} DESC") }
-          }
-
-          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
-
-          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
-end

data/config/routes.rb

@@ -1,2 +0,0 @@
-Eitil::Engine.routes.draw do
-end