padrino-helpers 0.12.0 → 0.12.1

data/lib/padrino-helpers/form_helpers/errors.rb

@@ -0,0 +1,138 @@
+module Padrino
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate form errors.
+      #
+      module Errors
+        ##
+        # Constructs list HTML for the errors for a given symbol.
+        #
+        # @overload error_messages_for(*objects, options = {})
+        #   @param [Array<Object>]  object   Splat of objects to display errors for.
+        #   @param [Hash]           options  Error message display options.
+        #   @option options [String] :header_tag ("h2")
+        #     Used for the header of the error div.
+        #   @option options [String] :id ("field-errors")
+        #     The id of the error div.
+        #   @option options [String] :class ("field-errors")
+        #     The class of the error div.
+        #   @option options [Array<Object>]  :object
+        #     The object (or array of objects) for which to display errors,
+        #     if you need to escape the instance variable convention.
+        #   @option options [String] :object_name
+        #     The object name to use in the header, or any text that you prefer.
+        #     If +:object_name+ is not set, the name of the first object will be used.
+        #   @option options [String] :header_message ("X errors prohibited this object from being saved")
+        #     The message in the header of the error div. Pass +nil+ or an empty string
+        #     to avoid the header message altogether.
+        #   @option options [String] :message ("There were problems with the following fields:")
+        #     The explanation message after the header message and before
+        #     the error list.  Pass +nil+ or an empty string to avoid the explanation message
+        #     altogether.
+        #
+        # @return [String] The html section with all errors for the specified +objects+
+        #
+        # @example
+        #   error_messages_for :user
+        #
+        def error_messages_for(*objects)
+          options = objects.extract_options!.symbolize_keys
+          objects = objects.map{ |obj| resolve_object(obj) }.compact
+          count   = objects.inject(0){ |sum, object| sum + object.errors.count }
+          return ActiveSupport::SafeBuffer.new if count.zero?
+
+          content_tag(:div, error_contents(objects, count, options), error_html_attributes(options))
+        end
+
+        ##
+        # Returns a string containing the error message attached to the
+        # +method+ on the +object+ if one exists.
+        #
+        # @param [Object] object
+        #   The object to display the error for.
+        # @param [Symbol] field
+        #   The field on the +object+ to display the error for.
+        # @param [Hash] options
+        #   The options to control the error display.
+        # @option options [String] :tag ("span")
+        #   The tag that encloses the error.
+        # @option options [String] :prepend ("")
+        #   The text to prepend before the field error.
+        # @option options [String] :append ("")
+        #   The text to append after the field error.
+        #
+        # @example
+        #   # => <span class="error">can't be blank</div>
+        #   error_message_on :post, :title
+        #   error_message_on @post, :title
+        #
+        #   # => <div class="custom" style="border:1px solid red">can't be blank</div>
+        #   error_message_on :post, :title, :tag => :id, :class => :custom, :style => "border:1px solid red"
+        #
+        #   # => <div class="error">This title can't be blank (or it won't work)</div>
+        #   error_message_on :post, :title, :prepend => "This title", :append => "(or it won't work)"
+        #
+        # @return [String] The html display of an error for a particular +object+ and +field+.
+        #
+        # @api public
+        def error_message_on(object, field, options={})
+          error = Array(resolve_object(object).errors[field]).first
+          return ActiveSupport::SafeBuffer.new unless error
+          options = { :tag => :span, :class => :error }.update(options)
+          tag   = options.delete(:tag)
+          error = [options.delete(:prepend), error, options.delete(:append)].compact.join(" ")
+          content_tag(tag, error, options)
+        end
+
+        private
+
+        def error_contents(objects, count, options)
+          object_name = options[:object_name] || objects.first.class.to_s.underscore.gsub(/\//, ' ')
+
+          contents = ActiveSupport::SafeBuffer.new
+          contents << error_header_tag(options, object_name, count)
+          contents << error_body_tag(options)
+          contents << error_list_tag(objects, object_name)
+        end
+
+        def error_list_tag(objects, object_name)
+          errors = objects.inject({}){ |all,object| all.update(object.errors) }
+          error_messages = errors.inject(ActiveSupport::SafeBuffer.new) do |all, (field, message)|
+            field_name = I18n.t(field, :default => field.to_s.humanize, :scope => [:models, object_name, :attributes])
+            all << content_tag(:li, "#{field_name} #{message}")
+          end
+          content_tag(:ul, error_messages)
+        end
+
+        def error_header_tag(options, object_name, count)
+          header_message = options[:header_message] || begin
+            model_name = I18n.t(:name, :default => object_name.humanize, :scope => [:models, object_name], :count => 1)
+            I18n.t :header, :count => count, :model => model_name, :locale => options[:locale], :scope => [:models, :errors, :template]
+          end
+          content_tag(options[:header_tag] || :h2, header_message) if header_message.present?
+        end
+
+        def error_body_tag(options)
+          body_message = options[:message] || I18n.t(:body, :locale => options[:locale], :scope => [:models, :errors, :template])
+          content_tag(:p, body_message) if body_message.present?
+        end
+
+        def error_html_attributes(options)
+          [:id, :class, :style].each_with_object({}) do |key,all|
+            if options.include?(key)
+              value = options[key]
+              all[key] = value unless value.blank?
+            else
+              all[key] = 'field-errors' unless key == :style
+            end
+          end
+        end
+
+        def resolve_object(object)
+          object.is_a?(Symbol) ? instance_variable_get("@#{object}") : object
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_helpers/options.rb

@@ -0,0 +1,97 @@
+module Padrino
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate options list for select tag.
+      #
+      module Options
+        def extract_option_tags!(options)
+          state = extract_option_state!(options)
+          option_tags = if options[:grouped_options]
+            grouped_options_for_select(options.delete(:grouped_options), state)
+          else
+            options_for_select(extract_option_items!(options), state)
+          end
+          if prompt = options[:include_blank]
+            option_tags.unshift(blank_option(prompt))
+          end
+          option_tags
+        end
+
+        private
+
+        ##
+        # Returns the blank option serving as a prompt if passed.
+        #
+        def blank_option(prompt)
+          case prompt
+          when nil, false
+            nil
+          when String
+            content_tag(:option, prompt,       :value => '')
+          when Array
+            content_tag(:option, prompt.first, :value => prompt.last)
+          else
+            content_tag(:option, '',           :value => '')
+          end
+        end
+
+        ##
+        # Returns whether the option should be selected or not.
+        #
+        # @example
+        #   option_is_selected?("red", "Red", ["red", "blue"])   => true
+        #   option_is_selected?("red", "Red", ["green", "blue"]) => false
+        #
+        def option_is_selected?(value, caption, selected_values)
+          Array(selected_values).any? do |selected|
+            [value.to_s, caption.to_s].include?(selected.to_s)
+          end
+        end
+
+        ##
+        # Returns the options tags for a select based on the given option items.
+        #
+        def options_for_select(option_items, state = {})
+          return [] if option_items.blank?
+          option_items.map do |caption, value, attributes|
+            html_attributes = { :value => value || caption  }.merge(attributes||{})
+            html_attributes[:selected] ||= option_is_selected?(value, caption, state[:selected])
+            html_attributes[:disabled] ||= option_is_selected?(value, caption, state[:disabled])
+            content_tag(:option, caption, html_attributes)
+          end
+        end
+
+        ##
+        # Returns the optgroups with options tags for a select based on the given :grouped_options items.
+        #
+        def grouped_options_for_select(collection, state = {})
+          collection.map do |item|
+            caption = item.shift
+            attributes = item.last.kind_of?(Hash) ? item.pop : {}
+            value = item.flatten(1)
+            attributes = value.pop if value.last.kind_of?(Hash)
+            html_attributes = { :label => caption }.merge(attributes||{})
+            content_tag(:optgroup, options_for_select(value, state), html_attributes)
+          end
+        end
+
+        def extract_option_state!(options)
+          {
+            :selected => Array(options.delete(:value))|Array(options.delete(:selected))|Array(options.delete(:selected_options)),
+            :disabled => Array(options.delete(:disabled_options))
+          }
+        end
+
+        def extract_option_items!(options)
+          if options[:collection]
+            collection, fields = options.delete(:collection), options.delete(:fields)
+            collection.map{ |item| [ item.send(fields.first), item.send(fields.last) ] }
+          else
+            options.delete(:options) || []
+          end        
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_helpers/security.rb

@@ -0,0 +1,70 @@
+require 'securerandom'
+
+module Padrino
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate form security tags for csrf protection.
+      #
+      module Security
+        ##
+        # Constructs a hidden field containing a CSRF token.
+        #
+        # @param [String] token
+        #   The token to use. Will be read from the session by default.
+        #
+        # @return [String] The hidden field with CSRF token as value.
+        #
+        # @example
+        #   csrf_token_field
+        #
+        def csrf_token_field
+          hidden_field_tag csrf_param, :value => csrf_token
+        end
+
+        ##
+        # Constructs meta tags `csrf-param` and `csrf-token` with the name of the
+        # cross-site request forgery protection parameter and token, respectively.
+        #
+        # @return [String] The meta tags with the CSRF token and the param your app expects it in.
+        #
+        # @example
+        #   csrf_meta_tags
+        #
+        def csrf_meta_tags
+          if is_protected_from_csrf?
+            meta_tag(csrf_param, :name => 'csrf-param') <<
+            meta_tag(csrf_token, :name => 'csrf-token')
+          end
+        end
+
+        protected
+
+        ##
+        # Returns whether the application is being protected from CSRF. Defaults to true.
+        #
+        def is_protected_from_csrf?
+          defined?(settings) ? settings.protect_from_csrf : true
+        end
+
+        ##
+        # Returns the current CSRF token (based on the session). If it doesn't exist,
+        # it will create one and assign it to the session's `csrf` key.
+        #
+        def csrf_token
+          session[:csrf] ||= SecureRandom.hex(32) if defined?(session)
+        end
+
+        ##
+        # Returns the param/field name in which your CSRF token should be expected by your
+        # controllers. Defaults to `authenticity_token`.
+        #
+        # Set this in your application with `set :csrf_param, :something_else`.
+        #
+        def csrf_param
+          defined?(settings) && settings.respond_to?(:csrf_param) ? settings.csrf_param : :authenticity_token
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers.rb

@@ -175,7 +175,7 @@ module Padrino
       def yield_content(key, *args)
         blocks = content_blocks[key.to_sym]
         return nil if blocks.empty?
-        mark_safe(blocks.map { |content| capture_html(*args, &content) }.join)
+        blocks.inject(ActiveSupport::SafeBuffer.new){ |all,content| all << capture_html(*args, &content) }
       end
 
       protected

data/lib/padrino-helpers/output_helpers/abstract_handler.rb

@@ -33,7 +33,7 @@ module Padrino
           raw = block.call(*args)
           captured = template.instance_variable_get(:@_out_buf)
           self.output_buffer = _buf_was
-          engine_matches?(block) ? captured : raw
+          engine_matches?(block) && !captured.empty? ? captured : raw.to_s
         end
 
         ##

data/lib/padrino-helpers/render_helpers.rb

@@ -31,12 +31,12 @@ module Padrino
       # @note If using this from Sinatra, pass explicit +:engine+ option
       #
       def partial(template, options={}, &block)
-        options = options.reverse_merge(:locals => {}, :layout => false)
+        options = { :locals => {}, :layout => false }.update(options)
         explicit_engine = options.delete(:engine)
 
         path,_,name = template.to_s.rpartition(File::SEPARATOR)
         template_path = File.join(path,"_#{name}").to_sym
-        object_name = name.to_sym
+        object_name = name.partition('.').first.to_sym
 
         objects, counter = if options[:collection].respond_to?(:inject)
           [options.delete(:collection), 0]
@@ -45,15 +45,16 @@ module Padrino
         end
 
         locals = options[:locals]
-        objects.inject(''.html_safe) do |html,object|
+        objects.each_with_object(ActiveSupport::SafeBuffer.new) do |object,html|
           locals[object_name] = object if object
           locals["#{object_name}_counter".to_sym] = counter += 1 if counter
-          if block_given?
-            output = render(explicit_engine, template_path, options){ capture_html(&block) }.html_safe
-            html << (block_is_template?(block) ? concat_content(output) : output)
-          else
-            html << render(explicit_engine, template_path, options).html_safe
-          end
+          content =
+            if block_given?
+              concat_content render(explicit_engine, template_path, options){ capture_html(&block) }
+            else
+              render(explicit_engine, template_path, options)
+            end
+          html.safe_concat content if content
         end
       end
       alias :render_partial :partial

data/lib/padrino-helpers/tag_helpers.rb

@@ -127,7 +127,7 @@ module Padrino
         output = ActiveSupport::SafeBuffer.new
         output.safe_concat "<#{name}#{attributes}>"
         if content.respond_to?(:each) && !content.is_a?(String)
-          content.each { |c| output.concat c; output.safe_concat NEWLINE }
+          content.each{ |item| output.concat item; output.safe_concat NEWLINE }
         else
           output.concat content.to_s
         end
@@ -236,6 +236,7 @@ module Padrino
       end
 
       private
+
       ##
       # Returns a compiled list of HTML attributes.
       #

data/lib/padrino/rendering.rb

@@ -0,0 +1,378 @@
+require 'padrino-support'
+require 'pathname'
+
+module Padrino
+  ##
+  # Padrino enhances the Sinatra 'render' method to have support for
+  # automatic template engine detection, enhanced layout functionality,
+  # locale enabled rendering, among other features.
+  #
+  module Rendering
+    ##
+    # A SafeTemplate assumes that its output is safe.
+    #
+    module SafeTemplate
+      def render(*)
+        super.html_safe
+      end
+    end
+
+    ##
+    # Exception responsible for when an expected template did not exist.
+    #
+    class TemplateNotFound < RuntimeError
+    end
+
+    ##
+    # This is an array of file patterns to ignore. If your editor add a
+    # suffix during editing to your files please add it like:
+    #
+    # @example
+    #   Padrino::Rendering::IGNORE_FILE_PATTERN << /~$/
+    #
+    IGNORE_FILE_PATTERN = [
+      /~$/ # This is for Gedit
+    ] unless defined?(IGNORE_FILE_PATTERN)
+
+    ##
+    # Default options used in the resolve_template-method.
+    #
+    DEFAULT_RENDERING_OPTIONS = { :strict_format => false, :raise_exceptions => true } unless defined?(DEFAULT_RENDERING_OPTIONS)
+
+    class << self
+      ##
+      # Default engine configurations for Padrino::Rendering.
+      #
+      # @return {Hash<Symbol,Hash>}
+      #   The configurations, keyed by engine.
+      def engine_configurations
+        @engine_configurations ||= {}
+      end
+
+      def registered(app)
+        if defined?(Padrino::Application) && app == Padrino::Application
+          # this fail can be removed later when jRuby is not bugged and MRI19 is dropped
+          fail 'Please, do not use `register` on Padrino::Application object, use `.dup` or subclassing'
+        end
+        included(app)
+        engine_configurations.each do |engine, configs|
+          app.set engine, configs
+        end
+      end
+
+      def included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+      end
+    end
+
+    ##
+    # Class methods responsible for rendering templates as part of a request.
+    #
+    module ClassMethods
+      ##
+      # Use layout like rails does or if a block given then like sinatra.
+      # If used without a block, sets the current layout for the route.
+      #
+      # By default, searches in your:
+      #
+      # +app+/+views+/+layouts+/+application+.(+haml+|+erb+|+xxx+)
+      # +app+/+views+/+layout_name+.(+haml+|+erb+|+xxx+)
+      #
+      # If you define +layout+ :+custom+ then searches for your layouts in
+      # +app+/+views+/+layouts+/+custom+.(+haml+|+erb+|+xxx+)
+      # +app+/+views+/+custom+.(+haml+|+erb+|+xxx+)
+      #
+      # @param [Symbol] name (:layout)
+      #   The layout to use.
+      #
+      # @yield []
+      #
+      def layout(name=:layout, &block)
+        return super(name, &block) if block_given?
+        @layout = name
+      end
+
+      ##
+      # Returns the cached template file to render for a given url,
+      # content_type and locale. Deprecated since 0.12.1
+      #
+      # @param [Array<template_path, content_type, locale>] render_options
+      #
+      def fetch_template_file(render_options)
+        logger.warn "##{__method__} is deprecated"
+        (@_cached_templates ||= {})[render_options]
+      end
+
+      ##
+      # Caches the template file for the given rendering options. Deprecated since 0.12.1
+      #
+      # @param [String] template_file
+      #   The path of the template file.
+      #
+      # @param [Array<template_path, content_type, locale>] render_options
+      #
+      def cache_template_file!(template_file, render_options)
+        logger.warn "##{__method__} is deprecated"
+        (@_cached_templates ||= {})[render_options] = template_file || []
+      end
+
+      ##
+      # Returns the cached layout path.
+      #
+      # @param [String, nil] given_layout
+      #   The requested layout.
+      # @param [String, nil] layouts_path
+      #   The directory where the layouts are located. Defaults to #views.
+      #
+      def fetch_layout_path(given_layout, layouts_path=views)
+        layout_name = (given_layout || @layout || :application).to_s
+        cache_layout_path(layout_name) do
+          if Pathname.new(layout_name).absolute? && Dir["#{layout_name}.*"].any? || Dir["#{layouts_path}/#{layout_name}.*"].any?
+            layout_name
+          else
+            File.join('layouts', layout_name)
+          end
+        end
+      end
+
+      def cache_layout_path(name)
+        @_cached_layout ||= {}
+        if !reload_templates? && path = @_cached_layout[name]
+          path
+        else
+          @_cached_layout[name] = yield(name)
+        end
+      end
+
+      def cache_template_path(options)
+        began_at = Time.now
+        @_cached_templates ||= {}
+        logging = defined?(settings) && settings.logging? && defined?(logger)
+        if !reload_templates? && path = @_cached_templates[options]
+          logger.debug :cached, began_at, path[0] if logging
+        else
+          path = @_cached_templates[options] = yield(name)
+          logger.debug :template, began_at, path[0] if path && logging
+        end
+        path
+      end
+    end
+
+    # Instance methods that allow enhanced rendering to function properly in Padrino.
+    module InstanceMethods
+      attr_reader :current_engine
+
+      ##
+      # Get/Set the content_type
+      #
+      # @param [String, nil] type
+      #   The Content-Type to use.
+      #
+      # @param [Symbol, nil] type.
+      #   Look and parse the given symbol to the matched Content-Type.
+      #
+      # @param [Hash] params
+      #   Additional params to append to the Content-Type.
+      #
+      # @example
+      #   case content_type
+      #     when :js then do_some
+      #     when :css then do_another
+      #   end
+      #
+      #   content_type :js
+      #   # => set the response with 'application/javascript' Content-Type
+      #   content_type 'text/html'
+      #
+      #   # => set directly the Content-Type to 'text/html'
+      #
+      def content_type(type=nil, params={})
+        if type
+          super(type, params)
+          @_content_type = type
+        end
+        @_content_type
+      end
+
+      private
+
+      ##
+      # Enhancing Sinatra render functionality for:
+      #
+      # * Using layout similar to rails
+      # * Use render 'path/to/my/template'   (without symbols)
+      # * Use render 'path/to/my/template'   (with engine lookup)
+      # * Use render 'path/to/template.haml' (with explicit engine lookup)
+      # * Use render 'path/to/template', :layout => false
+      # * Use render 'path/to/template', :layout => false, :engine => 'haml'
+      #
+      def render(engine, data=nil, options={}, locals={}, &block)
+        # If engine is nil, ignore engine parameter and shift up all arguments
+        # render nil, "index", { :layout => true }, { :localvar => "foo" }
+        engine, data, options = data, options, locals if engine.nil? && data
+
+        # Data is a hash of options when no engine isn't explicit
+        # render "index", { :layout => true }, { :localvar => "foo" }
+        # Data is options, and options is locals in this case
+        data, options, locals = nil, data, options if data.is_a?(Hash)
+
+        # If data is unassigned then this is a likely a template to be resolved
+        # This means that no engine was explicitly defined
+        data, engine = resolve_template(engine, options) if data.nil?
+
+        # Cleanup the template.
+        @current_engine, engine_was = engine, @current_engine
+        @_out_buf,  buf_was = ActiveSupport::SafeBuffer.new, @_out_buf
+
+        # Pass arguments to Sinatra render method.
+        super(engine, data, with_layout(options), locals, &block)
+      ensure
+        @current_engine = engine_was
+        @_out_buf = buf_was
+      end
+
+      ##
+      # Returns the located layout tuple to be used for the rendered template
+      # (if available). Deprecated since 0.12.1
+      #
+      # @example
+      #   resolve_layout
+      #   # => ["/layouts/custom", :erb]
+      #   # => [nil, nil]
+      #
+      def resolved_layout
+        logger.warn "##{__method__} is deprecated"
+        resolve_template(settings.fetch_layout_path, :raise_exceptions => false, :strict_format => true) || [nil, nil]
+      end
+
+      ##
+      # Returns the template path and engine that match content_type (if present),
+      # I18n.locale.
+      #
+      # @param [String] template_path
+      #   The path of the template.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @option options [Boolean] :strict_format (false)
+      #   The resolved template must match the content_type of the request.
+      #
+      # @option options [Boolean] :raise_exceptions (false)
+      #   Raises a {TemplateNotFound} exception if the template cannot be located.
+      #
+      # @return [Array<Symbol, Symbol>]
+      #   The path and format of the template.
+      #
+      # @raise [TemplateNotFound]
+      #   The template could not be found.
+      #
+      # @example
+      #   get "/foo", :provides => [:html, :js] do; render 'path/to/foo'; end
+      #   # If you request "/foo.js" with I18n.locale == :ru => [:"/path/to/foo.ru.js", :erb]
+      #   # If you request "/foo" with I18n.locale == :de => [:"/path/to/foo.de.haml", :haml]
+      #
+      def resolve_template(template_path, options={})
+        template_path = template_path.to_s
+        controller_key = respond_to?(:request) && request.respond_to?(:controller) && request.controller
+        rendering_options = [template_path, content_type || :html, locale]
+
+        settings.cache_template_path(["#{controller_key}/#{template_path}", rendering_options[1], rendering_options[2]]) do
+          options = DEFAULT_RENDERING_OPTIONS.merge(options)
+          view_path = options[:views] || settings.views || "./views"
+
+          template_candidates = glob_templates(view_path, template_path)
+          selected_template = select_template(template_candidates, *rendering_options)
+          selected_template ||= template_candidates.first unless options[:strict_format]
+
+          fail TemplateNotFound, "Template '#{template_path}' not found in '#{view_path}'"  if !selected_template && options[:raise_exceptions]
+          selected_template
+        end
+      end
+
+      ##
+      # Return the I18n.locale if I18n is defined.
+      #
+      def locale
+        I18n.locale if defined?(I18n)
+      end
+
+      LAYOUT_EXTENSIONS = %w[.slim .erb .haml].freeze
+
+      def resolve_layout(layout, options={})
+        layouts_path = options[:layout_options] && options[:layout_options][:views] || options[:views] || settings.views || "./views"
+        template_path = settings.fetch_layout_path(layout, layouts_path)
+        rendering_options = [template_path, content_type || :html, locale]
+
+        layout, engine =
+          settings.cache_template_path(rendering_options) do
+            template_candidates = glob_templates(layouts_path, template_path)
+            selected_template = select_template(template_candidates, *rendering_options)
+
+            fail TemplateNotFound, "Layout '#{template_path}' not found in '#{layouts_path}'" if !selected_template && layout.present?
+            selected_template
+          end
+
+        is_included_extension = LAYOUT_EXTENSIONS.include?(File.extname(template_path.to_s))
+        layout = false unless is_included_extension ? engine : engine == @current_engine
+
+        [layout, engine]
+      end
+
+      def with_layout(options)
+        options = options.dup
+        layout = options[:layout]
+        return options if layout == false
+
+        layout = @layout if !layout || layout == true
+        return options if settings.templates.has_key?(:layout) && layout.blank?
+
+        if layout.kind_of?(String) && Pathname.new(layout).absolute?
+          layout_path, _, layout = layout.rpartition('/')
+          options[:layout_options] ||= {}
+          options[:layout_options][:views] ||= layout_path
+        end
+        layout, layout_engine = resolve_layout(layout, options)
+        options.update(:layout => layout, :layout_engine => layout_engine)
+      end
+
+      def glob_templates(views_path, template_path)
+        parts = []
+        parts << views_path if views_path.present?
+        if respond_to?(:request) && request.respond_to?(:controller) && request.controller.present? && Pathname.new(template_path).relative?
+          parts << "{,#{request.controller}}"
+        end
+        parts << template_path.chomp(File.extname(template_path)) + '.*'
+        Dir.glob(File.join(parts)).sort.inject([]) do |all,file|
+          next all if IGNORE_FILE_PATTERN.any?{ |pattern| file.to_s =~ pattern }
+          all << path_and_engine(file, views_path)
+        end
+      end
+
+      def select_template(templates, template_path, content_type, _locale)
+        simple_content_type = [:html, :plain].include?(content_type)
+        target_path, target_engine = path_and_engine(template_path)
+
+        templates.find{ |file,_| file.to_s == "#{target_path}.#{locale}.#{content_type}" } ||
+        templates.find{ |file,_| file.to_s == "#{target_path}.#{locale}" && simple_content_type } ||
+        templates.find{ |file,engine| engine == target_engine || File.extname(file.to_s) == ".#{target_engine}" } ||
+        templates.find{ |file,_| file.to_s == "#{target_path}.#{content_type}" } ||
+        templates.find{ |file,_| file.to_s == "#{target_path}" && simple_content_type }
+      end
+
+      def path_and_engine(path, relative=nil)
+        extname = File.extname(path)
+        engine = (extname[1..-1]||'none').to_sym
+        path = path.chomp(extname)
+        path.insert(0, '/') unless Pathname.new(path).absolute?
+        path = path.squeeze('/').sub(relative, '') if relative
+        [path.to_sym, engine]
+      end
+    end
+  end
+end
+
+require 'padrino/rendering/extensions/haml'
+require 'padrino/rendering/extensions/erubis'
+require 'padrino/rendering/extensions/slim'