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

data/eitil_store/lib/eitil_store/regex/regex.rb

@@ -0,0 +1,41 @@
+# require "eitil_store/regex/regex"
+
+module EitilStore
+  module Regex
+
+    # URL
+    Url = /(\A\z)|(\A(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?\z)/ix
+
+    # Domain
+    Domain = /(\A\z)|(\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?)?\z)/ix
+
+    # From the email regex research: http://fightingforalostcause.net/misc/2006/compare-email-regex.php
+    Email = /\A([\w\!\#\z\%\&\'\*\+\-\/\=\?\\A\`{\|\}\~]+\.)*[\w\+-]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)\z/i
+
+    # Validates a UUID as defined: http://en.wikipedia.org/wiki/Universally_unique_identifier
+    UUID = /\A(\h{32}|\h{8}-\h{4}-\h{4}-\h{4}-\h{12})\z/
+
+    # IsNum comes from the Rubinius source code and identifies both integers and floats correctly.
+    IsNum = /^\s*[+-]?((\d+_?)*\d+(\.(\d+_?)*\d+)?|\.(\d+_?)*\d+)(\s*|([eE][+-]?(\d+_?)*\d+)\s*)$/
+
+    # Validates Credit Card numbers, Checks if it contains 16 numbers in groups of 4 separated by -, space or nothing
+    CreditCard = /\A(\d{4}-){3}\d{4}\z|\A(\d{4}\s){3}\d{4}\z|\A\d{16}\z/
+
+    # MasterCard credit card
+    MasterCard = /\A5[1-5]\d{14}\z/
+
+    # Visa credit card
+    Visa = /\A4\d{15}\z/
+
+    # Source: http://snipplr.com/view/15322/iban-regex-all-ibans/
+    # You have to remove spaces or any separator character from the original field before use this regex
+    Iban = /[a-zA-Z]{2}[0-9]{2}[a-zA-Z0-9]{4}[0-9]{7}([a-zA-Z0-9]?){0,16}/
+
+    # General postal code: validates a 5 digits postal code
+    GeneralPostalCode = /\A\d{5}\z/
+
+    # Validates US ZIP Code (basic and extended format)
+    ZIPCode = /\A(\d{5}\z)|(\d{5}-\d{4}\z)/
+
+  end
+end

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,26 @@
+
+# require "eitil_support/directory"
+
+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