eitil 1.0.1.e.2 → 1.0.3.e.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 161ea1fef5a7b13407bb26a3d99a8904c703892c1694810736c0730f641e979e
-  data.tar.gz: 4c41d1d6fdd1b3b801159bc636f4c21671f70c4abae545c36ce51c84c830bc14
+  metadata.gz: 1872b8eec9fde6e3cc707f5d66eb6c595000b3d4bb1d57d100b5759b39167cc2
+  data.tar.gz: d4cc20f05567ae72bfd693efe75e559584308a16fdf3322f6de6f2bd13ab448d
 SHA512:
-  metadata.gz: 94ac07f583fab8447efcb1db503d64aa568ce5afd93c33bd41463b41b2e1bc9ce6ed8ce91fb7991e785626f2d2ec92ec168dc7622906bc6d41836a5fd9a5211e
-  data.tar.gz: 8cdca2036c3c4da7bb3a733143faa3e319f1f05aea30bd049413ab7e913929f1dd277575b02e1274dc77dc8318286c98d305873733f714286b2f04aebe0908e4
+  metadata.gz: 747044b67ccab759ecd85c6e58e03607fff0038bfe98aad4f66e6fa8680fd06ac4fbc59922339c4f25ff7e38bdd7dac6feccb00bc0abb806626c1ccdb1a54300
+  data.tar.gz: 165cb9650bbfe9639da5ac493d01ea728001df63515854a5483149a9ff182a0f40796385ec089bf39e72cfb844423d0fa06d94cf1e52e4d0b5addec33f102b64

data/Rakefile

@@ -1,7 +1,6 @@
 require "bundler/setup"
 
 APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load "rails/tasks/engine.rake"
 
 load "rails/tasks/statistics.rake"
 

data/eitil_core/README.md

@@ -0,0 +1,344 @@
+
+
+
+# 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/all_args_to_ivars_bang"
+
+all_args_to_ivars!
+# works the same as .all_args_to_ivars, except that passing the binding is no longer required
+# production usage is discouraged by the creator of the supporting gem
+```
+
+
+```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
+```
+
+
+```ruby
+# require "eitil_core/argument_helpers/all_kwargs_to_ivars_bang"
+
+all_kwargs_to_ivars!(namespace= :kwargs)
+# works the same as .all_kwargs_to_ivars, except that passing the binding is no longer required
+# production usage is discouraged by the creator of the supporting gem
+```
+
+
+```ruby
+# require "eitil_core/argument_helpers/args_to_h"
+
+args_to_h(binding, *local_vars)
+# creates a hash, with a given local_var as keys and its value as value
+# call as: args_to_h(binding, :username, :password)
+# => { username: 'jurriaan', password: 'matz_is_nice' }
+```
+
+
+```ruby
+# require "eitil_core/argument_helpers/args_to_h_bang"
+
+args_to_h!(*local_vars)
+# works the same as .args_to_h, except that passing the binding is no longer required
+# production usage is discouraged by the creator of the supporting gem
+```
+
+
+```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/args_to_ivars_bang"
+
+args_to_ivars!(*local_vars)
+# works the same as .args_to_ivars, except that passing the binding is no longer required
+# production usage is discouraged by the creator of the supporting gem
+```
+
+
+## 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/
+```
+
+
+```ruby
+# require "eitil_core/lookups/gem_path"
+
+Find.gem_path(gem_name)
+# finds the root of an installed gem, allowing you to traverse its paths from there.
+# call as: Find.gem_path("rails")
+# => "/Users/jurriaanschrofer/.rvm/gems/ruby-2.6.5/gems/rails-5.2.3"
+```
+
+
+## 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
+```
+
+

data/eitil_core/lib/eitil_core.rb

@@ -0,0 +1,24 @@
+
+# require "eitil_core"
+
+# core class patches
+require "eitil_core/hash"
+require "eitil_core/float"
+require "eitil_core/datetime"
+
+# multi class patches
+require "eitil_core/type_checkers"
+
+# rails class patches
+require "eitil_core/application_record"
+require "eitil_core/application_controller"
+
+# helper patches
+require "eitil_core/errors"
+require "eitil_core/argument_helpers"
+require "eitil_core/safe_executions"
+require "eitil_core/setters"
+require "eitil_core/validations"
+require "eitil_core/lookups"
+require "eitil_core/concerns"
+

data/eitil_core/lib/eitil_core/application_controller.rb

@@ -0,0 +1,2 @@
+
+require "eitil_core/application_controller/slice_params"

data/eitil_core/lib/eitil_core/application_controller/slice_params.rb

@@ -0,0 +1,14 @@
+
+# require "eitil_core/application_controller/slice_params"
+
+module EitilCore
+  module ApplicationController
+    module SliceParams
+
+      def slice_params(*args)
+        params.slice(*args).as_json.symbolize_keys
+      end
+
+    end
+  end
+end

data/eitil_core/lib/eitil_core/application_record.rb

@@ -0,0 +1,4 @@
+
+require "eitil_core/application_record/where_like"
+require "eitil_core/application_record/find_by_like"
+require "eitil_core/application_record/all_associations"

data/eitil_core/lib/eitil_core/application_record/all_associations.rb

@@ -0,0 +1,16 @@
+
+# require "eitil_core/application_record/all_associations"
+
+module EitilCore
+  module ApplicationRecord
+    module AllAssociations
+
+      def all_associations
+        reflect_on_all_associations.map do |assoc|
+          { assoc.name => assoc.association_class.to_s.demodulize }
+        end.inject &:merge
+      end
+
+    end
+  end
+end

data/eitil_core/lib/eitil_core/application_record/find_by_like.rb

@@ -0,0 +1,15 @@
+
+# require "eitil_core/application_record/find_by_like"
+
+module EitilCore
+  module ApplicationRecord
+    module FindByLike
+
+      def find_by_like(_hash)
+        column, like = _hash.first
+        find_by("LOWER(#{column}) LIKE ?", "%#{like.downcase}%")
+      end
+
+    end
+  end
+end