middleman-core 3.2.0 → 3.2.1

data/lib/vendored-middleman-deps/padrino-core-0.11.2/lib/padrino-core/application/rendering.rb

@@ -1,320 +0,0 @@
-require 'padrino-core/support_lite' unless defined?(SupportLite)
-
-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.
-    #
-    # @api private
-    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
-
-      ##
-      # Main class that register this extension.
-      #
-      def registered(app)
-        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.
-      #
-      # @param [Array<template_path, content_type, locale>] render_options
-      #
-      def fetch_template_file(render_options)
-        (@_cached_templates ||= {})[render_options]
-      end
-
-      ##
-      # Caches the template file for the given rendering options
-      #
-      # @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)
-        (@_cached_templates ||= {})[render_options] = template_file || []
-      end
-
-      ##
-      # Returns the cached layout path.
-      #
-      # @param [Symbol, nil] given_layout
-      #   The requested layout.
-      #
-      def fetch_layout_path(given_layout=nil)
-        layout_name = given_layout || @layout || :application
-        @_cached_layout ||= {}
-        cached_layout_path = @_cached_layout[layout_name]
-        return cached_layout_path if cached_layout_path
-        has_layout_at_root = Dir["#{views}/#{layout_name}.*"].any?
-        layout_path = has_layout_at_root ? layout_name.to_sym : File.join('layouts', layout_name.to_s).to_sym
-        @_cached_layout[layout_name] = layout_path unless reload_templates?
-        layout_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={})
-        unless type.nil?
-          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.dup) if data.nil?
-
-          # Setup root
-          root = settings.respond_to?(:root) ? settings.root : ""
-
-          # Use @layout if it exists
-          layout_was = options[:layout]
-          options[:layout] = @layout if options[:layout].nil? || options[:layout] == true
-          # Resolve layouts similar to in Rails
-          if options[:layout].nil? && !settings.templates.has_key?(:layout)
-            layout_path, layout_engine = *resolved_layout
-            options[:layout] = layout_path || false # We need to force layout false so sinatra don't try to render it
-            options[:layout] = false unless layout_engine == engine # TODO allow different layout engine
-            options[:layout_engine] = layout_engine || engine if options[:layout]
-          elsif options[:layout].present?
-            options[:layout] = settings.fetch_layout_path(options[:layout] || @layout)
-          end
-          # Default to original layout value if none found
-          options[:layout] ||= layout_was
-
-          # 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, options.dup, 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).
-        #
-        # @example
-        #   resolve_layout
-        #   # => ["/layouts/custom", :erb]
-        #   # => [nil, nil]
-        #
-        def resolved_layout
-          located_layout = resolve_template(settings.fetch_layout_path, :raise_exceptions => false, :strict_format => true)
-          located_layout ? located_layout : [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={})
-          began_at = Time.now
-          # Fetch cached template for rendering options
-          template_path = template_path.to_s[0] == ?/ ? template_path.to_s : "/#{template_path}"
-          rendering_options = [template_path, content_type, locale]
-          cached_template = settings.fetch_template_file(rendering_options)
-          if cached_template
-            logger.debug :cached, began_at, cached_template[0] if settings.logging? && defined?(logger)
-            return cached_template
-          end
-
-          # Resolve view path and options
-          options.reverse_merge!(DEFAULT_RENDERING_OPTIONS)
-          view_path = options.delete(:views) || settings.views || "./views"
-          target_extension = File.extname(template_path)[1..-1] || "none" # explicit template extension
-          template_path = template_path.chomp(".#{target_extension}")
-
-          # Generate potential template candidates
-          templates = Dir[File.join(view_path, template_path) + ".*"].map do |file|
-            template_engine = File.extname(file)[1..-1].to_sym # retrieves engine extension
-            template_file   = file.sub(view_path, '').chomp(".#{template_engine}").to_sym # retrieves template filename
-            [template_file, template_engine] unless IGNORE_FILE_PATTERN.any? { |pattern| template_engine.to_s =~ pattern }
-          end
-
-          # Check if we have a simple content type
-          simple_content_type = [:html, :plain].include?(content_type)
-
-          # Resolve final template to render
-          located_template =
-            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}.#{content_type}" } ||
-            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}" && simple_content_type } ||
-            templates.find { |file, e| File.extname(file.to_s) == ".#{target_extension}" or e.to_s == target_extension.to_s } ||
-            templates.find { |file, e| file.to_s == "#{template_path}.#{content_type}" } ||
-            templates.find { |file, e| file.to_s == "#{template_path}" && simple_content_type } ||
-            (!options[:strict_format] && templates.first) # If not strict, fall back to the first located template
-
-          raise TemplateNotFound, "Template '#{template_path}' not found in '#{view_path}'!"  if !located_template && options[:raise_exceptions]
-          settings.cache_template_file!(located_template, rendering_options) unless settings.reload_templates?
-          logger.debug :template, began_at, located_template[0] if located_template && settings.logging? && defined?(logger)
-          located_template
-        end
-
-        ##
-        # Return the I18n.locale if I18n is defined.
-        #
-        def locale
-          I18n.locale if defined?(I18n)
-        end
-    end # InstanceMethods
-  end # Rendering
-end # Padrino
-
-require 'padrino-core/application/rendering/extensions/haml'
-require 'padrino-core/application/rendering/extensions/erubis'
-require 'padrino-core/application/rendering/extensions/slim'

