el 0.5.0

data/lib/el/cache.rb

@@ -0,0 +1,96 @@
+class E
+  def cache(*a, &b);    app.cache(*a, &b);    end
+  def clear_cache!(*a); app.clear_cache!(*a); end
+  def cache_pool;       app.cache_pool;       end
+end
+
+class EBuilder
+
+  # very basic cache implementation.
+  # by default the cache will be kept in memory.
+  # if you want to use a different pool, 
+  # set it by using `cache_pool` at app level.
+  # make sure your pool behaves just like a Hash,
+  # meant it responds to `[]=`, `[]`, `keys`, `delete` and `clear`
+  #
+  def cache_pool pool = nil
+    return @cache_pool if @cache_pool
+    @cache_pool = pool if pool
+    @cache_pool ||= Hash.new
+  end
+
+  # simply running a block and store returned value.
+  # on next request the stored value will be returned.
+  # 
+  # @note
+  #   value is not stored if block returns false or nil
+  #
+  def cache key = nil, &proc
+    key ||= proc.source_location
+    cache_pool[key] || ( (val = proc.call) && (cache_pool[key] = val) )
+  end
+  
+  # a simple way to manage stored cache.
+  # any number of arguments(actually matchers) accepted.
+  # matchers can be of String, Symbol or Regexp type. any other arguments ignored
+  # 
+  # @example
+  #    class App < E
+  #
+  #      before do
+  #        if 'some condition occurred'
+  #          # clearing cache only for @red_banners and @db_items
+  #          clear_cache! :red_banners, :db_items
+  #        end
+  #        if 'some another condition occurred'
+  #          # clearing all cache
+  #          clear_cache!
+  #        end
+  #        if 'Yet another condition occurred'
+  #          # clearing cache by regexp
+  #          clear_cache! /banners/, /db/
+  #        end
+  #      end
+  #    end
+  #
+  #    def index
+  #      @db_items = cache :db_items do
+  #        # ...
+  #      end
+  #      @red_banners = cache :red_banners do
+  #        # ...
+  #      end
+  #      @blue_banners = cache :blue_banners do
+  #        # ...
+  #      end
+  #      # ...
+  #    end
+  #
+  #    def products
+  #      cache do
+  #        # fetch and render products
+  #      end
+  #    end
+  #  end
+  #
+  # @param [Array] keys
+  def clear_cache! *matchers
+    clear_cache *matchers
+    ipcm_trigger :clear_cache, *matchers
+  end
+
+  # same as `clear_cache!` except it is working only on current process
+  #
+  # @param [Array] keys
+  def clear_cache *matchers
+    return cache_pool.clear if matchers.empty?
+    keys = Array.new(cache_pool.keys)
+    matchers.each do |matcher|
+      mkeys = matcher.is_a?(Regexp) ?
+        keys.select {|k| k =~ matcher} :
+        keys.select {|k| k == matcher}
+      mkeys.each {|k| cache_pool.delete k}
+    end
+  end
+
+end

data/lib/el/constants.rb

@@ -0,0 +1,21 @@
+module EConstants
+  GENERIC_TAGS = %w[
+    html head title body h1 h2 h3 h4 h5 h6 p a
+    abbr address b bdi bdo blockquote cite code del dfn em i ins kbd
+    mark meter pre progress q rp rt ruby s samp small strong sub sup
+    time u var wbr form textarea button select optgroup option label
+    fieldset legend datalist output iframe map area canvas figcaption figure
+    audio source track video nav ul ol li dl dt dd
+    table caption th tr td thead tbody tfoot colgroup col
+    div span header footer hgroup section article aside details dialog summary
+    style script noscript object
+  ].freeze
+  
+  EMPTY_TAGS = %w[
+    img link br hr input keygen meta base embed param
+  ].freeze
+
+  IMAGE_TAGS = %w[
+    jpg jpeg png gif tif tiff bmp svg xpm
+  ].freeze
+end

data/lib/el/content_helpers.rb

@@ -0,0 +1,61 @@
+module EL
+  module ContentHelpers
+
+    # capture content and then render it into a different place
+    #
+    # @example
+    #   content_for :assets do
+    #     js_tag :jquery
+    #   end
+    #
+    #   p content_for?(:assets)
+    #   #=> #<Proc:0x00...
+    #
+    #   yield_content :assets
+    #   #=> '<script src="jquery.js" type="text/javascript"></script>'
+    #
+    # @example
+    #   content_for :account do |name, email|
+    #     form_tag! do
+    #       input_tag(value: name) +
+    #       input_tag(value: email)
+    #     end
+    #   end
+    #
+    #   yield_content :account, :foo, 'foo@bar.com'
+    #   #=> '<form><input value="foo"><input value="foo@bar.com"></form>'
+    #
+    def content_for key, &proc
+      (@__el__content_for ||= {})[key] = proc
+    end
+
+    # check whether content block exists for some key
+    def content_for? key
+      (@__el__content_for || {})[key]
+    end
+
+    # render a content block captured by `content_for`
+    def yield_content key, *args
+      (proc = content_for?(key)) && proc.call(*args)
+    end
+
+    # execute given content block and return the result.
+    # useful when you need to display same snippet multiple times
+    # and want it rendered only once
+    #
+    # @example
+    #   assets = capture_html do
+    #     js_tag(:jquery) +
+    #     css_tag(:ui)
+    #   end
+    #
+    def capture_html &proc
+      proc.call
+    end
+  end
+
+end
+
+class E
+  include EL::ContentHelpers
+end

data/lib/el/crud.rb

@@ -0,0 +1,239 @@
+class << E
+
+  E__CRUD__AUTH_TEST_PAYLOAD_KEY = "E__CRUD__AUTH_TEST_PAYLOAD_#{rand(2**64)}".freeze
+
+  # automatically creates POST/PUT/DELETE actions
+  # and map them to corresponding methods of given resource,
+  # so sending a POST request to the controller
+  # resulting in creating new object of given resource.
+  # PUT/PATCH requests will update objects by given id.
+  # DELETE requests will delete objects by given id.
+  #
+  # @params [Class] resource
+  # @params [Array] path_or_opts
+  # @option path_or_opts [String || Array] :exclude
+  #   sometimes forms sending extra params. exclude them using :exclude option
+  # @option path_or_opts [Integer] :pkey
+  #   item's primary key(default :id) to be returned when item created /updated.
+  #   if no pkey given and item does not respond to :id, the item itself returned.
+  # @option path_or_opts [Integer] :halt_on_errors
+  #   if created/updated item contain errors,
+  #   halt processing unconditionally, even if proc given.
+  #   if this option is false(default) and a proc given,
+  #   it will pass item object and extracted errors to proc rather than halt.
+  # @option path_or_opts [Integer] :halt_with
+  #   when resource are not created/updated because of errors,
+  #   Espresso will halt operation with 500 error status code.
+  #   use :halt_with option to set a custom error status code.
+  # @option path_or_opts [String] :join_with
+  #   if resource thrown some errors, Espresso will join them using a coma.
+  #   use :join_with option to set a custom glue.
+  #
+  def crudify resource, *path_or_opts, &proc
+    opts = path_or_opts.last.is_a?(Hash) ? path_or_opts.pop : {}
+    if opts[:exclude]
+      opts[:exclude] = [ opts[:exclude] ] unless opts[:exclude].is_a?(Array)
+    else
+      opts[:exclude] = []
+    end
+    path = path_or_opts.first
+    action = '%s_' << (path || :index).to_s
+    orm = :ar if resource.respond_to?(:arel_table)
+    orm = :dm if resource.respond_to?(:storage_name)
+    orm = :sq if resource.respond_to?(:db_schema)
+    orm_map = {
+      ar: {
+          get: :find,
+          put: :update_attributes,
+        patch: :update_attributes
+      },
+      sq: {
+        get: :[]
+      }
+    }[orm] || {}
+    resource_method = {
+         get: opts.fetch(:get,    orm_map[:get] || :get),
+         put: opts.fetch(:put,    orm_map[:put] || :update),
+        post: opts.fetch(:post,   :create),
+       patch: opts.fetch(:patch,  orm_map[:patch] || :update),
+      delete: opts.fetch(:delete, :destroy),
+    }
+    
+    proc_accept_object, proc_accept_errors = nil
+    if proc
+      proc_accept_object = proc.arity > 0
+      proc_accept_errors = proc.arity > 1
+    end
+
+    pkey      = opts[:pkey]      || :id
+    join_with = opts[:join_with] || ', '
+    halt_with = opts[:halt_with] || 500
+
+    presenter = lambda do |controller_instance, obj, err|
+
+      # extracting errors, if any
+      errors = nil
+      if err || (obj.respond_to?(:errors) && (err = obj.errors) &&
+        err.respond_to?(:size) && err.size > 0)
+
+        if err.respond_to?(:join)
+          errors = err
+        else
+          if err.respond_to?(:each_pair) # seems error is a Hash
+            # some objects may respond to `each_pair` but not respond to `inject`,
+            # so using trivial looping to extract error messages.
+            errors = []
+            err.each_pair do |k,v|
+              # usually DataMapper returns errors in the following format:
+              # { :property => ['error 1', 'error 2'] }
+              # flatten is here just in case we get nested arrays.
+              error = v.is_a?(Array) ? v.flatten.join(join_with) : v.to_s
+              errors << '%s: %s' % [k, error]
+            end
+          elsif err.respond_to?(:to_a) # not Array nor Hash, but convertible to Array
+            # converting error to Array and joining
+            errors = err.to_a
+          elsif err.is_a?(String)
+            errors = [err]
+          else
+            errors = [err.inspect]
+          end
+        end
+      end
+      errors && errors = controller_instance.escape_html(errors.join(join_with))
+      
+      if proc
+        if errors && opts[:halt_on_errors]
+          controller_instance.halt halt_with, errors
+        end
+        proc_args = []
+        proc_args = [obj] if proc_accept_object
+        proc_args = [obj, errors] if proc_accept_errors
+        controller_instance.instance_exec(*proc_args, &proc)
+      else
+        if errors
+          # no proc given, so halting when some errors occurring
+          controller_instance.styled_halt halt_with, errors
+        else
+          # no proc given and no errors detected,
+          # so extracting and returning object's pkey.
+          # if no pkey given and object does not respond to :id nor to :[],
+          # returning object as is.
+          if obj.respond_to?(:[]) && obj.respond_to?(:has_key?)
+            obj.has_key?(pkey) ? obj[pkey] : obj
+          elsif obj.respond_to?(pkey)
+            obj.send(pkey)
+          else
+            obj
+          end
+        end
+      end
+    end
+    
+    fetch_object = lambda do |controller_instance, id|
+      obj, err = nil
+      begin
+        id = id.to_i if id =~ /\A\d+\Z/
+        obj = resource.send(resource_method[:get], id) ||
+          controller_instance.halt(404, 'object with ID %s not found' % controller_instance.escape_html(id))
+      rescue => e
+        err = e.message
+      end
+      [obj, err]
+    end
+
+    create_object = lambda do |controller_instance|
+      obj, err = nil
+      begin
+        data = controller_instance.params.reject { |k,v| opts[:exclude].include?(k) }
+        unless data.has_key?(E__CRUD__AUTH_TEST_PAYLOAD_KEY)
+          obj = resource.send(resource_method[:post], data)
+        end
+      rescue => e
+        err = e.message
+      end
+      [obj, err]
+    end
+
+    update_object = lambda do |controller_instance, request_method, id|
+      obj, err = nil
+      begin
+        obj, err = fetch_object.call(controller_instance, id)
+        unless err
+          data = controller_instance.params.reject { |k,v| opts[:exclude].include?(k) }
+          obj.send(resource_method[request_method], data)
+        end
+      rescue => e
+        err = e.message
+      end
+      [obj, err]
+    end
+
+    # fetching object by given id
+    # and calling #destroy(or whatever in options for delete) on it
+    #
+    # @return [String] empty string
+    delete_object = lambda do |id|
+      err = nil
+      begin
+        obj, err = fetch_object.call(self, id)
+        unless err
+          meth = resource_method[:delete]
+          if obj.respond_to?(meth)
+             obj.send(meth)
+          else
+            err = '%s does not respond to %s' % [obj.inspect, escape_html(meth)]
+          end
+        end
+      rescue => e
+        err = e.message
+      end
+      [nil, err]
+    end
+
+    options = lambda do |controller_instance|
+      EConstants::HTTP__REQUEST_METHODS.reject do |rm|
+        next if rm == 'OPTIONS'
+        args  = rm == 'POST' ? 
+          [{E__CRUD__AUTH_TEST_PAYLOAD_KEY => 'true'}] : 
+          [E__CRUD__AUTH_TEST_PAYLOAD_KEY]
+        s,h,b = controller_instance.invoke(action % rm.downcase, *args) do |env|
+          env.update EConstants::ENV__REQUEST_METHOD => rm
+        end
+        s == EConstants::STATUS__PROTECTED
+      end.join(', ')
+    end
+
+    self.class_exec do
+
+      define_method action % :get do |id|
+        presenter.call self, *fetch_object.call(self, id)
+      end
+
+      define_method action % :head do |id|
+        presenter.call self, *fetch_object.call(self, id)
+      end
+
+      define_method action % :post do
+        presenter.call self, *create_object.call(self)
+      end
+
+      [:put, :patch].each do |request_method|
+        define_method action % request_method do |id|
+          presenter.call self, *update_object.call(self, request_method, id)
+        end
+      end
+
+      define_method action % :delete do |id|
+        presenter.call self, *delete_object.call(id)
+      end
+
+      define_method action % :options do
+        options.call self
+      end
+    end
+
+  end
+  alias crud crudify
+
+end

data/lib/el/ipcm.rb

@@ -0,0 +1,67 @@
+# Inter-Process Cache Manager
+class EBuilder
+  
+  def ipcm_trigger *args
+    if pids_reader
+      pids = pids_reader.call rescue nil
+      if pids.is_a?(Array)
+        pids.map(&:to_i).reject {|p| p < 2 || p == Process.pid }.each do |pid|
+          file = '%s/%s.%s-%s' % [ipcm_tmpdir, pid, args.hash, Time.now.to_f]
+          begin
+            File.open(file, 'w') {|f| f << Marshal.dump(args)}
+            Process.kill ipcm_signal, pid
+          rescue => e
+            warn "was unable to perform IPCM operation because of error: %s" % ::CGI.escapeHTML(e.message)
+            File.unlink(file) if File.file?(file)
+          end
+        end
+      else
+        warn "pids_reader should return an array of pids. Exiting IPCM..."
+      end
+    end
+  end
+
+  def ipcm_tmpdir path = nil
+    return @ipcm_tmpdir if @ipcm_tmpdir
+    if path
+      @ipcm_tmpdir = ((path =~ /\A\// ? path : root + path) + '/').freeze
+    else
+      @ipcm_tmpdir = (root + 'tmp/ipcm/').freeze
+    end
+    FileUtils.mkdir_p @ipcm_tmpdir
+    @ipcm_tmpdir
+  end
+
+  def ipcm_signal signal = nil
+    return @ipcm_signal if @ipcm_signal
+    @ipcm_signal = signal.to_s if signal
+    @ipcm_signal ||= 'ALRM'
+  end
+
+  def register_ipcm_signal
+    Signal.trap ipcm_signal do
+      Dir[ipcm_tmpdir + '%s.*' % Process.pid].each do |file|
+        unless (setup = Marshal.restore(File.read(file)) rescue nil).is_a?(Array)
+          warn "Was unable to process \"%s\" cache file, skipping cache cleaning" % file
+        end
+        File.unlink(file) if File.file?(file)
+        meth = setup.shift
+        [ :clear_cache,
+          :clear_cache_like,
+          :clear_compiler,
+          :clear_compiler_like,
+        ].include?(meth) && self.send(meth, *setup)
+      end
+    end
+  end
+
+  def pids_reader &proc
+    return @pids_reader if @pids_reader
+    if proc.is_a?(Proc)
+      @pids_reader = proc
+      register_ipcm_signal
+    end
+  end
+  alias pids pids_reader
+
+end