eitil 0.3.10 → 1.0.1.e.4

data/eitil_support/README.md

@@ -0,0 +1,78 @@
+
+
+
+# EitilSupport
+
+EitilSupport provides utility through stand-alone classes and modules.
+
+
+
+## EitilSupport::Directory
+
+```ruby
+
+require "eitil_support/directory"
+
+```
+
+The EitilSupport::Directory module provides methods which help you introspect your Rails project.
+
+```ruby
+EitilSupport::Directory.contents(directory='app')
+# returns all files and subdirectories of a given directory
+```
+
+```ruby
+EitilSupport::Directory.files(directory='app')
+# returns all files of a given directory
+```
+
+```ruby
+EitilSupport::Directory.subdirs(directory='app')
+# returns all subdirectories of a given directory
+```
+
+```ruby
+EitilSupport::Directory.lines(directory='app')
+# returns the total amount of lines of all files of a given directory
+```
+
+
+## EitilSupport::StackTrace
+
+```ruby
+
+require "eitil_support/stacktrace"
+
+```
+
+The classes EitilSupport::Stack and EitilSupport::Call, and the module EitilSupport::Stack::Audit, provide the utility of easily viewing and storing the current stacktrace anywhere in your code – by initializing EitilSupport::Stack:
+
+```ruby
+stack = EitilSupport::Stack.new
+```
+
+```ruby
+stack.report
+# returns the stacktrace as array, with each call being a stringified instance of EitilSupport::Call
+```
+
+```ruby
+stack.show
+# pretty prints the stack.report stacktrace
+```
+
+```ruby
+stack.find
+# accepts a block to find a specific 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 EitilSupport::Stack::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_support/lib/eitil_support.rb

@@ -0,0 +1,5 @@
+
+# require "eitil_support"
+
+require "eitil_support/directory"
+require "eitil_support/stacktrace"

data/eitil_support/lib/eitil_support/directory.rb

@@ -0,0 +1,2 @@
+
+require "eitil_support/directory/lookups"

data/eitil_support/lib/eitil_support/directory/lookups.rb

@@ -0,0 +1,23 @@
+module EitilSupport
+  module Directory
+    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
+end

data/eitil_support/lib/eitil_support/railtie.rb

@@ -0,0 +1,10 @@
+
+require "rails"
+require "eitil_support"
+
+module EitilSupport
+
+  class Railtie < Rails::Railtie
+  end
+
+end

data/eitil_support/lib/eitil_support/stacktrace.rb

@@ -0,0 +1,4 @@
+
+require "eitil_support/stacktrace/call"
+require "eitil_support/stacktrace/stack"
+require "eitil_support/stacktrace/audit"

data/{app/models/eitil/stack_trace → eitil_support/lib/eitil_support/stacktrace}/audit.rb

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

data/{app/models/eitil/stack_trace → eitil_support/lib/eitil_support/stacktrace}/call.rb

@@ -1,4 +1,4 @@
-module Eitil::StackTrace
+module EitilSupport
   class Call
 
     attr_reader :program, :line, :meth

data/{app/models/eitil/stack_trace → eitil_support/lib/eitil_support/stacktrace}/stack.rb

@@ -1,11 +1,11 @@
-module Eitil::StackTrace
+module EitilSupport
   class Stack
 
   attr_reader :stack, :backtrace
 
   def initialize
     @stack     = caller[1..]
-    @backtrace = stack.map { |call| Eitil::StackTrace::Call.new(call) }
+    @backtrace = stack.map { |call| EitilSupport::Call.new(call) }
   end
 
   def report

data/eitil_wrapper/README.md

@@ -0,0 +1,181 @@
+
+
+
+# EitilWrapper
+
+EitilWrapper wraps core rails operations with extended utilities – such as routing, jobs and decoraters.
+
+
+
+
+
+## EitilWrapper::Decorators
+
+```ruby
+
+require "eitil_wrapper/decorators"
+
+```
+
+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.
+
+```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]
+end
+```
+
+
+
+
+
+## EitilWrapper::Jobs
+
+```ruby
+
+require "eitil_wrapper/jobs"
+
+```
+
+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.
+
+```ruby
+# require "eitil_wrapper/jobs/new_job"
+
+new_job(_method, *args, **kwargs)
+# assuming a method :hello_world, call as: new_job :hello_world
+# => defines :hello_world_job
+```
+
+```ruby
+# require "eitil_wrapper/jobs/new_job_debugger"
+
+new_job_debugger(_method, *args, **kwargs)
+# assuming a method :hello_world, call as: new_job_debugger :hello_world
+# => defines :hello_world_job_debugger
+```
+
+
+
+
+
+## EitilWrapper::Routes
+
+```ruby
+
+require "eitil_wrapper/routes"
+
+```
+
+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.
+
+### New route
+
+The first macro, .new_route, enables you to create new route objects which may be called and used by different controllers.
+
+```ruby
+# require "eitil_wrapper/routes/extended_resources"
+
+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 route
+
+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
+# require "eitil_wrapper/routes/extended_resources"
+
+extended_resources(controller, **kwargs)
+# call as: extended_resources :posts, only: [:create, :update, :attachment]
+```
+
+
+
+
+
+## EitilWrapper::Scopes
+
+```ruby
+
+require "eitil_wrapper/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
+# require "eitil_wrapper/scopes/default_scopes"
+
+# 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
+```
+
+

data/eitil_wrapper/lib/eitil_wrapper.rb

@@ -0,0 +1,7 @@
+
+require "eitil_wrapper"
+
+require "eitil_wrapper/jobs"
+require "eitil_wrapper/scopes"
+require "eitil_wrapper/routes"
+require "eitil_wrapper/decorators"

data/eitil_wrapper/lib/eitil_wrapper/decorators.rb

@@ -0,0 +1,3 @@
+
+require "eitil_wrapper/decorators/application_decorator"
+require "eitil_wrapper/decorators/controller_decorator"

data/{config/initializers/wrappers → eitil_wrapper/lib/eitil_wrapper}/decorators/application_decorator.rb

@@ -1,4 +1,4 @@
-module Eitil
+module EitilWrapper
   class ApplicationDecorator
 
     include ActiveModel::Model

data/eitil_wrapper/lib/eitil_wrapper/decorators/controller_decorator.rb

@@ -0,0 +1,60 @@
+module EitilWrapper
+  module ControllerDecorator
+
+    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

data/eitil_wrapper/lib/eitil_wrapper/jobs.rb

@@ -0,0 +1,4 @@
+
+require "eitil_wrapper/jobs/new_job"
+require "eitil_wrapper/jobs/new_job_debugger"
+require "eitil_wrapper/jobs/single_method_job"

data/eitil_wrapper/lib/eitil_wrapper/jobs/new_job.rb

@@ -0,0 +1,34 @@
+
+# require "eitil_wrapper/jobs/new_job"
+
+require "eitil_wrapper/jobs/single_method_job"
+
+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|
+        
+        EitilWrapper::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|
+       
+        EitilWrapper::SingleMethodJob.perform_later(
+          *args, _class: to_s, _method: _method.to_s, **kwargs
+        )
+      end
+    end 
+  end
+
+end