middleman-core 3.1.0.rc.2 → 3.1.0.rc.3

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

@@ -0,0 +1,229 @@
+module Padrino
+  module Flash
+
+    class << self
+      # @private
+      def registered(app)
+        app.helpers Helpers
+        app.after do
+          session[:_flash] = @_flash.next if @_flash
+        end
+      end
+    end # self
+
+    class Storage
+      include Enumerable
+
+      # @private
+      def initialize(session=nil)
+        @_now  = session || {}
+        @_next = {}
+      end
+
+      def now
+        @_now
+      end
+
+      def next
+        @_next
+      end
+
+      # @since 0.10.8
+      # @api public
+      def [](type)
+        @_now[type]
+      end
+
+      # @since 0.10.8
+      # @api public
+      def []=(type, message)
+        @_next[type] = message
+      end
+
+      # @since 0.10.8
+      # @api public
+      def delete(type)
+        @_now.delete(type)
+        self
+      end
+
+      # @since 0.10.8
+      # @api public
+      def keys
+        @_now.keys
+      end
+
+      # @since 0.10.8
+      # @api public
+      def key?(type)
+        @_now.key?(type)
+      end
+
+      # @since 0.10.8
+      # @api public
+      def each(&block)
+        @_now.each(&block)
+      end
+
+      # @since 0.10.8
+      # @api public
+      def replace(hash)
+        @_now.replace(hash)
+        self
+      end
+
+      # @since 0.10.8
+      # @api public
+      def update(hash)
+        @_now.update(hash)
+        self
+      end
+      alias_method :merge!, :update
+
+      # @since 0.10.8
+      # @api public
+      def sweep
+        @_now.replace(@_next)
+        @_next = {}
+        self
+      end
+
+      # @since 0.10.8
+      # @api public
+      def keep(key = nil)
+        if key
+          @_next[key] = @_now[key]
+        else
+          @_next.merge!(@_now)
+        end
+        self
+      end
+
+      # @since 0.10.8
+      # @api public
+      def discard(key = nil)
+        if key
+          @_next.delete(key)
+        else
+          @_next = {}
+        end
+        self
+      end
+
+      # @since 0.10.8
+      # @api public
+      def clear
+        @_now.clear
+      end
+
+      # @since 0.10.8
+      # @api public
+      def empty?
+        @_now.empty?
+      end
+
+      # @since 0.10.8
+      # @api public
+      def to_hash
+        @_now.dup
+      end
+
+      def length
+        @_now.length
+      end
+      alias_method :size, :length
+
+      # @since 0.10.8
+      # @api public
+      def to_s
+        @_now.to_s
+      end
+
+      # @since 0.10.8
+      # @api public
+      def error=(message)
+        self[:error] = message
+      end
+
+      # @since 0.10.8
+      # @api public
+      def error
+        self[:error]
+      end
+
+      # @since 0.10.8
+      # @api public
+      def notice=(message)
+        self[:notice] = message
+      end
+
+      # @since 0.10.8
+      # @api public
+      def notice
+        self[:notice]
+      end
+
+      # @since 0.10.8
+      # @api public
+      def success=(message)
+        self[:success] = message
+      end
+
+      # @since 0.10.8
+      # @api public
+      def success
+        self[:success]
+      end
+    end # Storage
+
+    module Helpers
+      ###
+      # Overloads the existing redirect helper in-order to provide support for flash messages
+      #
+      # @overload redirect(url)
+      #   @param [String] url
+      #
+      # @overload redirect(url, status_code)
+      #   @param [String] url
+      #   @param [Fixnum] status_code
+      #
+      # @overload redirect(url, status_code, flash_messages)
+      #   @param [String] url
+      #   @param [Fixnum] status_code
+      #   @param [Hash]   flash_messages
+      #
+      # @overload redirect(url, flash_messages)
+      #   @param [String] url
+      #   @param [Hash]   flash_messages
+      #
+      # @example
+      #   redirect(dashboard, success: :user_created)
+      #   redirect(new_location, 301, notice: 'This page has moved. Please update your bookmarks!!')
+      #
+      # @since 0.10.8
+      # @api public
+      def redirect(url, *args)
+        flashes = args.extract_options!
+
+        flashes.each do |type, message|
+          message = I18n.translate(message) if message.is_a?(Symbol) && defined?(I18n)
+          flash[type] = message
+        end
+
+        super(url, args)
+      end
+      alias_method :redirect_to, :redirect
+
+      ###
+      # Returns the flash storage object
+      #
+      # @return [Storage]
+      #
+      # @since 0.10.8
+      # @api public
+      def flash
+        @_flash ||= Storage.new(env['rack.session'] ? session[:_flash] : {})
+      end
+    end # Helpers
+  end # Flash
+end # Padrino

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/application/rendering.rb

