RubyGems - middleman - Versions diffs - 2.0.4 → 2.0.5 - Mend

middleman 2.0.4 → 2.0.5

Files changed (172) hide show

data/lib/middleman/vendor/padrino-helpers-0.10.0/.document ADDED Viewed

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

data/lib/middleman/vendor/padrino-helpers-0.10.0/.gitignore ADDED Viewed

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

data/lib/middleman/vendor/padrino-helpers-0.10.0/LICENSE ADDED Viewed

@@ -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/vendor/padrino-helpers-0.10.0/README.rdoc ADDED Viewed

@@ -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.
+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>relative_time_ago</tt>, <tt>time_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/vendor/padrino-helpers-0.10.0/Rakefile ADDED Viewed

@@ -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/vendor/padrino-helpers-0.10.0/lib/padrino-helpers.rb ADDED Viewed

@@ -0,0 +1,51 @@
+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 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.
+  #
+  module Helpers
+    ##
+    # Register these helpers:
+    #
+    #   Padrino::Helpers::OutputHelpers
+    #   Padrino::Helpers::TagHelpers
+    #   Padrino::Helpers::AssetTagHelpers
+    #   Padrino::Helpers::FormHelpers
+    #   Padrino::Helpers::FormatHelpers
+    #   Padrino::Helpers::RenderHelpers
+    #   Padrino::Helpers::NumberHelpers
+    #
+    # for Padrino::Application
+    #
+    class << self
+      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/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/asset_tag_helpers.rb ADDED Viewed

@@ -0,0 +1,288 @@
+module Padrino
+  module Helpers
+    module AssetTagHelpers
+      ##
+      # Creates a div to display the flash of given type if it exists
+      #
+      # ==== Examples
+      #   # Generates: <div class="notice">flash-notice</div>
+      #   flash_tag(:notice, :id => 'flash-notice')
+      #
+      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
+      #
+      # ==== Examples
+      #
+      #   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
+      #
+      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.
+      #
+      # ==== Examples
+      #
+      #   # Generates:
+      #   # <form class="form" action="/admin/accounts/destroy/2" method="post">
+      #   #   <input type="hidden" value="delete" name="_method" />
+      #   #   <input type="submit" value="Delete" />
+      #   # </form>
+      #   button_to 'Delete', url(:accounts_destroy, :id => account), :method => :delete, :class => :form
+      #
+      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.
+      #
+      # === Options
+      #
+      #   :rel::   Specify the relation of this link, defaults to "alternate"
+      #   :type::  Override the auto-generated mime type
+      #   :title:: Specify the title of the link, defaults to the type
+      #
+      # === Examples
+      #
+      #   # Generates: <link type="application/atom+xml" rel="alternate" href="/blog/posts.atom" title="ATOM" />
+      #   feed_tag :atom, url(:blog, :posts, :format => :atom), :title => "ATOM"
+      #   # Generates: <link type="application/rss+xml" rel="alternate" href="/blog/posts.rss" title="rss" />
+      #   feed_tag :rss, url(:blog, :posts, :format => :rss)
+      #
+      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
+      #
+      # ==== Examples
+      #
+      #   # 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"
+      #
+      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
+      #
+      # ==== Examples
+      #
+      #   # 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"
+      #
+      def meta_tag(content, options={})
+        options.reverse_merge!("content" => content)
+        tag(:meta, options)
+      end
+      ##
+      # Generates a favicon link. looks inside images folder
+      #
+      # ==== Examples
+      #
+      #   favicon_tag 'favicon.png'
+      #   favicon_tag 'icons/favicon.png'
+      #   # or override some options
+      #   favicon_tag 'favicon.png', :type => 'image/ico'
+      #
+      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
+      #
+      # ==== Examples
+      #
+      #   image_tag('icons/avatar.png')
+      #
+      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+
+      # like app/public/stylesheets for inclusion. You can provide also a full path.
+      #
+      # ==== Examples
+      #
+      #   stylesheet_link_tag 'style', 'application', 'layout'
+      #
+      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+
+      # like app/public/javascript for inclusion. You can provide also a full path.
+      #
+      # ==== Examples
+      #
+      #   javascript_include_tag 'application', :extjs
+      #
+      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+
+      # like app/public/images for inclusion. You can provide also a full path.
+      #
+      # ==== Examples
+      #
+      #   # Generates: /images/foo.jpg?1269008689
+      #   image_path("foo.jpg")
+      #
+      def image_path(src)
+        asset_path(:images, src)
+      end
+      ##
+      # Returns the path to the specified asset (css or javascript)
+      #
+      # ==== Examples
+      #
+      #   # 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'
+      #
+      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.
+        #
+        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
+        #
+        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
+        #
+        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
+        #
+        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