RubyGems - middleman-core - Versions diffs - 3.0.0.alpha.7 - Mend

middleman-core 3.0.0.alpha.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (571) hide show

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/.document ADDED

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+README.rdoc
+LICENSE.txt

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/.gitignore ADDED

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+## TEXTMATE
+*.tmproj
+tmtags
+## EMACS
+*~
+\#*
+.\#*
+## VIM
+*.swp
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+## PROJECT::SPECIFIC

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/.yardopts ADDED

	@@ -0,0 +1 @@
1	+ --title 'Padrino Helpers Documentation' --protected

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/LICENSE.txt ADDED

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Padrino
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/README.rdoc ADDED

@@ -0,0 +1,239 @@
+= Application Extensions and Helpers (padrino-helpers)
+=== Overview
+This component provides a great deal of view helpers related to html markup generation.
+There are helpers for generating tags, forms, links, images, and more. Most of the basic
+methods should be very familiar to anyone who has used rails view helpers.
+=== Output Helpers
+Output helpers are a collection of important methods for managing, capturing and displaying output
+in various ways and is used frequently to support higher-level helper functions. There are
+three output helpers worth mentioning: <tt>content_for</tt>, <tt>capture_html</tt>, and <tt>concat_content</tt>
+The content_for functionality supports capturing content and then rendering this into a different place
+such as within a layout. One such popular example is including assets onto the layout from a template:
+  # app/views/site/index.erb
+  ...
+  <% content_for :assets do %>
+    <%= stylesheet_link_tag 'index', 'custom' %>
+  <% end %>
+  ...
+Added to a template, this will capture the includes from the block and allow them to be yielded into the layout:
+  # app/views/layout.erb
+  ...
+  <head>
+    <title>Example</title>
+    <%= stylesheet_link_tag 'style' %>
+    <%= yield_content :assets %>
+  </head>
+  ...
+This will automatically insert the contents of the block (in this case a stylesheet include) into the
+location the content is yielded within the layout. You can also check if content exists for a block using
+<tt>content_for?(true)</tt> which returns true if content exists.
+The capture_html and the concat_content methods allow content to be manipulated and stored for use in building
+additional helpers accepting blocks or displaying information in a template. One example is the use of
+these in constructing a simplified 'form_tag' helper which accepts a block.
+  # form_tag '/register' do ... end
+  def form_tag(url, options={}, &block)
+    # ... truncated ...
+    inner_form_html = capture_html(&block)
+    concat_content '<form>' + inner_form_html + '</form>'
+  end
+This will capture the template body passed into the form_tag block and then append the content
+to the template through the use of <tt>concat_content</tt>. Note have been built to work for both haml and erb
+templates using the same syntax.
+For more information on using output helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== Tag Helpers
+Tag helpers are the basic building blocks used to construct html 'tags' within a view template. There
+are three major functions for this category: <tt>tag</tt>, <tt>content_tag</tt> and <tt>input_tag</tt>.
+The tag and content_tag are for building arbitrary html tags with a name and specified options. If
+the tag contains 'content' within then <tt>content_tag</tt> is used. For example:
+  tag(:br, :style => 'clear:both') => <br style="clear:both" />
+  content_tag(:p, "demo", :class => 'light') => <p class="light">demo</p>
+The input_tag is used to build tags that are related to accepting input from the user:
+  input_tag :text, :class => "demo" => <input type='text' class='demo' />
+  input_tag :password, :value => "secret", :class => "demo"
+Note that all of these accept html options and result in returning a string containing html tags.
+For more information on using tag helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== Asset Helpers
+Asset helpers are intended to help insert useful html onto a view template such as 'flash' notices,
+hyperlinks, mail_to links, images, stylesheets and javascript. An example of their uses would be on a
+simple view template:
+  # app/views/example.haml
+  ...
+  %head
+    = stylesheet_link_tag 'layout'
+    = javascript_include_tag 'application'
+  %body
+    ...
+    = flash_tag :notice
+    %p= link_to 'Blog', '/blog', :class => 'example'
+    %p Mail me at #{mail_to 'fake@faker.com', "Fake Email Link", :cc => "test@demo.com"}
+    %p= image_tag 'padrino.png', :width => '35', :class => 'logo'
+For more information on using asset helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== Form Helpers
+Form helpers are the 'standard' form tag helpers you would come to expect when building forms. A simple
+example of constructing a non-object form would be:
+  - form_tag '/destroy', :class => 'destroy-form', :method => 'delete' do
+    = flash_tag(:notice)
+    - field_set_tag do
+      %p
+        = label_tag :username, :class => 'first'
+        = text_field_tag :username, :value => params[:username]
+      %p
+        = label_tag :password, :class => 'first'
+        = password_field_tag :password, :value => params[:password]
+      %p
+        = label_tag :strategy
+        = select_tag :strategy, :options => ['delete', 'destroy'], :selected => 'delete'
+      %p
+        = check_box_tag :confirm_delete
+    - field_set_tag(:class => 'buttons') do
+      = submit_tag "Remove"
+For more information on using form helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== FormBuilders
+Form builders are full-featured objects allowing the construction of complex object-based forms
+using a simple, intuitive syntax.
+A form_for using these basic fields might look like:
+  - form_for @user, '/register', :id => 'register' do |f|
+    = f.error_messages
+    %p
+      = f.label :username, :caption => "Nickname"
+      = f.text_field :username
+    %p
+      = f.label :email
+      = f.text_field :email
+    %p
+      = f.label :password
+      = f.password_field :password
+    %p
+      = f.label :is_admin, :caption => "Admin User?"
+      = f.check_box :is_admin
+    %p
+      = f.label :color, :caption => "Favorite Color?"
+      = f.select :color, :options => ['red', 'black']
+    %p
+      - fields_for @user.location do |location|
+        = location.text_field :street
+        = location.text_field :city
+    %p
+      = f.submit "Create", :class => 'button'
+Forms can also accept nested attributes using `fields_for` within the form builder in recent releases. Check out the guide for {Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers] to learn more about nested forms.
+There is also an additional StandardFormBuilder which builds on the abstract fields that can be used within a form_for.
+A form_for using these standard fields might be:
+  - form_for @user, '/register', :id => 'register' do |f|
+    = f.error_messages
+    = f.text_field_block :name, :caption => "Full name"
+    = f.text_field_block :email
+    = f.check_box_block  :remember_me
+    = f.select_block     :fav_color, :options => ['red', 'blue']
+    = f.password_field_block :password
+    = f.submit_block "Create", :class => 'button'
+and would generate this html (with each input contained in a paragraph and containing a label):
+  <form id="register" action="/register" method="post">
+    <p><label for="user_name">Full name: </label><input type="text" id="user_name" name="user[name]"></p>
+    ...omitted...
+    <p><input type="submit" value="Create" class="button"></p>
+  </form>
+You can also easily build your own FormBuilder which allows for customized fields and behavior.
+For more information on using the Padrino form builders, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== Format Helpers
+Format helpers are several useful utilities for manipulating the format of text to achieve a goal.
+The four format helpers are <tt>escape_html</tt>, <tt>time_ago_in_words</tt>, and <tt>js_escape_html</tt>.
+The escape_html and js_escape_html function are for taking an html string and escaping certain characters.
+<tt>escape_html</tt> will escape ampersands, brackets and quotes to their HTML/XML entities. This is useful
+to sanitize user content before displaying this on a template. <tt>js_escape_html</tt> is used for
+passing javascript information from a js template to a javascript function.
+  escape_html('<hello>&<goodbye>') # => &lt;hello&gt;&amp;&lt;goodbye&gt;
+There is also an alias for escape_html called <tt>h</tt> for even easier usage within templates.
+Format helpers also includes a number of useful text manipulation functions such as <tt>simple_format</tt>,
+<tt>pluralize</tt>, <tt>word_wrap</tt>, <tt>truncate</tt> and <tt>truncate_words</tt>.
+  simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
+  pluralize(2, 'person') => '2 people'
+  word_wrap('Once upon a time', :line_width => 8) => "Once upon\na time"
+  truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
+  truncate_words("Once upon a time in a world far far away", :length => 4) => "Once upon a time..."
+These helpers can be invoked from any route or view within your application.
+For more information on using the format helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+=== Render Helpers
+This component provides a number of rendering helpers making the process of displaying templates a bit easier.
+This plugin also has support for useful additions such as partials (with support for :collection) for the templating system.
+Using render plugin helpers is extremely simple. If you want to render an erb template in your view path:
+  render :erb, 'path/to/erb/template'
+or using haml templates works just as well:
+  render :haml, 'path/to/haml/template'
+There is also a method which renders the first view matching the path and removes the need to define an engine:
+  render 'path/to/any/template'
+Finally, we have the all-important partials support for rendering mini-templates onto a page:
+  partial 'photo/_item', :object => @photo, :locals => { :foo => 'bar' }
+  partial 'photo/_item', :collection => @photos
+For more information on using the render and partial helpers, check out the guide for
+{Padrino Helpers}[http://www.padrinorb.com/guides/application-helpers].
+== Copyright
+Copyright (c) 2011 Padrino. See LICENSE for details.

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/Rakefile ADDED

@@ -0,0 +1,5 @@
+# coding:utf-8
+RAKE_ROOT = __FILE__
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/lib/padrino-helpers.rb ADDED

@@ -0,0 +1,58 @@
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+require 'cgi'
+# require 'i18n'
+require 'enumerator'
+require 'active_support/core_ext/string/conversions'  # to_date
+require 'active_support/core_ext/float/rounding'      # round
+require 'active_support/option_merger'                # with_options
+require 'active_support/core_ext/object/with_options' # with_options
+require 'active_support/inflector'                    # humanize
+FileSet.glob_require('padrino-helpers/**/*.rb', __FILE__)
+# Load our locales
+# I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-helpers/locale/*.yml"]
+module Padrino
+  ##
+  # This component provides a variety of view helpers related to html markup generation.
+  # There are helpers for generating tags, forms, links, images, and more.
+  # Most of the basic methods should be very familiar to anyone who has used rails view helpers.
+  #
+  module Helpers
+    class << self
+      ##
+      # Registers these helpers into your application:
+      #
+      #   Padrino::Helpers::OutputHelpers
+      #   Padrino::Helpers::TagHelpers
+      #   Padrino::Helpers::AssetTagHelpers
+      #   Padrino::Helpers::FormHelpers
+      #   Padrino::Helpers::FormatHelpers
+      #   Padrino::Helpers::RenderHelpers
+      #   Padrino::Helpers::NumberHelpers
+      #
+      # @param [Sinatra::Application] app
+      #   The specified padrino application
+      #
+      # @example Register the helper module
+      #   require 'padrino-helpers'
+      #   class Padrino::Appliocation
+      #     register Padrino::Helpers
+      #   end
+      #
+      def registered(app)
+        app.set :default_builder, 'StandardFormBuilder'
+        app.helpers Padrino::Helpers::OutputHelpers
+        app.helpers Padrino::Helpers::TagHelpers
+        app.helpers Padrino::Helpers::AssetTagHelpers
+        app.helpers Padrino::Helpers::FormHelpers
+        app.helpers Padrino::Helpers::FormatHelpers
+        app.helpers Padrino::Helpers::RenderHelpers
+        app.helpers Padrino::Helpers::NumberHelpers
+        app.helpers Padrino::Helpers::TranslationHelpers
+      end
+      alias :included :registered
+    end
+  end # Helpers
+end # Padrino

data/lib/middleman-core/vendor/padrino-helpers-0.10.5/lib/padrino-helpers/asset_tag_helpers.rb ADDED

@@ -0,0 +1,420 @@
+module Padrino
+  module Helpers
+    ###
+    # Helpers related to producing assets (images,stylesheets,js,etc) within templates.
+    #
+    module AssetTagHelpers
+      ##
+      # Creates a div to display the flash of given type if it exists
+      #
+      # @param [Symbol] kind
+      #   The type of flash to display in the tag.
+      # @param [Hash] options
+      #   The html options for this section.
+      #
+      # @return [String] Flash tag html with specified +options+.
+      #
+      # @example
+      #   flash_tag(:notice, :id => 'flash-notice')
+      #   # Generates: <div class="notice">flash-notice</div>
+      #
+      # @api public
+      def flash_tag(kind, options={})
+        flash_text = flash[kind]
+        return '' if flash_text.blank?
+        options.reverse_merge!(:class => kind)
+        content_tag(:div, flash_text, options)
+      end
+      ##
+      # Creates a link element with given name, url and options
+      #
+      # @overload link_to(caption, url, options={})
+      #   @param [String]  caption  The text caption.
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      # @overload link_to(url, options={}, &block)
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      #   @param [Proc]    block    The link content.
+      #
+      # @option options [String] :anchor
+      #   The anchor for the link (i.e #something)
+      # @option options [Boolean] :if
+      #   If true, the link will appear, otherwise not;
+      # @option options [Boolean] :unless
+      #   If false, the link will appear, otherwise not;
+      # @option options [Boolean] :remote
+      #   If true, this link should be handled by a ajax ujs handler.
+      # @option options [String] :confirm
+      #   Instructs ujs handler to alert confirm message.
+      # @option options [Symbol] :method
+      #   Instructs ujs handler to use different http method (i.e :post, :delete).
+      #
+      # @return [String] Link tag html with specified +options+.
+      #
+      # @example
+      #   link_to('click me', '/dashboard', :class => 'linky')
+      #   link_to('click me', '/dashboard', :remote => true)
+      #   link_to('click me', '/dashboard', :method => :delete)
+      #   link_to('click me', :class => 'blocky') do; end
+      #
+      # Note that you can pass :+if+ or :+unless+ conditions, but if you provide :current as
+      # condition padrino return true/false if the request.path_info match the given url
+      #
+      # @api public
+      def link_to(*args, &block)
+        options = args.extract_options!
+        options = parse_js_attributes(options) # parses remote, method and confirm options
+        anchor  = "##{CGI.escape options.delete(:anchor).to_s}" if options[:anchor]
+        if block_given?
+          url = args[0] ? args[0] + anchor.to_s : anchor || 'javascript:void(0);'
+          options.reverse_merge!(:href => url)
+          link_content = capture_html(&block)
+          return '' unless parse_conditions(url, options)
+          result_link = content_tag(:a, link_content, options)
+          block_is_template?(block) ? concat_content(result_link) : result_link
+        else
+          name, url = args[0], (args[1] ? args[1] + anchor.to_s : anchor || 'javascript:void(0);')
+          return name unless parse_conditions(url, options)
+          options.reverse_merge!(:href => url)
+          content_tag(:a, name, options)
+        end
+      end
+      ##
+      # Creates a form containing a single button that submits to the url.
+      #
+      # @overload button_to(name, url, options={})
+      #   @param [String]  caption  The text caption.
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      # @overload button_to(name, options={}, &block)
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      #   @param [Proc]    block    The button content.
+      #
+      # @option options [Boolean] :multipart
+      #   If true, this form will support multipart encoding.
+      # @option options [String] :remote
+      #   Instructs ujs handler to handle the submit as ajax.
+      # @option options [Symbol] :method
+      #   Instructs ujs handler to use different http method (i.e :post, :delete).
+      #
+      # @return [String] Form and button html with specified +options+.
+      #
+      # @example
+      #   button_to 'Delete', url(:accounts_destroy, :id => account), :method => :delete, :class => :form
+      #   # Generates:
+      #   # <form class="form" action="/admin/accounts/destroy/2" method="post">
+      #   #   <input type="hidden" value="delete" name="_method" />
+      #   #   <input type="submit" value="Delete" />
+      #   # </form>
+      #
+      # @api public
+      def button_to(*args, &block)
+        name, url = args[0], args[1]
+        options   = args.extract_options!
+        desired_method = options[:method]
+        options.delete(:method) if options[:method].to_s !~ /get|post/i
+        options.reverse_merge!(:method => 'post', :action => url)
+        options[:enctype] = "multipart/form-data" if options.delete(:multipart)
+        options["data-remote"] = "true" if options.delete(:remote)
+        inner_form_html  = hidden_form_method_field(desired_method)
+        inner_form_html += block_given? ? capture_html(&block) : submit_tag(name)
+        content_tag('form', inner_form_html, options)
+      end
+      ##
+      # Creates a link tag that browsers and news readers can use to auto-detect an RSS or ATOM feed.
+      #
+      # @param [Symbol] mime
+      #   The mime type of the feed (i.e :atom or :rss).
+      # @param [String] url
+      #   The url for the feed tag to reference.
+      # @param[Hash] options
+      #   The options for the feed tag.
+      # @option options [String] :rel ("alternate")
+      #   Specify the relation of this link
+      # @option options [String] :type
+      #   Override the auto-generated mime type
+      # @option options [String] :title
+      #   Specify the title of the link, defaults to the type
+      #
+      # @return [String] Feed link html tag with specified +options+.
+      #
+      # @example
+      #   feed_tag :atom, url(:blog, :posts, :format => :atom), :title => "ATOM"
+      #   # Generates: <link type="application/atom+xml" rel="alternate" href="/blog/posts.atom" title="ATOM" />
+      #   feed_tag :rss, url(:blog, :posts, :format => :rss)
+      #   # Generates: <link type="application/rss+xml" rel="alternate" href="/blog/posts.rss" title="rss" />
+      #
+      # @api public
+      def feed_tag(mime, url, options={})
+        full_mime = (mime == :atom) ? 'application/atom+xml' : 'application/rss+xml'
+        content_tag(:link, options.reverse_merge(:rel => 'alternate', :type => full_mime, :title => mime, :href => url))
+      end
+      ##
+      # Creates a mail link element with given name and caption.
+      #
+      # @param [String] email
+      #   The email address for the link.
+      # @param [String] caption
+      #   The caption for the link.
+      # @param [Hash] mail_options
+      #   The options for the mail link. Accepts html options.
+      # @option mail_options [String] cc      The cc recipients.
+      # @option mail_options [String] bcc     The bcc recipients.
+      # @option mail_options [String] subject The subject line.
+      # @option mail_options [String] body    The email body.
+      #
+      # @return [String] Mail link html tag with specified +options+.
+      #
+      # @example
+      #   # Generates: <a href="mailto:me@demo.com">me@demo.com</a>
+      #   mail_to "me@demo.com"
+      #   # Generates: <a href="mailto:me@demo.com">My Email</a>
+      #   mail_to "me@demo.com", "My Email"
+      #
+      # @api public
+      def mail_to(email, caption=nil, mail_options={})
+        html_options = mail_options.slice!(:cc, :bcc, :subject, :body)
+        mail_query = Rack::Utils.build_query(mail_options).gsub(/\+/, '%20').gsub('%40', '@')
+        mail_href = "mailto:#{email}"; mail_href << "?#{mail_query}" if mail_query.present?
+        link_to((caption || email), mail_href, html_options)
+      end
+      ##
+      # Creates a meta element with the content and given options.
+      #
+      # @param [String] content
+      #   The content for the meta tag.
+      # @param [Hash] options
+      #   The html options for the meta tag.
+      #
+      # @return [String] Meta html tag with specified +options+.
+      #
+      # @example
+      #   # Generates: <meta name="keywords" content="weblog,news">
+      #   meta_tag "weblog,news", :name => "keywords"
+      #
+      #   # Generates: <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+      #   meta_tag "text/html; charset=UTF-8", 'http-equiv' => "Content-Type"
+      #
+      # @api public
+      def meta_tag(content, options={})
+        options.reverse_merge!("content" => content)
+        tag(:meta, options)
+      end
+      ##
+      # Generates a favicon link. looks inside images folder
+      #
+      # @param [String] source
+      #   The source image path for the favicon link tag.
+      # @param [Hash] options
+      #   The html options for the favicon link tag.
+      #
+      # @return [String] The favicon link html tag with specified +options+.
+      #
+      # @example
+      #   favicon_tag 'favicon.png'
+      #   favicon_tag 'icons/favicon.png'
+      #   # or override some options
+      #   favicon_tag 'favicon.png', :type => 'image/ico'
+      #
+      # @api public
+      def favicon_tag(source, options={})
+        type = File.extname(source).gsub('.','')
+        options = options.dup.reverse_merge!(:href => image_path(source), :rel => 'icon', :type => "image/#{type}")
+        tag(:link, options)
+      end
+      ##
+      # Creates an image element with given url and options
+      #
+      # @param [String] url
+      #   The source path for the image tag.
+      # @param [Hash] options
+      #   The html options for the image tag.
+      #
+      # @return [String] Image html tag with +url+ and specified +options+.
+      #
+      # @example
+      #   image_tag('icons/avatar.png')
+      #
+      # @api public
+      def image_tag(url, options={})
+        options.reverse_merge!(:src => image_path(url))
+        tag(:img, options)
+      end
+      ##
+      # Returns an html script tag for each of the sources provided.
+      # You can pass in the filename without extension or a symbol and we search it in your +appname.public_folder+
+      # like app/public/stylesheets for inclusion. You can provide also a full path.
+      #
+      # @overload stylesheet_link_tag(*sources, options={})
+      #   @param [Array<String>] sources   Splat of css source paths
+      #   @param [Hash]          options   The html options for the link tag
+      #
+      # @return [String] Stylesheet link html tag for +sources+ with specified +options+.
+      #
+      # @example
+      #   stylesheet_link_tag 'style', 'application', 'layout'
+      #
+      # @api public
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.symbolize_keys
+        options.reverse_merge!(:media => 'screen', :rel => 'stylesheet', :type => 'text/css')
+        sources.flatten.map { |source|
+          tag(:link, options.reverse_merge(:href => asset_path(:css, source)))
+        }.join("\n")
+      end
+      ##
+      # Returns an html script tag for each of the sources provided.
+      # You can pass in the filename without extension or a symbol and we search it in your +appname.public_folder+
+      # like app/public/javascript for inclusion. You can provide also a full path.
+      #
+      # @overload javascript_include_tag(*sources, options={})
+      #   @param [Array<String>] sources   Splat of js source paths
+      #   @param [Hash]          options   The html options for the script tag
+      #
+      # @return [String] Script tag for +sources+ with specified +options+.
+      #
+      # @example
+      #   javascript_include_tag 'application', :extjs
+      #
+      # @api public
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.symbolize_keys
+        options.reverse_merge!(:type => 'text/javascript', :content => "")
+        sources.flatten.map { |source|
+          tag(:script, options.reverse_merge(:src => asset_path(:js, source)))
+        }.join("\n")
+      end
+      ##
+      # Returns the path to the image, either relative or absolute. We search it in your +appname.public_folder+
+      # like app/public/images for inclusion. You can provide also a full path.
+      #
+      # @param [String] src
+      #   The path to the image file (relative or absolute)
+      #
+      # @return [String] Path to an image given the +kind+ and +source+.
+      #
+      # @example
+      #   # Generates: /images/foo.jpg?1269008689
+      #   image_path("foo.jpg")
+      #
+      # @api public
+      def image_path(src)
+        asset_path(:images, src)
+      end
+      ##
+      # Returns the path to the specified asset (css or javascript)
+      #
+      # @param [String] kind
+      #   The kind of asset (i.e :images, :js, :css)
+      # @param [String] source
+      #   The path to the asset (relative or absolute).
+      #
+      # @return [String] Path for the asset given the +kind+ and +source+.
+      #
+      # @example
+      #   # Generates: /javascripts/application.js?1269008689
+      #   asset_path :js, :application
+      #
+      #   # Generates: /stylesheets/application.css?1269008689
+      #   asset_path :css, :application
+      #
+      #   # Generates: /images/example.jpg?1269008689
+      #   asset_path :images, 'example.jpg'
+      #
+      # @api semipublic
+      def asset_path(kind, source)
+        return source if source =~ /^http/
+        asset_folder  = case kind
+          when :css then 'stylesheets'
+          when :js  then 'javascripts'
+          else kind.to_s
+        end
+        source = source.to_s.gsub(/\s/, '%20')
+        ignore_extension = (asset_folder.to_s == kind.to_s) # don't append extension
+        source << ".#{kind}" unless ignore_extension or source =~ /\.#{kind}/
+        result_path   = source if source =~ %r{^/} # absolute path
+        result_path ||= uri_root_path(asset_folder, source)
+        timestamp = asset_timestamp(result_path)
+        "#{result_path}#{timestamp}"
+      end
+      private
+        ##
+        # Returns the uri root of the application.
+        #
+        # @example
+        #   uri_root_path("/some/path") => "/base/some/path"
+        #
+        def uri_root_path(*paths)
+          root_uri = self.class.uri_root if self.class.respond_to?(:uri_root)
+          File.join(ENV['RACK_BASE_URI'].to_s, root_uri || '/', *paths)
+        end
+        ##
+        # Returns the timestamp mtime for an asset
+        #
+        # @example
+        #   asset_timestamp("some/path/to/file.png") => "?154543678"
+        #
+        def asset_timestamp(file_path)
+          return nil if file_path =~ /\?/ || (self.class.respond_to?(:asset_stamp) && !self.class.asset_stamp)
+          public_path = Padrino.root("public", file_path) if Padrino.respond_to?(:root)
+          stamp = Time.now.to_i unless public_path && File.exist?(public_path)
+          stamp ||= File.mtime(public_path).to_i
+          "?#{stamp}"
+        end
+        ##
+        # Parses link_to options for given correct conditions
+        #
+        # @example
+        #   parse_conditions("/some/url", :if => false) => true
+        #
+        def parse_conditions(url, options)
+          if options.has_key?(:if)
+            condition = options.delete(:if)
+            condition == :current ? url == request.path_info : condition
+          elsif condition = options.delete(:unless)
+            condition == :current ? url != request.path_info : !condition
+          else
+            true
+          end
+        end
+        ##
+        # Parses link_to options for given js declarations (remote, method, confirm)
+        # Not destructive on options; returns updated options
+        #
+        # parse_js_attributes(:remote => true, :confirm => "test", :method => :delete)
+        # => { "data-remote" => true, "data-method" => "delete", "data-confirm" => "test" }
+        #
+        def parse_js_attributes(options)
+          options = options.dup
+          options["data-remote"] = "true" if options.delete(:remote)
+          if link_confirm = options.delete(:confirm)
+            options["data-confirm"] = link_confirm
+          end
+          if link_method = options.delete(:method)
+            options["data-method"] = link_method
+            options["rel"] = "nofollow"
+          end
+          options
+        end
+    end # AssetTagHelpers
+  end # Helpers
+end # Padrino