scorched 0.9 → 0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 295ef9e64b632d7c0d594d7faa770abe1a276306
-  data.tar.gz: 77d884750ab7dd5946e124963a0f818141074a6c
+  metadata.gz: 08889289c8e64bbfd860c495a1e0319c5c1c9310
+  data.tar.gz: 7c203bcdc50f2070e157302e6daa8b442c8a6694
 SHA512:
-  metadata.gz: a22df1cc5accdf2ef58b0a9135726d5379b74b55ecd5ed6d301c5e7adf55e14f5905c400411d12263f65552cbf32792d0f1400397fc6be260831536033f52f09
-  data.tar.gz: 426055e514e3ec9a4a7a13c2dccb692a914a38d054630a4f39b9df0a1d973520850571491741d3dc3f2a8aab363d62c283b4fac0a76140e1b9433bd825564eff
+  metadata.gz: 5aaa29d4c05e8bc4b4a2e11381c6a6030f91cbe0e3d2d7d312eabceabcae3447d742485852bfc115938526e21d32fa1399777737eaae9e71a40fe1f2879e8f11
+  data.tar.gz: 17c71a09fb5cf953a3dd96b880be3d68332622002ca3dfe9c1393b72e3141c63ea1fb4009bb0044f18a923c6f5e95657781a4514e50745f2735895f830fff57f

data/Milestones.md

@@ -3,6 +3,23 @@ Milestones
 
 Changelog
 ---------
+### v0.10
+* Route matching internals have been refactored.
+    * Match information is now stored in the `Match` struct for better formalisation.
+    * `matches` method no longer has a short-circuit option, and now returns all mappings that match the URL, regardless of whether their conditions passed. It also now caches the set of matches which are returned on subsequent calls.
+    * The first failed condition (if any) is stored in the `Match` struct as `:failed_condition`. This allows one to change the response in an after block depending on what condition failed. For example, proper status codes can be set depending on the failed condition.
+    * Response status defaults to 403 if one or more mappings are matched, but their conditions do not pass. The existing behaviour was to always return 404.
+* Added `:proc` condition which takes one or more Proc objects, allowing custom conditions to be added on-the-fly.
+* Added `:matched` condition. When a controller delegates the request to a mapping, it's considered to be matched.
+* Added `:failed_condition` condition. If one or more mappings are matched, but they're conditions do not pass, the first failed condition of the first matched mapping is considered the `failed_condition` for the request.
+* Added `:config` condition which takes a hash, each element of which must match the value of the corresponding config option.
+* Renamed `:methods` condition to `:method` for consistency sake.
+* Added default error message for all empty responses with a HTTP status code between 400 and 599, inclusive.
+* `Scorched::Collection` now merges parent values onto the beginning of self, rather than the end.
+* To compensate for the previous change, an `append_parent` accessor added to `Scorched::Collection` to allow _after_ filters to run in the correct order, executing inner filters before outer filters.
+* Added `:show_http_error_pages` config option. If true, it shows the Scorched HTTP error pages. Defaults to false.
+* Filters have been added to set the appropriate HTTP status code for certain failed conditions, such as returning `405 Method Not Allowed` when for example, a POST is made to a URL that only accepts GET requests.
+
 ### v0.9
 * Refactored `render` method:
     * All Scorched options are now keyword arguments, including `:locals` which was added as a proper render option.
@@ -24,13 +41,13 @@ Changelog
     * Non-Development
         * `config[:static_dir] = false`   * Development
         * `config[:show_exceptions] = true`       * `config[:logger] = Logger.new(STDOUT)`       * Add developer-friendly 404 error page. This is implemented as an after filter, and won't have any effect if the response body is set.
-* `absolute`ethod now returns forward slash if script name is empty.
+* `absolute` method now returns forward slash if script name is empty.
 
 ### v0.6
 * `view_config` options hash renamed to ` `render_defaults`ch better reflects its function.
 
 ### v0.5.2
-* Minor modification to routing to make it behave as a documented regarding matching at the directly before or on a path.
+* Minor modification to routing to make it behave as documented regarding matching a forward slash directly after or at the end of the matched path.
 * Response content-type now defaults to "text/html;charset=utf-8", rather than empty.
 
 ### v0.5.1
@@ -80,6 +97,7 @@ Some of these remaining features may be reconsidered and either left out, or put
     intended to make link building easier.
   * Form populator implemented with Nokogiri. This would have to be added to a contrib library.
 * Add Verbose logging, including debug logging to show each routing hop and the current environment (variables, mode, etc)
+* I need feedback on what order _after_ filters should be run. While it's somewhat intuitive for them to run in the order they're defined, it could also be considered intuitive for the first defined _after_ filter to be the last to touch the outgoing response; to have priority.
 
 
 Unlikely
@@ -88,6 +106,7 @@ These features are unlikely to be implemented unless someone provides a good rea
 
 * Mutex locking option - I'm of the opinion that the web server should be configured for the concurrency model of the application, rather than the framework.
 * Using Rack::Protection by default - The problem here is that a good portion of Rack::Protection involves sessions, and given that Scorched doesn't itself load any session middleware, these components of Rack::Protection would have to be excluded. I wouldn't want to invoke a false sense of security
+* Filter priorities - They're technically possible, but I believe it would introduce the potential for _filter hell_; badly written filters and mass confusion. Filter order has to be logical and predictable. Adding prioritisation would undermine that, and make for lazy use of filters. By not having prioritisation, there's incentive to design filters to be order-agnostic.
 
 
 More things will be added as they're thought of and considered.

data/README.md

@@ -70,7 +70,7 @@ class MyApp < Scorched::Controller
   end
   
   # To something that gets the muscle's flexing
-  route '/articles/:title/::opts', 2, methods: ['GET', 'POST'], content_type: :json do
+  route '/articles/:title/::opts', 2, method: ['GET', 'POST'], content_type: :json do
     # Do what you want in here. Note, the second argument is the optional route priority.
   end
   

data/docs/02_fundamentals/01_the_controller.md

@@ -71,7 +71,7 @@ class ControllerA < Scorched::Controller
   end
 end
 
-class ControllerB < Scorched::Controller
+class ControllerB < ControllerA
   render_defaults[:layout] = :controller_b
   
   get '/', user: 'bob' do
@@ -117,7 +117,7 @@ class MyApp < Scorched::Controller
 end
 ```
 
