RubyGems - eitil - Versions diffs - 0.3.10 → 1.0.1.e.4 - Mend

eitil 0.3.10 → 1.0.1.e.4

Files changed (86) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a5f03357f8feee5c40fa17fdf11acc544229eb85e822578929d18bab25f5ec4
-  data.tar.gz: 32ecc96ed0088b7a447fac59505d76e1f5c0e4131b38a615b2ccdf6bdbdf4b13
+  metadata.gz: 5232de873f2bceae1b35b083d012bfce49232bc8ca31f44dd8ca59813817dfb9
+  data.tar.gz: 1db3364578e717a1cf277f5716d22b9d2e4d13a993bd814861cc4a2ad6a3adc5
 SHA512:
-  metadata.gz: 706798e2c7e5e1f81cd413a5698fa030eedcc606dae5a2a6ade7fd74bc21cfa1e485cc3a7c782097aa7cac2271d879f91e8d0791627540df9acd03e8bc873273
-  data.tar.gz: c33996734e261cc3419ad9dfcec4dd271ecb40be39cc0dac2ae44156f750329a179a3988ba0a4d574a27fa8d411b1542f230c566544d9bb67ef4f6c60d93dc1a
+  metadata.gz: b3cae8cfdd62e6dfa886bc74dd3df3c360eaed551a372969caa5fb0667e56b80ba00a41c8916fe4ab3edbc1467a83a00157f0bf02490e93f00b0f8a81dd5d420
+  data.tar.gz: fbff1d6ed87e89fcb9082e8b04d5cc980d7e152817f3fb590f710abb536b5ad7125f08809df106debfe964f15ea89a515669705fe37327450a9c8493300c435f

data/README.md CHANGED Viewed

@@ -1,392 +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:
+## Layers
-```ruby
+- 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.
-gem 'eitil' # check the latest version on https://rubygems.org/gems/eitil
-```
-Or, if you want a specific branch (requires auth for private branch):
+## Cherry picking utilities
-```ruby
+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:
-gem 'eitil', git: 'https://github.com/eitje-app/eitil_engine', branch: 'production'
-```
+### 1. include a single method
-Or, for development purposes:
+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
-gem 'eitil', path: "/Users/jurriaanschrofer/Documents/eitil"
-```
-# Monkey patches
+require "eitil_core/hash/auto_dig"
+# This will simply add the patched Hash#auto_dig into your main application.
-## Kernel
-```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!)
 ```
+### 2. include a collection of methods
-## Object
+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
-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/
-```
+require "eitil_core/hash"
-## Module
+# This will add all Hash patches into your project.
-```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
 ```
+### 3. include a whole layer
-## String
-```ruby
-is_num?
-# returns true if a string matches the Rubinius source code regex for strings and integers, false otherwise
-# comes in handy since ruby plays it safe on string to number conversion ('aaa'.to_f returns 0.0, thus is valid)
-# this method is also implemented for all other classes, such as Integer, Float, NilClass, TrueClass, Hash and so on...
-is_nan?
-# returns true if a string does NOT match the Rubinius source code regex for strings and integers, false otherwise
-# comes in handy since ruby plays it safe on string to number conversion ('aaa'.to_f returns 0.0, thus is valid)
-# this method is also implemented for all other classes, such as Integer, Float, NilClass, TrueClass, Hash and so on...
-```
+A whole layer, for example all utilities provided by EitilCore, can be included at once in your application.rb file:
-## 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
-```
-## Float
-```ruby
-safe_to_i
-# converts a float to an integer, only when no decimal values are lost.
-# 8.00.safe_to_i returns 8    (Integer)
-# 8.88.safe_to_i returns 8.88 (Float)
-```
-## 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 }
-```
-## 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')
-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.
+# config/application.rb
-### 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.
-### Create New Route Macro
-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.
+### 4. include all alyers
+Just like you can include a single eitil layer, you can also include them all at once:
-## 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.
+# config/application.rb
-## Scopes
-### 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/eitil_core/README.md ADDED Viewed