@@ -7,6 +7,16 @@ module Padrino
   # 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.
     #
@@ -25,19 +35,34 @@ module Padrino
     ] unless defined?(IGNORE_FILE_PATTERN)
 
     ##
-    # Default rendering options used in the #render-method.
+    # 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)
-        app.send(:include, InstanceMethods)
-        app.extend(ClassMethods)
+        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
-      alias :included :registered
     end
 
     ##
@@ -152,11 +177,8 @@ module Padrino
         # * 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'
-        # * Use render { :a => 1, :b => 2, :c => 3 } # => return a json string
         #
         def render(engine, data=nil, options={}, locals={}, &block)
-          # If engine is a hash then render data converted to json
-          content_type(:json, :charset => 'utf-8') and return engine.to_json if engine.is_a?(Hash)
 
           # If engine is nil, ignore engine parameter and shift up all arguments
           # render nil, "index", { :layout => true }, { :localvar => "foo" }
@@ -175,10 +197,10 @@ module Padrino
           root = settings.respond_to?(:root) ? settings.root : ""
 
           # Use @layout if it exists
-          options[:layout] = @layout if options[:layout].nil?
-
+          layout_was = options[:layout]
+          options[:layout] = @layout if options[:layout].nil? || options[:layout] == true
           # Resolve layouts similar to in Rails
-          if (options[:layout].nil? || options[:layout] == true) && !settings.templates.has_key?(:layout)
+          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
@@ -186,10 +208,12 @@ module Padrino
           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 = "", @_out_buf
+          @_out_buf,  _buf_was = ActiveSupport::SafeBuffer.new, @_out_buf
 
           # Pass arguments to Sinatra render method
           super(engine, data, options.dup, locals, &block)
@@ -290,3 +314,7 @@ module Padrino
     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/rendering/extensions/erubis.rb

@@ -0,0 +1,55 @@
+begin
+  require 'erubis'
+
+  module Padrino
+    module Erubis
+      ##
+      # SafeBufferEnhancer is an Erubis Enhancer that compiles templates that
+      # are fit for using ActiveSupport::SafeBuffer as a Buffer.
+      #
+      # @api private
+      module SafeBufferEnhancer
+        def add_expr_literal(src, code)
+          src << " #{@bufvar}.concat((" << code << ').to_s);'
+        end
+
+        def add_expr_escaped(src, code)          
+          src << " #{@bufvar}.safe_concat " << code << ';'
+        end
+
+        def add_text(src, text)
+          src << " #{@bufvar}.safe_concat '" << escape_text(text) << "';" unless text.empty?
+        end
+      end
+
+      ##
+      # SafeBufferTemplate is the classic Erubis template, augmented with
+      # SafeBufferEnhancer.
+      #
+      # @api private
+      class SafeBufferTemplate < ::Erubis::Eruby
+        include SafeBufferEnhancer
+      end
+
+      ##
+      # Modded ErubisTemplate that doesn't insist in an String as output
+      # buffer.
+      #
+      # @api private
+      class Template < Tilt::ErubisTemplate
+        def precompiled_preamble(locals)
+          old_postamble = super.split("\n")[0..-2]
+          [old_postamble, "#{@outvar} = _buf = (#{@outvar} || ActiveSupport::SafeBuffer.new)"].join("\n")
+        end
+      end
+    end
+  end
+  
+  Tilt.prefer Padrino::Erubis::Template, :erb
+
+  if defined? Padrino::Rendering
+    Padrino::Rendering.engine_configurations[:erb] = 
+      {:engine_class => Padrino::Erubis::SafeBufferTemplate}
+  end
+rescue LoadError
+end

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