-The controller helper takes an optional URL pattern as it's first argument, an optional parent class as it's second, and finally a mapping hash as its third optional argument, where you can define a priority, conditions, or override the URL pattern. Of course, the `controller` helper takes a block as well, which defines the body of the new controller class.
+The `controller` helper takes an optional URL pattern as it's first argument, an optional parent class as it's second, and finally a mapping hash as its third optional argument, where you can define a priority, conditions, or override the URL pattern. Of course, the `controller` helper takes a block as well, which defines the body of the new controller class.
 
 The optional URL pattern defaults to `'/'` which means it's essentially a match-all mapping. In addition, the generated controller has `:auto_pass` set to `true` by default (refer to configuration documentation for more information). This is a handy combination for grouping a set of routes in their own scope, with their own methods, filters, configuration, etc. 
 
@@ -158,4 +158,4 @@ The Root Controller
 -------------------
 Although you will likely have a main controller to serve as the target for Rack, Scorched does not have the concept of a root controller. It makes no differentiation between a sub-controller and any other controller. All Controllers are made equal.
 
-You can arrange and nest your controllers in any way, shape or form. Scorched has been designed to not make any assumptions about how you structure your controllers, which again, can accommodate creative solutions.
+You can arrange and nest your controllers in any way, shape or form. Scorched has been designed to not make any assumptions about how you structure your controllers, which again, can accommodate creative solutions.

data/docs/02_fundamentals/02_configuration.md

@@ -8,24 +8,26 @@ There are two sets of configurables. Those which apply to views, and everything
 Options
 -------
 
-Each configuration is listed below, with the default value of each included. Note, development environment may override the default values below.
+Each configuration is listed below, with the default value of each included. Note, development environment defaults may override the default values below.
 
+* `config[:auto_pass] = false` -  If no routes within the current controller match, automatically _pass_ the request back to the outer controller without running any filters. This makes sub-controllers behave more like a kind-of route group.
+* `config[:cache_templates] = true` - If true, caches compiled templates using Tilt::Cache.
+* `config[:logger] = false` - Is currently only used for Rack::Logger.
+* `config[:show_exceptions] = false` - If true, shows exceptions using Rack::ShowExceptions
+* `config[:show_http_error_pages] = false` - If true, shows the default Scorched HTTP error page.
+* `config[:static_dir] = 'public'`  
+    The directory Scorched should serve static files from. Should be set to false if the web server or some other middleware is serving static files.
 * `config[:strip_trailing_slash] = :redirect`  
     Controls how trailing forward slashes in requests are handled.
     * `:redirect` - Strips and redirects URL's ending in a forward slash
     * `:ignore` - Internally ignores trailing slash
     * `false` - Does nothing. Respects the presence of a trailing forward flash.
-* `config[:static_dir] = 'public'`  
-    The directory Scorched should serve static files from. Should be set to false if the web server or some other middleware is serving static files.
-* `config[:logger] = false` - Is currently only used for Rack::Logger.
-* `config[:auto_pass] = false` -  If no routes within the current controller match, automatically _pass_ the request back to the outer controller without running any filters. This makes sub-controllers behave more like a kind-of route group.
-* `config[:cache_templates] = true` - If true, caches compiled templates using Tilt::Cache.
 
 You can also configure the default options when rendering views by setting them on the `render_defaults` hash. The options specified here are merged with those provided when calling the `render` method, with the explicit options obviously taking precedence over the defaults.
 
 Refer to the _views_ page for more information.
 
