eitil 1.0.1.e.1 → 1.0.2

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/eitil_support/lib/eitil_support/stacktrace/audit.rb

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

data/eitil_support/lib/eitil_support/stacktrace/call.rb

@@ -0,0 +1,17 @@
+module EitilSupport
+  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/eitil_support/lib/eitil_support/stacktrace/stack.rb

@@ -0,0 +1,28 @@
+module EitilSupport
+  class Stack
+
+  attr_reader :stack, :backtrace
+
+  def initialize
+    @stack     = caller[1..]
+    @backtrace = stack.map { |call| EitilSupport::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/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/eitil_wrapper/lib/eitil_wrapper/decorators/application_decorator.rb

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