@@ -0,0 +1,26 @@
+begin
+  require 'haml'
+  require 'haml/helpers/xss_mods'
+
+  module Haml
+    module Helpers
+      include XssMods
+    end
+
+    module Util
+      def self.rails_xss_safe?
+        true
+      end
+    end
+  end
+
+  if defined? Padrino::Rendering
+    Padrino::Rendering.engine_configurations[:haml] =
+      {:escape_html => true}
+
+    class Tilt::HamlTemplate
+      include Padrino::Rendering::SafeTemplate
+    end
+  end
+rescue LoadError
+end

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

@@ -0,0 +1,14 @@
+begin
+  require 'slim'
+
+  if defined? Padrino::Rendering
+    Padrino::Rendering.engine_configurations[:slim] =
+      {:generator => Temple::Generators::RailsOutputBuffer,
+      :buffer => "@_out_buf", :use_html_safe => true}
+
+    class Slim::Template
+      include Padrino::Rendering::SafeTemplate
+    end
+  end
+rescue LoadError
+end

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/application/routing.rb

@@ -11,6 +11,9 @@ class Sinatra::Request
   def controller
     route_obj && route_obj.controller
   end
+  def action
+    route_obj && route_obj.action
+  end
 end
 
 ##
@@ -28,8 +31,8 @@ class HttpRouter
       @route    = path.route
       @params ||= {}
       @params.update(env['router.params'])
-      @block_params = if path.route.is_a?(HttpRouter::RegexRoute)
-        params_list = env['router.request'].extra_env['router.regex_match'].to_a
+      @block_params = if match_data = env['router.request'].extra_env['router.regex_match']
+        params_list = match_data.to_a
         params_list.shift
         @params[:captures] = params_list
         params_list