@@ -0,0 +1,288 @@
+# EitilCore
+EitilCore extends the core classes of Ruby and Rails.
+## ApplicationController
+```ruby
+require "eitil_core/application_controller"
+```
+```ruby
+# require "eitil_core/application_controller/slice_params"
+slice_params(*args)
+# slices request params, converts them to JSON and symbolizes the keys
+# call as: slice_params :id, :user
+# => { id: 1, user: 69 }
+```
+## ApplicationRecord
+```ruby
+require "eitil_core/application_controller"
+```
+```ruby
+# require "eitil_core/application_record/find_by_like"
+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')
+```
+```ruby
+# require "eitil_core/application_record/where_like"
+self.where_like(_hash)
+# runs .where with your string field made into a wildcard and case insensitive
+# call as: User.where_like(name: 'jurriaan')
+```
+```ruby
+# require "eitil_core/application_record/all_associations"
+self.all_associations
+# returns all associations for a given model
+# call as: Environment.all_associations
+```
+## ArgumentHelpers
+```ruby
+require "eitil_core/arugment_helpers"
+```
+```ruby
+# require "eitil_core/argument_helpers/all_args_to_ivars"
+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
+```
+```ruby
+# require "eitil_core/argument_helpers/args_to_ivars"
+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
+```
+```ruby
+# require "eitil_core/argument_helpers/all_kwargs_to_ivars"
+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
+```
+## Concerns
+```ruby
+require "eitil_core/concerns"
+```
+```ruby
+# require "eitil_core/concerns/include_concerns_of"
+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
+```
+## DateTime
+```ruby
+require "eitil_core/datetime"
+```
+```ruby
+# require "eitil_core/datetime/prettify"
+prettify
+# formats DateTime instances into a pretty, simple and filename friendly format
+# call as: DateTime.now.prettify
+# => "2021-04-21.17:51:42"
+```
+## Errors
+```ruby
+require "eitil_core/errors"
+```
+```ruby
+# require "eitil_core/errors/raise_error"
+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!)
+```
+## Float
+```ruby
+require "eitil_core/float"
+```
+```ruby
+# require "eitil_core/float/safe_to_i"
+safe_to_i
+# converts a float to an integer, only when no decimal values are lost.
+# 8.00.safe_to_i returns 8    (Integer)
+# 8.88.safe_to_i returns 8.88 (Float)
+```
+## Hash
+```ruby
+require "eitil_core/hash"
+```
+```ruby
+# require "eitil_core/hash/auto_dig"
+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
+```
+## Lookups
+```ruby
+require "eitil_core/lookups"
+```
+```ruby
+# require "eitil_core/lookups/all_methods"
+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/
+```
+## SafeExecutions
+```ruby
+require "eitil_core/safe_executions"
+```
+```ruby
+# require "eitil_core/safe_executions/safe_send"
+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
+```
+```ruby
+# require "eitil_core/safe_executions/safe_call"
+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
+```
+## Setters
+```ruby
+require "eitil_core/setters"
+```
+```ruby
+# require "eitil_core/setters/set_ivars"
+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
+```
+## TypeCheckers
+```ruby
+require "eitil_core/type_checkers"
+```
+```ruby
+# require "eitil_core/type_checkers/is_num_or_nan"
+is_num?
+# returns true if a string matches the Rubinius source code regex for strings and integers, false otherwise
+# comes in handy since ruby plays it safe on string to number conversion ('aaa'.to_f returns 0.0, thus is valid)
+# this method is also implemented for all other classes, such as Integer, Float, NilClass, TrueClass, Hash and so on...
+is_nan?
+# returns true if a string does NOT match the Rubinius source code regex for strings and integers, false otherwise
+# comes in handy since ruby plays it safe on string to number conversion ('aaa'.to_f returns 0.0, thus is valid)
+# this method is also implemented for all other classes, such as Integer, Float, NilClass, TrueClass, Hash and so on...
+```
+## Validations
+```ruby
+require "eitil_core/validations"
+```
+```ruby
+# require "eitil_core/validations/run_validations"
+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
+```