data/lib/vendored-middleman-deps/padrino-core-0.11.2/lib/padrino-core/application/showexceptions.rb

@@ -1,20 +0,0 @@
-module Padrino
-  ##
-  # This module extend Sinatra::ShowExceptions adding Padrino as "Framework".
-  #
-  # @private
-  class ShowExceptions < Sinatra::ShowExceptions
-    private
-      def frame_class(frame)
-        if frame.filename =~ /lib\/sinatra.*\.rb|lib\/padrino.*\.rb/
-          "framework"
-        elsif (defined?(Gem) && frame.filename.include?(Gem.dir)) ||
-              frame.filename =~ /\/bin\/(\w+)$/ ||
-              frame.filename =~ /Ruby\/Gems/
-          "system"
-        else
-          "app"
-        end
-      end
-  end # ShowExceptions
-end # Padrino

data/lib/vendored-middleman-deps/padrino-core-0.11.2/lib/padrino-core/caller.rb

@@ -1,53 +0,0 @@
-module Padrino
-
-  # List of callers in a Padrino application that should be ignored as part of a stack trace.
-  PADRINO_IGNORE_CALLERS = [
-    %r{lib/padrino-.*$},                             # all padrino code
-    %r{/padrino-.*/(lib|bin)},                       # all padrino code
-    %r{/bin/padrino$},                               # all padrino code
-    %r{/sinatra(/(base|main|showexceptions))?\.rb$}, # all sinatra code
-    %r{lib/tilt.*\.rb$},                             # all tilt code
-    %r{lib/rack.*\.rb$},                             # all rack code
-    %r{lib/mongrel.*\.rb$},                          # all mongrel code
-    %r{lib/shotgun.*\.rb$},                          # all shotgun lib
-    %r{bin/shotgun$},                                # shotgun binary
-    %r{\(.*\)},                                      # generated code
-    %r{shoulda/context\.rb$},                        # shoulda hacks
-    %r{mocha/integration},                           # mocha hacks
-    %r{test/unit},                                   # test unit hacks
-    %r{rake_test_loader\.rb},                        # rake hacks
-    %r{custom_require\.rb$},                         # rubygems require hacks
-    %r{active_support},                              # active_support require hacks
-    %r{/thor}                                        # thor require hacks
-  ] unless defined?(PADRINO_IGNORE_CALLERS)
-
-  ##
-  # Add rubinius (and hopefully other VM implementations) ignore patterns ...
-  #
-  PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
-
-  private
-    ##
-    # The filename for the file that is the direct caller (first caller).
-    #
-    # @return [String]
-    #   The file the caller method exists in.
-    #
-    def self.first_caller
-      caller_files.first
-    end
-
-    #
-    # Like +Kernel#caller+ but excluding certain magic entries and without
-    # line / method information; the resulting array contains filenames only.
-    #
-    # @return [Array<String>]
-    #   The files of the calling methods.
-    #
-    def self.caller_files
-      caller(1).
-        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
-        reject { |file,line| PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern } }.
-        map    { |file,line| file }
-    end
-end # Padrino

data/lib/vendored-middleman-deps/padrino-helpers-0.11.2/lib/padrino-helpers/breadcrumb_helpers.rb