@@ -47,7 +50,6 @@ class HttpRouter
         (@route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
         @layout = path.route.use_layout if path.route.use_layout
         @route.custom_conditions.each { |block| pass if block.bind(self).call == false } if @route.custom_conditions
-        @block_params     = @block_params[0, @route.dest.arity] if @route.dest.arity > 0
         halt_response     = catch(:halt) { route_eval { @route.dest[self, @block_params] } }
         @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
         successful        = true
@@ -62,7 +64,9 @@ class HttpRouter
 
   # @private
   class Route
-    attr_accessor :use_layout, :controller, :cache, :cache_key, :cache_expires_in
+    VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
+
+    attr_accessor :use_layout, :controller, :action, :cache, :cache_key, :cache_expires_in, :parent
 
     def before_filters(&block)
       @_before_filters ||= []
@@ -84,6 +88,60 @@ class HttpRouter
 
       @_custom_conditions
     end
+
+    def significant_variable_names
+      @significant_variable_names ||= if @original_path.is_a?(String)
+        @original_path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
+      elsif @original_path.is_a?(Regexp) and @original_path.respond_to?(:named_captures)
+        @original_path.named_captures.keys.map(&:to_sym)
+      else
+        []
+      end
+    end
+  end
+
+  #Monkey patching the Request class. Using Rack::Utils.unescape rather than
+  #URI.unescape which can't handle utf-8 chars
+  class Request
+    def initialize(path, rack_request)
+      @rack_request = rack_request
+      @path = Rack::Utils.unescape(path).split(/\//)
+      @path.shift if @path.first == ''
+      @path.push('') if path[-1] == ?/
+      @extra_env = {}
+      @params = []
+      @acceptable_methods = Set.new
+    end
+  end
+
+  class Node::Path
+    def to_code
+      path_ivar = inject_root_ivar(self)
+      "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
+        catch(:pass) do
+          response = ::Rack::Response.new
+          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
+          return response.finish
+        end
+      end" if router.redirect_trailing_slash?}
+
+      #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
+        catch(:pass) do
+          if callback
+            request.called = true
+            callback.call(Response.new(request, #{path_ivar}))
+          else
+            env = request.rack_request.dup.env
+            env['router.request'] = request
+            env['router.params'] ||= {}
+            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
+            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
+            response = @router.process_destination_path(#{path_ivar}, env)
+            return response unless router.pass_on_response(response)
+          end
+        end
+      #{"end" unless route.match_partially}"
+    end
   end
 end
 
@@ -98,7 +156,7 @@ module Padrino
     def apply?(request)
       detect = @args.any? do |arg|
         case arg
-        when Symbol then request.route_obj && (request.route_obj.named == arg or request.route_obj.named == [@scoped_controller, arg].flatten.join("_").to_sym)
+        when Symbol then request.route_obj && (request.route_obj.name == arg or request.route_obj.name == [@scoped_controller, arg].flatten.join("_").to_sym)
         else             arg === request.path_info
         end
       end || @options.any? do |name, val|
@@ -166,7 +224,7 @@ module Padrino
     # Class methods responsible for enhanced routing for controllers.
     module ClassMethods
       ##
-      # Method for organize in a better way our routes.
+      # Method to organize our routes in a better way.
       #
       # @param [Array] args
       #   Controller arguments.
@@ -237,8 +295,8 @@ module Padrino
       #     get :index, :map => "/:lang" do; "params[:lang] == :de"; end
       #   end
       #
-      # In a controller before and after filters are scoped and didn't affect other controllers or main app.
-      # In a controller layout are scoped and didn't affect others controllers and main app.
+      # In a controller, before and after filters are scoped and don't affect other controllers or the main app.
+      # In a controller, layouts are scoped and don't affect other controllers or the main app.
       #
       # @example
       #   controller :posts do
@@ -449,7 +507,8 @@ module Padrino
       #
       def recognize_path(path)
         responses = @router.recognize(Rack::MockRequest.env_for(path))
-        [responses[0].path.route.named, responses[0].params]
+        responses = responses[0] if responses[0].is_a?(Array)
+        [responses[0].path.route.name, responses[0].params]
       end
 
       ##
@@ -470,11 +529,12 @@ module Padrino
           params[:format] = params[:format].to_s unless params[:format].nil?
           params = value_to_param(params)
         end
-        url = if params_array.empty?
-          compiled_router.url(name, params)
-        else
-          compiled_router.url(name, *(params_array << params))
-        end
+        url =
+          if params_array.empty?
+            compiled_router.path(name, params)
+          else
+            compiled_router.path(name, *(params_array << params))
+          end
         url[0,0] = conform_uri(uri_root) if defined?(uri_root)
         url[0,0] = conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
         url = "/" if url.blank?
@@ -556,8 +616,17 @@ module Padrino
           # Do padrino parsing. We dup options so we can build HEAD request correctly
           route_options = options.dup
           route_options[:provides] = @_provides if @_provides
+
+          # CSRF protection is always active except when explicitly switched off
+          if allow_disabled_csrf
+            unless route_options[:csrf_protection] == false
+              route_options[:csrf_protection] = true
+            end
+          end
+
           path, *route_options[:with] = path if path.is_a?(Array)
-          path, name, options, route_options = *parse_route(path, route_options, verb)
+          action = path
+          path, name, route_parents, options, route_options = *parse_route(path, route_options, verb)
           options.reverse_merge!(@_conditions) if @_conditions
 
           # Sinatra defaults
@@ -572,20 +641,22 @@ module Padrino
 
           # HTTPRouter route construction
           route = router.add(path, route_options)
-          route.name(name) if name
+          route.name = name if name
+          route.action = action
           priority_name = options.delete(:priority) || :normal
           priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
           route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
-          route.send(verb.downcase.to_sym)
-          route.host(options.delete(:host)) if options.key?(:host)
-          route.user_agent(options.delete(:agent)) if options.key?(:agent)
+          route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
+          route.add_request_method(verb.downcase.to_sym)
+          route.host = options.delete(:host) if options.key?(:host)
+          route.user_agent = options.delete(:agent) if options.key?(:agent)
           if options.key?(:default_values)
             defaults = options.delete(:default_values)
-            route.default(defaults) if defaults
+            route.add_default_values(defaults) if defaults
           end
           options.delete_if do |option, args|
-            if route.send(:significant_variable_names).include?(option)
-              route.matching(option => Array(args).first)
+            if route.significant_variable_names.include?(option)
+              route.add_match_with(option => Array(args).first)
               true
             end
           end
@@ -646,8 +717,8 @@ module Padrino
 
             if @_use_format or format_params = options[:provides]
               process_path_for_provides(path, format_params)
-              options[:matching] ||= {}
-              options[:matching][:format] = /[^\.]+/
+              # options[:add_match_with] ||= {}
+              # options[:add_match_with][:format] = /[^\.]+/
             end
 
             absolute_map = map && map[0] == ?/
@@ -657,14 +728,14 @@ module Padrino
               if map.blank? and !absolute_map
                 controller_path = controller.join("/")
                 path.gsub!(%r{^\(/\)|/\?}, "")
-                path = File.join(controller_path, path)
+                path = File.join(controller_path, path)  unless @_map
               end
               # Here we build the correct name route
             end
 
             # Now we need to parse our 'parent' params and parent scope
             if !absolute_map and parent_params = options.delete(:parent) || @_parents
-              parent_params = Array(@_parents) + Array(parent_params)
+              parent_params = (Array(@_parents) + Array(parent_params)).uniq
               path = process_path_for_parent_params(path, parent_params)
             end
 
@@ -692,7 +763,7 @@ module Padrino
           # Merge in option defaults
           options.reverse_merge!(:default_values => @_defaults)
 
-          [path, name, options, route_options]
+          [path, name, parent_params, options, route_options]
         end
 
         ##
@@ -756,19 +827,22 @@ module Padrino
         def provides(*types)
           @_use_format = true
           condition do
-            mime_types        = types.map { |t| mime_type(t) }
+            mime_types        = types.map { |t| mime_type(t) }.compact
             url_format        = params[:format].to_sym if params[:format]
-            accepts           = request.accept.map { |a| a.split(";")[0].strip }
+            accepts           = request.accept.map { |a| a.to_str }
 
             # per rfc2616-sec14:
             # Assume */* if no ACCEPT header is given.
             catch_all = (accepts.delete "*/*" || accepts.empty?)
             matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
+            if matching_types.empty? && types.include?(:any)
+              matching_types = accepts
+            end
 
             if !url_format && matching_types.first
               type = ::Rack::Mime::MIME_TYPES.find { |k, v| v == matching_types.first }[0].sub(/\./,'').to_sym
               accept_format = CONTENT_TYPE_ALIASES[type] || type
-            elsif catch_all
+            elsif catch_all && !types.include?(:any)
               type = types.first
               accept_format = CONTENT_TYPE_ALIASES[type] || type
             end
@@ -793,6 +867,21 @@ module Padrino
             matched_format
           end
         end
+
+        ##
+        # Implements CSRF checking when `allow_disabled_csrf` is set to true.
+        #
+        # This condition is always on, except when it is explicitly switched
+        # off.
+        #
+        # @example
+        #   post("/", :csrf_protection => false)
+        #
+        def csrf_protection(on = true)
+          if on
+            condition { halt 403 if request.env['protection.csrf.failed'] }
+          end
+        end
     end
 
     ##
@@ -836,7 +925,7 @@ module Padrino
         else
           path_params << params
         end
-        @route.url(*path_params)
+        @route.path(*path_params)
       end
 
       ##
@@ -905,13 +994,19 @@ module Padrino
         end
 
         def dispatch!
-          static! if settings.static? && (request.get? || request.head?)
-          route!
+          invoke do
+            static! if settings.static? && (request.get? || request.head?)
+            route!
+          end
         rescue ::Exception => boom
-          filter! :before
-          handle_exception!(boom)
+          filter! :before  if boom.kind_of? ::Sinatra::NotFound
+          invoke { @boom_handled = handle_exception!(boom) }
         ensure
-          filter! :after unless env['sinatra.static_file']
+          @boom_handled  or begin
+            filter! :after  unless env['sinatra.static_file']
+          rescue ::Exception => boom
+            invoke { handle_exception!(boom) } unless @env['sinatra.error']
+          end
         end
 
         def route!(base=settings, pass_block=nil)
@@ -919,9 +1014,10 @@ module Padrino
           if base.compiled_router and match = base.compiled_router.call(@request.env)
             if match.respond_to?(:each)
               route_eval do
-                match[1].each {|k,v| response[k] = v}
+                match[1].each { |k,v| response[k] = v }
                 status match[0]
                 route_missing if match[0] == 404
+                route_missing if allow = response['Allow'] and allow.include?(request.env['REQUEST_METHOD'])
               end
             end
           else