-Here is an example of the configuration options in action. A couple of different ways to set the options are shown. Refer to the API documentation for the `Scorched::Options` for more information.
+Here is an example of the configuration options in action. A couple of different ways to set the options are shown. Refer to the API documentation for `Scorched::Options` for more information.
 
 ```ruby
 class MyApp < Scorched::Controller

data/docs/02_fundamentals/03_routing.md

@@ -6,7 +6,7 @@ When Scorched receives a request, the first thing it does is iterate over it's i
 Mappings can be defined manually using the `map` class method, also aliased as `<<`. Besides the required URL pattern and target elements, a mapping can also define a priority, and one or more conditions. The example below demonstrates the use of all of them.
 
 ```ruby
-map pattern: '/', priority: -99, conditions: {methods: ['POST', 'PUT', 'DELETE']}, target: proc { |env|
+map pattern: '/', priority: -99, conditions: {method: ['POST', 'PUT', 'DELETE']}, target: proc { |env|
   [200, {}, 'Bugger off']
 }
 ```
@@ -26,7 +26,7 @@ route '/' do
   'Well hello there'
 end
 
-route '/*', 5, methods: ['POST', 'PUT', 'DELETE'] do |capture|
+route '/*', 5, method: ['POST', 'PUT', 'DELETE'] do |capture|
   "Hmm trying to change #{capture} I see"
 end
 ```
@@ -37,7 +37,7 @@ The first exception is that the pattern must match to the end of the request pat
 
 The other more notable exception is in how the given block is treated. The block given to the route helper is wrapped in another proc. The wrapping proc does a couple of things. It first sends all the captures in the url pattern as argument to the given block, this is shown in the example above. The other thing it does is takes care of assigning the return value to the body of the response.
 
-In the latter of the two examples above, a `:methods` condition defines what methods the route is intended to process. The first example has no such condition, so it accepts all HTTP methods. Typically however, a route will handle a single HTTP method, which is why Scorched also provides the convenience helpers: `get`, `post`, `put`, `delete`, `head`, `options`, and `patch`. These methods automatically define the corresponding `:method` condition, with the `get` helper also including `head` as an accepted HTTP method.
+In the latter of the two examples above, a `:method` condition defines what methods the route is intended to process. The first example has no such condition, so it accepts all HTTP methods. Typically however, a route will handle a single HTTP method, which is why Scorched also provides the convenience helpers: `get`, `post`, `put`, `delete`, `head`, `options`, and `patch`. These methods automatically define the corresponding `:method` condition, with the `get` helper also including `head` as an accepted HTTP method.
 
 Pattern Matching
 ----------------
@@ -68,15 +68,19 @@ Conditions
 Conditions are essentially just pre-requisites that must be met before a mapping is invoked to handle the current request. They're implemented as `Proc` objects which take a single argument, and return true if the condition is satisfied, or false otherwise. Scorched comes with a number of pre-defined conditions included, many of which are provided by _rack-accept_ - one of the few dependancies of Scorched.
 
 * `:charset` - Character sets accepted by the client.
+* `:config` - Takes a hash, each element of which must match the value of the corresponding config option.
 * `:encoding` - Encodings accepted by the client.
+* `:failed_condition` - If one or more mappings are matched, but they're conditions do not pass, the first failed condition of the first matched mapping is considered the `failed_condition` for the request.
 * `:host` - The host name (i.e. domain name) used in the request.
 * `:language` - Languages accepted by the client.
 * `:media_type` - Media types (i.e. content types) accepted by the client.
-* `:methods` - The request method used, e.g. GET, POST, PUT, ...
+* `:matched` - Whether a mapping in the controller instance was invoked as the target for the request.
+* `:method` - The request method used, e.g. GET, POST, PUT, ... .
+* `:proc` - An on-the-fly condition to be evaluated in the context of the controller instance. Should return true if the condition was satisfied, or false otherwise.
 * `:user_agent` - The user agent string provided with the request. Takes a Regexp or String.
 * `:status` - The response status of the request. Intended for use by _after_ filters.
 
-Like configuration options, conditions are implemented using the `Scorched::Options` class, so they're inherited and be overridable by child classes. You may easily add your own conditions as the example below demonstrates.
+Like configuration options, conditions are implemented using the `Scorched::Options` class, so they're inherited and can be overridden by child classes. You may easily add your own conditions as the example below demonstrates.
 
 ```ruby
 condition[:has_permission] = proc { |v|

data/docs/02_fundamentals/04_requests_and_responses.md

@@ -32,4 +32,4 @@ A route may _pass_ a request to the next matching route. _passing_ is very simil
 
 Redirections
 ------------
-A common requirement of many applications is to redirect requests to another URL based on some kind of condition. Scorched offers the very simple `redirect` method which takes one argument - the URL to redirect to. Like `halt` it's mostly a convenience method. It sets the _Location_ header of the response before halting the request.
+A common requirement of many applications is to redirect requests to another URL based on some kind of condition. Scorched offers the very simple `redirect` method which takes one required argument - the URL to redirect to - and an optional response status, which defaults to 307 (temporary redirect). `redirect` is mostly a convenience method. It sets the _Location_ header of the response before halting the request.

data/lib/scorched.rb

@@ -13,6 +13,7 @@ require_relative 'scorched/static'
 require_relative 'scorched/dynamic_delegate'
 require_relative 'scorched/options'
 require_relative 'scorched/collection'
+require_relative 'scorched/match'
 require_relative 'scorched/controller'
 require_relative 'scorched/error'
 require_relative 'scorched/request'

data/lib/scorched/collection.rb

@@ -7,7 +7,10 @@ module Scorched
       [:<<, :add, :add?, :clear, :delete, :delete?, :delete_if, :merge, :replace, :subtract].include? m
     }
     
-    # sets parent Collection object and returns self
+    # If true, parent values are appended to self. The default behavior is to append self to the parent values.
+    attr_accessor :append_parent
+    
+    # Sets parent Collection object and returns self
     def parent!(parent)
       @parent = parent
       self
@@ -15,8 +18,11 @@ module Scorched
     
     def to_set(inherit = true)
       if inherit && (Set === @parent || Array === @parent)
-        # An important attribute of a Scorched::Collection is that the merged set is ordered from inner to outer.
-        Set.new.merge(self._to_a).merge(@parent.to_set)
+        if append_parent
+          Set.new.merge(self._to_a).merge(@parent.to_set)
+        else
+          Set.new.merge(@parent.to_set).merge(self._to_a)
+        end
       else
         Set.new.merge(self._to_a)
       end
@@ -27,12 +33,12 @@ module Scorched
     end
     
     def inspect
-      "#<#{self.class}: #{_inspect}, #{to_set.inspect}>"
+      "#<#{self.class}(#{super}, #{to_set.inspect})>"
     end
   end
   
   class << self
-    def Collection(accessor_name)
+    def Collection(accessor_name, append_parent = false)
       m = Module.new
       m.class_eval <<-MOD
         class << self
@@ -46,6 +52,8 @@ module Scorched
             @#{accessor_name} || begin
               parent = superclass.#{accessor_name} if superclass.respond_to?(:#{accessor_name}) && Scorched::Collection === superclass.#{accessor_name}
               @#{accessor_name} = Collection.new.parent!(parent)
+              @#{accessor_name}.append_parent = #{append_parent.inspect}
+              @#{accessor_name}
             end
           end
         end

data/lib/scorched/controller.rb

@@ -7,16 +7,18 @@ module Scorched
     include Scorched::Options('conditions')
     include Scorched::Collection('middleware')
     include Scorched::Collection('before_filters')
-    include Scorched::Collection('after_filters')
+    include Scorched::Collection('after_filters', true)
     include Scorched::Collection('error_filters')
     
     config << {
-      :strip_trailing_slash => :redirect, # :redirect => Strips and redirects URL ending in forward slash, :ignore => internally ignores trailing slash, false => does nothing.
-      :static_dir => false, # The directory Scorched should serve static files from. Set to false if web server or anything else is serving static files.
+      :auto_pass => false, # Automatically _pass_ request back to outer controller if no route matches.
+      :cache_templates => true,
       :logger => nil,
       :show_exceptions => false,
-      :auto_pass => false, # Automatically _pass_ request back to outer controller if no route matches.
-      :cache_templates => true
+      :show_http_error_pages => false, # If true, shows the default Scorched HTTP error page.
+      :static_dir => false, # The directory Scorched should serve static files from. Set to false if web server or anything else is serving static files.
+      :strip_trailing_slash => :redirect, # :redirect => Strips and redirects URL ending in forward slash, :ignore => internally ignores trailing slash, false => does nothing.
+      
     }
     
     render_defaults << {
@@ -32,15 +34,24 @@ module Scorched
       config[:show_exceptions] = true
       config[:static_dir] = 'public'
       config[:cache_templates] = false
+      config[:show_http_error_pages] = true
     end
     
     conditions << {
       charset: proc { |charsets|
         [*charsets].any? { |charset| request.env['rack-accept.request'].charset? charset }
       },
+      config: proc { |map|
+        map.all? { |k,v| config[k] == v }
+      },
       encoding: proc { |encodings|
         [*encodings].any? { |encoding| request.env['rack-accept.request'].encoding? encoding }
       },
+      failed_condition: proc { |conditions|
+        if !matches.empty? && matches.all? { |m| m.failed_condition }
+          [*conditions].include? matches.first.failed_condition[0]
+        end
+      },
       host: proc { |host| 
         (Regexp === host) ? host =~ request.host : host == request.host 
       },
@@ -50,8 +61,14 @@ module Scorched
       media_type: proc { |types|
         [*types].any? { |type| request.env['rack-accept.request'].media_type? type }
       },
-      methods: proc { |accepts| 
-        [*accepts].include?(request.request_method)
+      method: proc { |methods| 
+        [*methods].include?(request.request_method)
+      },
+      matched: proc { |bool|
+        @_matched == bool
+      },
+      proc: proc { |*blocks|
+        [*blocks].all? { |b| instance_exec(&b) }
       },
       user_agent: proc { |user_agent| 
         (Regexp === user_agent) ? user_agent =~ request.user_agent : user_agent == request.user_agent 
@@ -146,7 +163,7 @@ module Scorched
       ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'].each do |method|
         methods = (method == 'get') ? ['GET', 'HEAD'] : [method.upcase]
         define_method(method) do |*args, **conds, &block|
-          conds.merge!(methods: methods)
+          conds.merge!(method: methods)
           route(*args, **conds, &block)
         end
       end
@@ -187,6 +204,10 @@ module Scorched
       end
     end
     
+    after(failed_condition: :host) { response.status = 404 }
+    after(failed_condition: :method) { response.status = 405 }
+    after(failed_condition: %i{charset encoding language media_type}) { response.status = 406 }
+    
     def method_missing(method, *args, &block)
       (self.class.respond_to? method) ? self.class.__send__(method, *args, &block) : super
     end
@@ -203,7 +224,9 @@ module Scorched
       inner_error = nil
       rescue_block = proc do |e|
         raise unless filters[:error].any? do |f|
-          (f[:args].empty? || f[:args].any? { |type| e.is_a?(type) }) && check_conditions?(f[:conditions]) && instance_exec(e, &f[:proc])
+          (f[:args].empty? || f[:args].any? { |type| e.is_a?(type) }) &&
+          !check_for_failed_condition(f[:conditions]) &&
+          instance_exec(e, &f[:proc])
         end
       end
 
@@ -213,22 +236,22 @@ module Scorched
             redirect(request.path.chomp('/'))
           end
           
-          all_matches = matches
-          if all_matches.empty?
+          if matches.all? { |m| m.failed_condition }
             pass if config[:auto_pass]
-            response.status = 404
+            response.status = matches.empty? ? 404 : 403
           end
           
           run_filters(:before)
           begin
-            all_matches.each do |match|
+            @_matched = true == matches.each { |match|
+              next if match.failed_condition
               request.breadcrumb << match
-              processed = catch(:pass) {
-                target = match[:mapping][:target]
-                response.merge! (Proc === target) ? instance_exec(request.env, &target) : target.call(request.env)
+              break if catch(:pass) {
+                target = match.mapping[:target]
+                response.merge! (Proc === target) ? instance_exec(env, &target) : target.call(env)
               }
-              processed ? break : request.breadcrumb.pop
-            end
+              request.breadcrumb.pop
+            }
           rescue => inner_error
             rescue_block.call(inner_error)
           end
@@ -240,44 +263,37 @@ module Scorched
       response
     end
     
-    def match?
-      !matches(true).empty?
-    end
-    
-    # Finds mappings that match the currently unmatched portion of the request path, returning an array of all matches.
-    # If _short_circuit_ is set to true, it stops matching at the first positive match, returning only a single match.
-    def matches(short_circuit = false)
+    # Finds mappings that match the unmatched portion of the request path, returning an array of `Match` objects, or an
+    # empty array if no matches were found.
+    #
+    # The `:eligable` attribute of the `Match` object indicates whether the conditions for that mapping passed.
+    # The result is cached for the life time of the controller instance, for the sake of effecient-recalling.
+    def matches
+      return @matches if @matches
       to_match = request.unmatched_path
       to_match = to_match.chomp('/') if config[:strip_trailing_slash] == :ignore && to_match =~ %r{./$}
-      matches = []
-      mappings.each do |m|
-        m[:pattern].match(to_match) do |match_data|
+      @matches = mappings.map { |mapping|
+        mapping[:pattern].match(to_match) do |match_data|
           if match_data.pre_match == ''
-            if check_conditions?(m[:conditions])
-              if match_data.names.empty?
-                captures = match_data.captures
-              else
-                captures = Hash[match_data.names.map{|v| v.to_sym}.zip match_data.captures]
-              end
-              matches << {mapping: m, captures: captures, path: match_data.to_s}
-              break if short_circuit
+            if match_data.names.empty?
+              captures = match_data.captures
+            else
+              captures = Hash[match_data.names.map{|v| v.to_sym}.zip match_data.captures]
             end
+            Match.new(mapping, captures, match_data.to_s, check_for_failed_condition(mapping[:conditions]))
           end
         end
-      end
-      matches
+      }.compact
     end
     
-    def check_conditions?(conds)
-      if !conds
-        true
-      else
-        conds.all? { |c,v| check_condition?(c, v) }
-      end
+    # Tests the given conditions, returning the name of the first failed condition, or nil otherwise.
+    def check_for_failed_condition(conds)
+      (conds || []).find { |c,v| check_condition?(c, v) ? false : c }
     end
     
+    # Test the given condition, returning true if the condition passes, or false otherwise.
     def check_condition?(c, v)
-      raise Error, "The condition `#{c}` either does not exist, or is not a Proc object" unless Proc === self.conditions[c]
+      raise Error, "The condition `#{c}` either does not exist, or is not an instance of Proc" unless Proc === self.conditions[c]
       instance_exec(v, &self.conditions[c])
     end
     
@@ -330,7 +346,7 @@ module Scorched
       env['scorched.flash'].each { |k,v| session[k] = v } if session && env['scorched.flash']
     end
     
-    # Serves as a thin layer of convenience to Rack's built-in methods: Request#cookies, Response#set_cookie, and
+    # Serves as a thin layer of convenience to Rack's built-in method: Request#cookies, Response#set_cookie, and
     # Response#delete_cookie.
     #
     # If only one argument is given, the specified cookie is retreived and returned.
@@ -431,35 +447,33 @@ module Scorched
       return_path[0] == '/' ? return_path : return_path.insert(0, '/')
     end
     
-    if ENV['RACK_ENV'] == 'development' && 
-      after do
-        if response.empty?
-          response.body = <<-HTML
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <style type="text/css">
-               @import url(http://fonts.googleapis.com/css?family=Titillium+Web|Open+Sans:300italic,400italic,700italic,400,700,300);
-                html, body { height: 100%; width: 100%; margin: 0; font-family: 'Open Sans', 'Lucida Sans', 'Arial'; }
-                body { color: #333; display: table; }
-                #container { display: table-cell; vertical-align: middle; text-align: center; }
-                #container > * { display: inline-block; text-align: center; vertical-align: middle; }
-                #logo {
-                  padding: 12px 24px 12px 120px; color: white; background: rgb(191, 64, 0);
-                  font-family: 'Titillium Web', 'Lucida Sans', 'Arial'; font-size: 36pt;  text-decoration: none;
-                }
-                h1 { margin-left: 18px; font-weight: 400; }
-              </style>
-            </head>
-            <body>
-              <div id="container">
-                <a id="logo" href="http://scorchedrb.com">Scorched</a>
-                <h1>404 Page Not Found</h1>
-              </div>
-            </body>
-            </html>
-          HTML
-        end
+    after config: {show_http_error_pages: true}, status: 400..599 do
+      if response.empty?
+        response.body = <<-HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+             @import url(http://fonts.googleapis.com/css?family=Titillium+Web|Open+Sans:300italic,400italic,700italic,400,700,300);
+              html, body { height: 100%; width: 100%; margin: 0; font-family: 'Open Sans', 'Lucida Sans', 'Arial'; }
+              body { color: #333; display: table; }
+              #container { display: table-cell; vertical-align: middle; text-align: center; }
+              #container > * { display: inline-block; text-align: center; vertical-align: middle; }
+              #logo {
+                padding: 12px 24px 12px 120px; color: white; background: rgb(191, 64, 0);
+                font-family: 'Titillium Web', 'Lucida Sans', 'Arial'; font-size: 36pt;  text-decoration: none;
+              }
+              h1 { margin-left: 18px; font-weight: 400; }
+            </style>
+          </head>
+          <body>
+            <div id="container">
+              <a id="logo" href="http://scorchedrb.com">Scorched</a>
+              <h1>#{response.status} #{Rack::Utils::HTTP_STATUS_CODES[response.status]}</h1>
+            </div>
+          </body>
+          </html>
+        HTML
       end
     end
 
@@ -467,9 +481,9 @@ module Scorched
   private
   
     def run_filters(type)
-      tracker = env['scorched.filters'] ||= {before: Set.new, after: Set.new}
+      tracker = env['scorched.executed_filters'] ||= {before: Set.new, after: Set.new}
       filters[type].reject{ |f| tracker[type].include? f }.each do |f|
-        if check_conditions?(f[:conditions])
+        unless check_for_failed_condition(f[:conditions])
           tracker[type] << f
           instance_exec(&f[:proc])
         end

data/lib/scorched/match.rb

@@ -0,0 +1,3 @@
+module Scorched
+  Match = Struct.new(:mapping, :captures, :path, :failed_condition)
+end

data/lib/scorched/request.rb

@@ -8,17 +8,17 @@ module Scorched
     
     # Returns a hash of captured strings from the last matched URL in the breadcrumb.
     def captures
-      breadcrumb.last ? breadcrumb.last[:captures] : []
+      breadcrumb.last ? breadcrumb.last.captures : []
     end
     
     # Returns an array of capture arrays; one for each mapping that's been hit during the request processing so far.
     def all_captures
-      breadcrumb.map { |v| v[:captures] }
+      breadcrumb.map { |match| match.captures }
     end
     
     # The portion of the path that's currently been matched by one or more mappings.
     def matched_path
-      join_paths(breadcrumb.map{|v| v[:path]})
+      join_paths(breadcrumb.map{ |match| match.path })
     end
     
     # The remaining portion of the path that has yet to be matched by any mappings.

data/lib/scorched/response.rb

@@ -16,8 +16,10 @@ module Scorched
     end
     
     # Automatically wraps the assigned value in an array if it doesn't respond to ``each``.
+    # Also filters out non-true values and empty strings.
     def body=(value)
-      super(value.respond_to?(:each) ? value : [value].compact)
+      value = []  if !value || value == ''
+      super(value.respond_to?(:each) ? value : [value.to_s])
     end
     
     def finish(*args, &block)

data/lib/scorched/version.rb

@@ -1,3 +1,3 @@
 module Scorched
-  VERSION = '0.9'
+  VERSION = '0.10'
 end

data/spec/collection_spec.rb

@@ -1,7 +1,7 @@
 require_relative './helper.rb'
 
 class CollectionA
-  include Scorched::Collection('middleware')
+  include Scorched::Collection('things')
 end
 
 class CollectionB < CollectionA
@@ -12,35 +12,56 @@ end
 
 module Scorched
   describe Collection do
+    before(:each) do
+      CollectionA.things.clear
+      CollectionB.things.clear
+      CollectionC.things.clear
+    end
+    
     it "defaults to an empty set" do
-      CollectionA.middleware.should == Set.new
+      CollectionA.things.should == Set.new
     end
   
     it "can be set to a given set" do
       my_set = Set.new(['horse', 'cat', 'dog'])
-      CollectionA.middleware.replace my_set
-      CollectionA.middleware.should == my_set
+      CollectionA.things.replace my_set
+      CollectionA.things.should == my_set
     end
     
     it "automatically converts arrays to sets" do
-      array = ['horse', 'cat', 'dog']
-      CollectionA.middleware.replace array
-      CollectionA.middleware.should == array.to_set
+      array = ['small', 'medium', 'large']
+      CollectionA.things.replace array
+      CollectionA.things.should == array.to_set
     end
   
     it "recursively inherits from parents by default" do
-      CollectionB.middleware.should == CollectionA.middleware
-      CollectionC.middleware.should == CollectionA.middleware
+      CollectionB.things.should == CollectionA.things
+      CollectionC.things.should == CollectionA.things
     end
   
     it "allows values to be overridden without modifying the parent" do
-      CollectionB.middleware << 'rabbit'
-      CollectionB.middleware.should include('rabbit')
-      CollectionA.middleware.should_not include('rabbit')
+      CollectionB.things << 'rabbit'
+      CollectionB.things.should include('rabbit')
+      CollectionA.things.should_not include('rabbit')
+    end
+    
+    it "prepends parent values by default" do
+      CollectionA.things.replace %w{car house}
+      CollectionB.things.replace %w{dog cat}
+      CollectionB.things.to_a.should == %w{car house dog cat}
+    end
+    
+    it "can be set to append parent values" do
+      CollectionB.things.append_parent = true
+      CollectionA.things.replace %w{car house}
+      CollectionB.things.replace %w{dog cat}
+      CollectionB.things.to_a.should == %w{dog cat car house}
     end
     
     it "provides access to a copy of internal set" do
-      CollectionB.middleware.to_set(false).should == Set.new(['rabbit'])
+      CollectionA.things << 'monkey'
+      CollectionB.things << 'rabbit'
+      CollectionB.things.to_set(false).should == Set.new(['rabbit'])
     end
   end
 end

data/spec/controller_spec.rb

@@ -14,7 +14,7 @@ module Scorched
     it "contains a set of default conditions" do
       app.conditions.should be_a(Options)
       app.conditions.length.should > 0
-      app.conditions[:methods].should be_a(Proc)
+      app.conditions[:method].should be_a(Proc)
     end
     
     describe "basic route handling" do
@@ -143,21 +143,21 @@ module Scorched
     describe "conditions" do
       it "contains a default set of conditions" do
         app.conditions.should be_a(Options)
-        app.conditions.should include(:methods, :media_type)
+        app.conditions.should include(:method, :media_type)
         app.conditions.each { |k,v| v.should be_a(Proc) }
       end
       
       it "executes route only if all conditions return true" do
-        app << {pattern: '/', conditions: {methods: 'POST'}, target: generic_handler}
+        app << {pattern: '/', conditions: {method: 'POST'}, target: generic_handler}
         response = rt.get "/"
-        response.status.should == 404
+        response.status.should be_between(400, 499)
         response = rt.post "/"
         response.status.should == 200
         
         app.conditions[:has_name] = proc { |name| request.GET['name'] }
-        app << {pattern: '/about', conditions: {methods: ['GET', 'POST'], has_name: 'Ronald'}, target: generic_handler}
+        app << {pattern: '/about', conditions: {method: ['GET', 'POST'], has_name: 'Ronald'}, target: generic_handler}
         response = rt.get "/about"
-        response.status.should == 404
+        response.status.should be_between(400, 499)
         response = rt.get "/about", name: 'Ronald'
         response.status.should == 200
       end
@@ -170,8 +170,8 @@ module Scorched
       end
       
       it "falls through to next route when conditions are not met" do
-        app << {pattern: '/', conditions: {methods: 'POST'}, target: proc { |env| [200, {}, ['post']] }}
-        app << {pattern: '/', conditions: {methods: 'GET'}, target: proc { |env| [200, {}, ['get']] }}
+        app << {pattern: '/', conditions: {method: 'POST'}, target: proc { |env| [200, {}, ['post']] }}
+        app << {pattern: '/', conditions: {method: 'GET'}, target: proc { |env| [200, {}, ['get']] }}
         rt.get("/").body.should == 'get'
         rt.post("/").body.should == 'post'
       end
@@ -179,9 +179,9 @@ module Scorched
     
     describe "route helpers" do
       it "allows end points to be defined more succinctly" do
-        route_proc = app.route('/*', 2, methods: 'GET') { |capture| capture }
+        route_proc = app.route('/*', 2, method: 'GET') { |capture| capture }
         mapping = app.mappings.first
-        mapping.should == {pattern: mapping[:pattern], priority: 2, conditions: {methods: 'GET'}, target: route_proc}
+        mapping.should == {pattern: mapping[:pattern], priority: 2, conditions: {method: 'GET'}, target: route_proc}
         rt.get('/about').body.should == 'about'
       end
       
@@ -249,11 +249,11 @@ module Scorched
         end
       
         it "can take mapping options" do
-          app.controller priority: -1, conditions: {methods: 'POST'} do
+          app.controller priority: -1, conditions: {method: 'POST'} do
             route('/') { 'ok' }
           end
           app.mappings.first[:priority].should == -1
-          rt.get('/').status.should == 404
+          rt.get('/').status.should be_between(400, 499)
           rt.post('/').body.should == 'ok'
         end
         
@@ -303,14 +303,24 @@ module Scorched
       
       they "can take an optional set of conditions" do
         counter = 0
-        app.before(methods: ['GET', 'PUT']) { counter += 1  }
-        app.after(methods: ['GET', 'PUT']) { counter += 1  }
+        app.before(method: ['GET', 'PUT']) { counter += 1  }
+        app.after(method: ['GET', 'PUT']) { counter += 1  }
         rt.post('/')
         rt.get('/')
         rt.put('/')
         counter.should == 4
       end
       
+      they "execute in the order they're defined" do
+        order = []
+        app.before { order << :first }
+        app.before { order << :second }
+        app.after { order << :third }
+        app.after { order << :fourth }
+        rt.get('/')
+        order.should == %i{first second third fourth}
+      end
+      
       describe "nesting" do
         example "filters inherit but only run once" do
           before_counter, after_counter = 0, 0
@@ -331,26 +341,48 @@ module Scorched
           after_counter.should == 1
         end
         
-        example "before filters run from outermost to inner" do
+        example "before filters run from outermost to innermost" do
           order = []
           app.before { order << :outer }
+          app.before { order << :outer2 }
           app.controller do
             before { order << :inner }
+            before { order << :inner2 }
             get('/') { }
           end
           rt.get('/')
-          order.should == [:outer, :inner]
+          order.should == %i{outer outer2 inner inner2}
         end
         
         example "after filters run from innermost to outermost" do
           order = []
           app.after { order << :outer }
+          app.after { order << :outer2 }
           app.controller do
             get('/') { }
             after { order << :inner }
+            after { order << :inner2 }
           end
           rt.get('/')
-          order.should == [:inner, :outer]
+          order.should == %i{inner inner2 outer outer2}
+        end
+        
+        example "inherited filters which fail to satisfy their conditions are re-evaluated at every level" do
+          order = []
+          sub_class = app.controller do
+            before { order << :third }
+            get('/hello') { }
+          end
+          app.before(status: 500) do
+            order << :second
+            self.class.should == sub_class
+          end
+          app.before do
+            order << :first
+            response.status = 500
+          end
+          rt.get('/hello')
+          order.should == %i{first second third}
         end
       end
     end
@@ -432,7 +464,7 @@ module Scorched
       end
       
       they "can take an optional set of conditions" do
-        app.error(methods: ['GET', 'PUT']) { true  }
+        app.error(method: ['GET', 'PUT']) { true  }
         expect {
           rt.post('/')
         }.to raise_error(StandardError)
@@ -585,6 +617,26 @@ module Scorched
         end
       end
       
+      describe :show_http_error_pages do
+        it "shows HTTP error pages for errors 400 to 599" do
+          app.config[:show_http_error_pages] = true
+          app.get('/') { response.status = 501; '' }
+          app.get('/unknown') { response.status = 480; nil }
+          rt.get('/').body.should include('501 Not Implemented')
+          rt.post('/').body.should include('405 Method Not Allowed')
+          rt.get('/unknown').body.should include('480 ')
+        end
+        
+        it "can be disabled" do
+          app.config[:show_http_error_pages] = false
+          app.get('/') { response.status = 501; '' }
+          app.get('/unknown') { response.status = 480; nil }
+          rt.get('/').body.should_not include('501 Not Implemented')
+          rt.post('/').body.should_not include('405 Method Not Allowed')
+          rt.post('/unknown').body.should_not include('408 ')
+        end
+      end
+      
       describe :auto_pass do
         it "passes to the outer controller without running any filters, if no match" do
           sub = Class.new(Scorched::Controller) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: '0.10'
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -112,6 +112,7 @@ files:
 - lib/scorched/controller.rb
 - lib/scorched/dynamic_delegate.rb
 - lib/scorched/error.rb
+- lib/scorched/match.rb
 - lib/scorched/options.rb
 - lib/scorched/request.rb
 - lib/scorched/response.rb
@@ -162,3 +163,4 @@ test_files:
 - spec/controller_spec.rb
 - spec/options_spec.rb
 - spec/request_spec.rb
+has_rdoc: