el 0.5.0

data/docs/CacheManager.md

@@ -0,0 +1,66 @@
+
+## Cache Manager
+
+Allows to cache the result of an arbitrary block and use the result on consequent requests.
+
+*Note: Value is not stored if block returns false or nil.*
+
+Cache can be cleared by calling `clear_cache!` method.
+
+If called without params, all cache will be cleared.
+
+To clear only specific blocks, pass their IDs as params.
+
+**Example:**
+
+```ruby
+class App < E
+
+  def index
+    @db_items = cache :db_items do
+      # fetching items
+    end
+    @banners = cache :banners do
+      # render banners partial
+    end
+    # ...
+  end
+
+  def products
+    cache do
+      # fetch and render products
+    end
+  end
+
+  after do
+    if 'some condition occurred'
+      # clearing cache only for @banners and @db_items
+      clear_cache! :banners, :db_items
+    end
+    if 'some another condition occurred'
+      # clearing all cache
+      clear_cache!
+    end
+  end
+end
+```
+
+
+By default, the cache will be kept in memory.<br>
+If you want to use a different pool, set it by using `cache_pool` at app level.
+
+Just make sure your pool behaves like a Hash,
+Meant it should respond to `[]=`, `[]`, `delete` and `clear`.
+
+
+```ruby
+# controllers...
+
+app = E.new do
+  cache_pool SomePool
+  mount Something
+end
+app.run
+```
+
+**[ [contents &uarr;](https://github.com/espresso/espresso-lungo#use) ]**

data/docs/ContentHelpers.md

@@ -0,0 +1,64 @@
+
+## content_for
+
+Allow to capture content and then render it into a different place:
+
+```ruby
+content_for :assets do
+  js_tag :jquery
+end
+
+# later in views
+yield_content :assets
+#=> '<script src="jquery.js" type="text/javascript"></script>'
+```
+
+Use `content_for?` to check whether content block exists for some key:
+
+```ruby
+p content_for?(:assets)
+#=> #<Proc:0x00...
+
+p content_for?(:blah)
+#=> nil
+```
+
+It is also possible to pass any variables into content block:
+
+```ruby
+content_for :account do |name, email|
+  form_tag! do
+    input_tag(value: name) +
+    input_tag(value: email)
+  end
+end
+
+# somewhere in views
+yield_content :account, :foo, 'foo@bar.com'
+#=> '<form><input value="foo"><input value="foo@bar.com"></form>'
+```
+
+Please note that content block will be executed every time you call `yield_content`.
+
+If you are using same content block multiple times on same page please consider to assign the result to a variable and use it repeatedly to avoid performance decreasing.
+
+**[ [contents &uarr;](https://github.com/espresso/espresso-lungo#use) ]**
+
+## capture_html
+
+Execute given content block and return the result.
+
+Useful when you need to display same snippet multiple times and want it rendered only once.
+
+```ruby
+html = capture_html do
+  js_tag(:jquery) +
+  css_tag(:ui)
+end
+
+puts html
+#=> <script src="jquery.js" type="text/javascript"></script>
+#=> <link href="ui.css" media="all" type="text/css" rel="stylesheet">
+```
+
+**[ [contents &uarr;](https://github.com/espresso/espresso-lungo#use) ]**

data/docs/TagFactory.md

@@ -0,0 +1,201 @@
+
+## Generic Tags
+
+`Espresso Lungo` comes with a set of useful helpers aimed at generating HTML in plain Ruby:
+
+```ruby
+div_tag 'some text'
+#=> <div>some text</div>
+```
+
+HTML attributes can be passed via options Hash:
+
+```ruby
+h1_tag 'Welcome!', class: 'well'
+#=> <h1 class="well">Welcome!</h1>
+```
+
+Content can be provided via block:
+
+```ruby
+script_tag do
+  // some js here
+end
+#=> <script>
+#=>   // some js here
+#=> </script>
+```
+
+**Important!** Any content, provided via first argument or block, will be HTML escaped!
+To emit content as is, use bang methods and MAKE SURE you do not pass any untrusted input into HTML helpers!
+
+**Default Behavior:**
+
+```ruby
+div_tag 'some <evil> string'
+#=> <div>some &lt;evil&gt; string</div>
+```
+
+**Bang helpers wont escape output! Use with care!**
+
+```ruby
+div_tag! 'some <evil> string'
+#=> <div>some <evil> string</div>
+```
+
+Though bang methods are mostly dangerous, they are necessary when using nested tags:
+
+```ruby
+div_tag! do # without bang <b> tag will be escaped
+  b_tag 'some <evil> string'
+end
+#=> <div><b>some &lt;evil&gt; string</b></div>
+```
+
+The main concern when using nested tags is to not mix helpers with any untrusted input.
+
+**Note:** when using multiple tags you have to concat them, otherwise only the last one will be shown:
+
+**Wrong:**
+
+```ruby
+form_tag! do
+  input_tag(name: :name)
+  input_tag(name: :email)
+end
+#=> <form><input name="email"></form>
+```
+
+**Correct:**
+
+```ruby
+form_tag! do
+  input_tag(name: :name) +  # or <<
+  input_tag(name: :email)
+end
+#=> <form><input name="name"><input name="email"></form>
+```
+
+**[ [contents &uarr;](https://github.com/espresso/espresso-lungo#use) ]**
+
+
+## link_to
+
+`link_to` allow to build a HTML &lt;a&gt; tag.
+
+If first param is a valid action, the URL of given action will be used.
+
+Action accepted as a symbol or a string representing action name and format.
+
+Action can also be passed in deRESTified form, eg. `:read` instead of `:post_read`
+
+```ruby
+class App < E
+  format '.html'
+
+  def read
+    link_to :read        #=> <a href="/app/read" ...
+    link_to 'read.html'  #=> <a href="/app/read.html" ...
+    link_to 'read.xml'   #=> <a href="read.xml" ... - not translated, used as is
+  end
+
+  def post_write
+    link_to :post_write  #=> <a href="/app/write" ... - works but it is tedious, use :write instead
+    link_to :write       #=> <a href="/app/write" ...
+    link_to 'write.html' #=> <a href="/app/write.html" ...
+    link_to '/something' #=> <a href="/something" ... - not translated, used as is
+  end
+end
+```
+
+When you need to create a link to an arbitrary controller, use `base_url`, `route` or `[]` of target controller:
+
+```ruby
+  class News < E
+    format '.html'
+
+    def home
+      # ...
+    end
+
+    def get_read id = nil
+      # ...
+    end
+
+  end
+
+  link_to News.base_url      #=> <a href="/news" ...
+  link_to News[:home]        #=> <a href="/news/home" ...
+  link_to News['home.html']  #=> <a href="/news/home.html" ...
+  link_to News[:get_read]    #=> <a href="/news/read" ...
+  link_to News[:read]        #=> <a href="/news/read" ...
+  link_to News['read.html']  #=> <a href="/news/read.html" ...
+
+  link_to News.route(:read, 100)         #=> <a href="/news/read/100" ...
+  link_to News.route(:read, '100.html')  #=> <a href="/news/read/100.html" ...
+```
+
+
+If `nil` passed as first argument, a void link will be created:
+
+```ruby
+link_to nil, 'something'
+#=> <a href="javascript:void(null);>something</a>
+```
+
+Anchor can be passed via second argument.
+
+If it is missing, the link will be used as anchor:
+
+```ruby
+link_to :something
+#=> <a href="/something">/something</a>
+
+link_to :foo, 'bar'
+#=> <a href="/foo">bar</a>
+```
+
+Anchor can also be passed as a block:
+
+```ruby
+link_to(:foo) { 'bar' }
+#=> <a href="/foo>bar</a>
+```
+
+
+**Important!** Anchor will be HTML escaped:
+
+```ruby
+link_to(:foo) { 'some <evil>' }
+#=> <a href="/foo>some &lt;evil&gt;</a>
+```
+
+To emit content as is, use bang method instead and make sure you do not pass any untrusted content to `link_to` helper:
+
+
+```ruby
+link_to! :foo, 'some <evil>'
+#=> <a href="/foo>some <evil></a>
+```
+
+Also you'll need bang helper when you build nested tags:
+
+```ruby
+link_to! :foo do
+  b_tag 'some text'
+end
+#=> <a href="/foo><b>some text</b></a>
+```
+
+
+Attributes can be passed as a hash via last argument:
+
+```ruby
+link_to :foo, target: '_blank'
+#=> <a href="/foo" target="_blank">/foo</a>
+
+link_to :foo, :bar, target: '_blank'
+#=> <a href="/foo" target="_blank">bar</a>
+```
+
+**[ [contents &uarr;](https://github.com/espresso/espresso-lungo#use) ]**

data/el.gemspec

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+version = '0.5.0'
+Gem::Specification.new do |s|
+
+  s.name = 'el'
+  s.version = version
+  s.authors = ['Silviu Rusu']
+  s.email = ['slivuz@gmail.com']
+  s.homepage = 'https://github.com/espresso/espresso-lungo'
+  s.summary = 'el-%s' % version
+  s.description = 'Espresso Lungo - Extra Libs for Espresso Framework'
+
+  s.required_ruby_version = '>= 1.9.2'
+  s.add_dependency 'e', '>= 0.4.8'
+  s.add_dependency 'sprockets'
+
+  s.add_development_dependency 'bundler'
+
+  s.require_paths = ['lib']
+  s.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock)\Z/}
+  s.licenses = ['MIT']
+end

data/lib/el.rb

@@ -0,0 +1,11 @@
+require 'e'
+require 'sprockets'
+
+require 'el/constants'
+require 'el/tag_factory'
+require 'el/content_helpers'
+require 'el/assets'
+require 'el/cache'
+require 'el/crud'
+require 'el/ipcm'
+require 'el/utils'

data/lib/el/assets.rb

@@ -0,0 +1,126 @@
+module EL
+  class AssetsMapper
+    include TagFactory
+
+    attr_reader :baseurl, :wd
+
+    # @example
+    # 
+    #   assets_mapper :vendor do
+    #     
+    #     js_tag :jquery
+    # 
+    #     chdir 'jquery-ui'
+    #     js_tag 'js/jquery-ui.min'
+    #     css_tag 'css/jquery-ui.min'
+    # 
+    #     cd '../bootstrap'
+    #     js_tag 'js/bootstrap.min'
+    #     css_tag 'css/bootstrap'
+    #   end
+    #
+    #   #=> <script src="/vendor/jquery.js" ...
+    #   #=> <script src="/vendor/jquery-ui/js/jquery-ui.min.js" ...
+    #   #=> <link href="/vendor/jquery-ui/css/jquery-ui.min.css" ...
+    #   #=> <script src="/vendor/bootstrap/js/bootstrap.min.js" ...
+    #   #=> <link href="/vendor/bootstrap/css/bootstrap.css" ...
+    #
+    def initialize baseurl, opts = {}, &proc
+      @opts = Hash[opts]
+      @suffix = @opts.delete(:suffix) || ''
+      baseurl = baseurl.to_s.dup.strip
+      baseurl.empty? ? baseurl = nil : (baseurl =~ /\/\Z/ || baseurl << '/')
+      @baseurl, @wd = baseurl.freeze, nil
+      proc && self.instance_exec(&proc)
+    end
+
+    (%w[js css] + EConstants::IMAGE_TAGS).each do |tag|
+      define_method tag + '_tag' do |src, attrs={}|
+        super src, attrs.merge(suffix: @suffix)
+      end
+    end
+
+    def chdir path = nil
+      return @wd = nil unless path
+      wd = []
+      if (path = path.to_s) =~ /\A\//
+        path = path.sub(/\A\/+/, '')
+        path = path.empty? ? [] : [path]
+      else
+        dirs_back, path = path.split(/\/+/).partition { |c| c == '..' }
+        if @wd
+          wd_chunks = @wd.split(/\/+/)
+          wd = wd_chunks[0, wd_chunks.size - dirs_back.size] || []
+        end
+      end
+      @wd = (wd + path << '').compact.join('/').freeze
+    end
+    alias :cd :chdir
+
+    private
+    def assets_url path = nil
+      chunks = [baseurl, wd, path]          # assigning array to a variable
+      chunks.select! {|c| c && c.size > 0}  # and work on it
+      File.join(*chunks)                    # is 2x faster than array#select {...}
+    end
+
+  end
+end
+
+class E
+  include EL::TagFactory
+
+  def assets *args, &proc
+    app.assets *args, &proc
+  end
+
+  def assets_mapper *args, &proc
+    EL::AssetsMapper.new *args, &proc
+  end
+
+  private
+  def assets_url path = nil
+    path ?
+      (app.assets_url ? File.join(app.assets_url, path.to_s) : path.to_s) :
+      (app.assets_url ? app.assets_url : '')
+  end
+
+end
+
+class EBuilder
+
+  # set the baseurl for assets.
+  # by default, assets URL is empty.
+  # 
+  # @example assets_url not set
+  #   script_tag 'master.js'
+  #   => <script src="master.js"
+  #   style_tag 'theme.css'
+  #   => <link href="theme.css"
+  #
+  # @example assets_url set to /assets
+  #
+  #   script_tag 'master.js'
+  #   => <script src="/assets/master.js"
+  #   style_tag 'theme.css'
+  #   => <link href="/assets/theme.css"
+  #
+  # @note
+  #   by default, Sprockets will be used to serve static files.
+  #   to disable this, set second argument to false.
+  #
+  def assets_url url = nil, server = true
+    return @assets_url if @assets_url
+    url = url.to_s.dup.strip
+    url = url =~ /\A[\w|\d]+\:\/\//i ? url : EUtils.rootify_url(url)
+    @assets_url = (url =~ /\/\Z/ ? url : String.new(url) << '/').freeze
+    return unless server
+    mount_application(assets, @assets_url, on: :GET)
+  end
+  alias assets_map assets_url
+
+  def assets
+    @sprockets_env ||= Sprockets::Environment.new(root)
+  end
+
+end