eitil 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f822863c972553dc89dca4e80fce4b197c89c27f78456342195f46b920fa07f5
+  data.tar.gz: 0e852adfd5a9127d3d67f349102bb6000121b730a5a42d0628b09beab45723fe
+SHA512:
+  metadata.gz: cc64496f6e70c4d737ddf6bf091988ab01425802852034dd1d0c083bee1cda38ee25381927b498fc74c0094f27c071b71e10b360fc00ac477e81635b509d1915
+  data.tar.gz: ac2c18d0bd040e892caf008de55550cd09322fb69b09d15efd6adf6d147ce399b8e5aff547603af1311c7ebb86f0a8051da40211791d70042ee4e87a57ef23b3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Jurriaan Schrofer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,272 @@
+
+
+
+# Eitil (Eitje Util)
+
+Never stops increasing your life's efficacy and productivity, yay!
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```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:
+
+```ruby
+
+gem 'eitil', path: "/Users/jurriaanschrofer/Documents/eitil"
+
+```
+
+
+
+# Monkey patches
+
+
+
+## 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(binding)
+# 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
+
+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
+
+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!)
+```
+
+
+
+## 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/
+```
+
+
+
+## Module
+
+```ruby
+include_concerns_of(*directories)
+# includes all models/concerns/{sub_directory}/* within a module or class
+# call as: include_concerns_of :user, :mail 
+# => includes all modules of models/concerns/user/* and models/oncerns/mail/*
+```
+
+
+
+## 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
+```
+
+
+
+## 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 }
+```
+
+
+
+## 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::VerlofVerzoekenController.controller_ivars' # => [:user, :env]
+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.
+
+
+
+## Jobs
+
+### 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.
+
+### Job Macro
+
+```ruby
+new_job(_method)
+# assuming a method :print_hello_world, call as: new_job :hello_world
+# => method :hello_world_job
+```
+
+- method is 
+
+### Configuration
+
+The new_job macro is monkey patched into Kernel, therefore no configuration is required.
+
+
+
+## Scopes
+
+### 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 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
+```
+
+### Configuration
+
+Your models should inherit the module Eitil::DefaultScopes through inclusion in a superclass, such as ApplicationRecord.
+
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/eitil/application_controller.rb

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

data/app/jobs/eitil/application_job.rb

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

data/app/mailers/eitil/application_mailer.rb

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

data/app/models/eitil/application_record.rb

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

data/config/initializers/monkeys/application_controller.rb

@@ -0,0 +1,14 @@
+module ApplicationMonkey
+  extend ActiveSupport::Concern 
+  included do
+
+    private
+
+    def slice_params(*args)
+      params.slice(*args).as_json.symbolize_keys
+    end
+
+  end
+end
+
+ApplicationController.send :include, ApplicationMonkey

data/config/initializers/monkeys/date_time.rb

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

data/config/initializers/monkeys/hash.rb

@@ -0,0 +1,14 @@
+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
+
+    false
+  end
+
+end

data/config/initializers/monkeys/kernel.rb

@@ -0,0 +1,44 @@
+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)
+    local_binding.local_variable_get(:kwargs).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 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

@@ -0,0 +1,12 @@
+class Module
+
+  def include_concerns_of(*directories)
+    directories.map! { |dir| 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,18 @@
+Kernel.module_eval do
+
+  def new_job(_method)
+
+    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)
+      end
+
+    elsif singleton_methods(false).include? _method
+      define_singleton_method "#{_method}_job" do
+        Eitil::SingleMethodJob.perform_later(_class: to_s, _method: _method.to_s)
+      end
+    end  
+
+  end
+
+end

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

@@ -0,0 +1,10 @@
+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
+    end
+  end
+end

data/config/initializers/wrappers/routes/extended_resources.rb

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,60 @@
+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) }
+
+        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 << self
+
+        private
+
+        def use_eitil_scopes  
+          %i[boolean datetime date].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 column
+          end
+        end
+
+        def create_eitil_date_scopes
+          columns_of_type(:date).map do |column, object|
+            SharableDateScopes.call column
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/config/routes.rb

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

data/lib/eitil.rb

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

data/lib/eitil/engine.rb

@@ -0,0 +1,14 @@
+module Eitil
+  
+  class Engine < ::Rails::Engine   
+    isolate_namespace Eitil
+    config.generators.api_only = true
+  end
+
+  mattr_accessor :get_controller_ivars_method
+
+  def self.set_config(&block)
+    yield self
+  end
+
+end

data/lib/eitil/version.rb

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

data/lib/tasks/eitil_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :eitil do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: eitil
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Jurriaan Schrofer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+description: Description of Eitil.
+email:
+- jschrofer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+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
+- config/initializers/monkeys/application_controller.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/engine.rb
+- lib/eitil/version.rb
+- lib/tasks/eitil_tasks.rake
+homepage: https://eitje.app
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://eitje.app
+  source_code_uri: https://eitje.app
+  changelog_uri: https://eitje.app
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Summary of Eitil.
+test_files: []