@@ -1,171 +0,0 @@
-module Padrino
-  module Helpers
-    class Breadcrumb
-
-      attr_accessor :home
-      attr_accessor :items
-
-      DEFAULT_URL = "/"
-      DEFAULT_CAPTION ="Home Page"
-
-      ##
-      # initialize breadcrumbs with default value
-      #
-      # @example
-      #   before do
-      #     @breadcrumbs = breadcrumbs.new
-      #   end
-      #
-      # @api public
-      def initialize
-        self.home = { :url => DEFAULT_URL, :caption => DEFAULT_CAPTION, :name => :home }
-        reset
-      end
-
-      ##
-      # Set the custom home (Parent) link
-      #
-      # @param [String] url
-      #  The url href
-      #
-      # @param [String] caption
-      #   The  text caption.
-      #
-      # @example
-      #   breadcrumbs.set_home "/HomeFoo", "Foo Home"
-      #
-      #
-      # @api public
-      def set_home(url, caption)
-        self.home = { :url => url, :caption => caption.to_s.humanize.html_safe, :name => :home }
-        reset
-      end
-
-      ##
-      # Reset breadcrumbs to default or personal  home
-      #
-      # @example
-      #   breadcrumbs.reset
-      #
-      # @api public
-      def reset
-        self.items=[]
-        self.items << home
-      end
-
-      ##
-      # Reset breadcrumbs to default home
-      #
-      # @example
-      #   breadcrumbs.reset!
-      #
-      # @api public
-      def reset!
-        self.home = { :url => DEFAULT_URL, :caption => DEFAULT_CAPTION, :name => :home }
-        reset
-      end
-
-      ##
-      # Add a new  breadcrumbs
-      #
-      # @param [String] name
-      #   The name of resource
-      # @param [Symbol] name
-      #   The name of resource
-      #
-      # @param [String] url
-      #   The url href.
-      #
-      # @param [String] caption
-      #   The text caption
-      #
-      # @example
-      #   breadcrumbs.add "foo", "/foo", "Foo Link"
-      #   breadcrumbs.add :foo, "/foo", "Foo Link"
-      #
-      # @api public
-      def add(name, url, caption)
-        items << { :name => name, :url => url.to_s, :caption => caption.to_s.humanize.html_safe }
-      end
-
-      alias :<< :add
-
-      ##
-      # Remove a Breadcrumbs
-      #
-      # @param [String] name
-      #  The name of resource to delete from breadcrumbs list
-      #
-      # @param [Symbol] name
-      #  The name of resource to delete from breadcrumbs list
-      #
-      # @example
-      #   breadcrumbs.del "foo"
-      #   breadcrumbs.del :foo
-      #
-      # @api public
-      def del(name)
-        items.delete_if { |item| item[:name] == name.to_sym }
-      end
-
-    end # Breadcrumb
-
-
-    module Breadcrumbs
-
-      # Render breadcrumbs to view
-      #
-      # @param [Breadcrumbs] breadcrumbs
-      #   The breadcrumbs to render into view
-      #
-      # @param [Boolean] bootstrap
-      #  If true, render separation (usefull with Twitter Bootstrap)
-      #
-      # @param [String] active
-      #  Css class style set to active breadcrumb
-      #
-      # @return [String] Unordered list with breadcrumbs
-      #
-      # @example
-      #  = breadcrumbs @breacrumbs
-      #  # Generates:
-      #  # <ul>
-      #  #   <li><a herf="/foo" >Foo Link</a></li>
-      #  #   <li class="active" ><a herf="/bar">Bar Link</a></li>
-      #  # </ul>
-      #
-      #
-      # @api public
-      def breadcrumbs(breadcrumbs, bootstrap=false, active="active")
-        content=""
-        breadcrumbs.items[0..-2].each do |item|
-          content << render_item(item, bootstrap)
-        end
-        last = link_to(breadcrumbs.items.last[:caption], breadcrumbs.items.last[:url])
-        content << safe_content_tag(:li, last, :class => active)
-        safe_content_tag(:ul, content, :class => "breadcrumb" )
-      end
-
-      private
-      ##
-      # Private method to return list item
-      #
-      # @param [Hash] item
-      #   The breadcrumb item
-      #
-      # @param [Boolean] bootstrap
-      #   If true, render separation (usefull with Twitter Bootstrap)
-      #
-      # @return [String] List item with breacrumb
-      #
-      # @api public
-      def render_item(item, bootstrap)
-        content = ""
-        content << link_to(item[:caption], item[:url])
-        content << safe_content_tag(:span, "/", :class => "divider") if bootstrap
-        safe_content_tag(:li, content )
-      end
-
-    end # Breadcrumb
-  end # Helpers
-end # Padrino