scorched 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca89aa0414bd6f8f6ac42afd5fb7816198b4a9bdbf6b008cd32dbd5dcac89c7e
-  data.tar.gz: 34b43e1c6975f32954c52aeaccb21ebd797b31abd5adeaeb2430dd0cdf5ae848
+  metadata.gz: 7a838c96acf81063ddc76cc2a26fe3497b7fd83de1b095ba4d9cef042835b9ed
+  data.tar.gz: 0de14593266fcf5df232a6f56cc89ca4de8d9b7de9d8a4df2fbc173974d55aca
 SHA512:
-  metadata.gz: 752e607e45d78a21de7acaca053cca0d5f2b0b3b73f485c72a9c4779302c982fbf56496b248132ff7b4a895f2d50da2cfb579b7e6f7a7a008a4e5dd189eb4b8d
-  data.tar.gz: a0680f3c093aff1b1de0e612f3bffb052e1fdb3d4d39b54b8838a2ae295a26bb65fabe7263d4dd3239ea5687014ed772fd5d9a10f0886260f27a9d435d4179d4
+  metadata.gz: a76db1e57fc1a1a62428e3e3e728ecc4eeee9d504579e5a7894c4e07ed0d819306f0ea2b73725e605e129ee188d864e1cbaf145c2e7eda6e1aea39e4f51ef930
+  data.tar.gz: 7b7185d2a622ac50111c0e3fbd5104e962ae2afc26c9058d07493b1a3666111bbf2b274c8afef1967697f319a268f1ff97d94511914509de4ed1bd4fd008b872

data/CHANGES.md

@@ -1,6 +1,23 @@
 Changelog
 =========
 
+### v1.1.0
+* Added `around` filters to allow wrapping application logic around a request. `around` filters wrap around `before/after` filters. Ideal for `begin...ensure...end` where you need to ensure something happens before the request processing ends. For example:
+    ```
+    around do |cont|
+        begin
+            cont.call
+        ensure
+            # Ensure something important happens here
+        end
+    end
+    ```
+* Compatible with Ruby 4.0
+
+### v1.1.0.pre
+* Updated dependancies
+* Now compatible with (and requires) Rack 3.x
+* No longer escapes "+" into space characters
 ### v1.0.3
 * Fixed issue where routes with a `media_type` condition were prioritised over those without for HTTP requests accepting "*/*"
 ### v1.0.2

data/lib/scorched/controller.rb

@@ -10,6 +10,7 @@ module Scorched
     include Scorched::Options('symbol_matchers')
     include Scorched::Collection('middleware')
     include Scorched::Collection('before_filters')
+    include Scorched::Collection('around_filters')
     include Scorched::Collection('after_filters', true)
     include Scorched::Collection('error_filters')
 
@@ -108,7 +109,7 @@ module Scorched
       end
 
       def filters
-        @filters ||= {before: before_filters, after: after_filters, error: error_filters}
+        @filters ||= {before: before_filters, around: around_filters, after: after_filters, error: error_filters}
       end
 
       def call(env)
@@ -213,6 +214,16 @@ module Scorched
         filter(:after, force: force, conditions: conditions, &block)
       end
 
+      # Syntactic sugar for defining an around filter.
+      # The block is passed a single argument - a proc representing the rest of the filter chain (including the
+      # eventual dispatch to before/matching/after processing). The block must call it (e.g. `cont.call`) for
+      # request handling to proceed; if it doesn't, the wrapped chain simply never runs.
+      # Around filters defined earlier (including those defined in superclasses) wrap those defined later, with the
+      # innermost proc being the actual before/dispatch/after cycle.
+      def around(**conditions, &block)
+        filter(:around, conditions: conditions, &block)
+      end
+
       # Syntactic sugar for defining an error filter.
       # Takes one or more optional exception classes for which this error filter should handle. Handles all exceptions
       # by default.
@@ -286,26 +297,29 @@ module Scorched
         end
       end
 
-      begin
-        if config[:strip_trailing_slash] == :redirect && request.path =~ %r{[^/]/+$}
-          query_string = request.query_string.empty? ? '' : '?' << request.query_string
-          redirect(request.path.chomp('/') + query_string, status: 307, halt: false)
-          return response.finish
-        end
-        pass if config[:auto_pass] && eligable_matches.empty?
-
-        if run_filters(:before)
-          catch(:halt) {
-            begin
-              try_matches
-            rescue => inner_error
-              rescue_block.call(inner_error)
-            end
-          }
+      if config[:strip_trailing_slash] == :redirect && request.path =~ %r{[^/]/+$}
+        query_string = request.query_string.empty? ? '' : '?' << request.query_string
+        redirect(request.path.chomp('/') + query_string, status: 307, halt: false)
+        return response.finish
+      end
+
+      run_around_filters do
+        begin
+          pass if config[:auto_pass] && eligable_matches.empty?
+
+          if run_ba_filters(:before)
+            catch(:halt) {
+              begin
+                try_matches
+              rescue => inner_error
+                rescue_block.call(inner_error)
+              end
+            }
+          end
+          run_ba_filters(:after)
+        rescue => outer_error
+          outer_error == inner_error ? raise : catch(:halt) { rescue_block.call(outer_error) }
         end
-        run_filters(:after)
-      rescue => outer_error
-        outer_error == inner_error ? raise : catch(:halt) { rescue_block.call(outer_error) }
       end
       response.finish
     end
@@ -328,6 +342,9 @@ module Scorched
     # Overriding this method provides the opportunity for one to have more control over how mapping targets are invoked.
     def dispatch(match)
       @_dispatched = true
+      if String === match.mapping[:target] || Symbol === match.mapping[:target]
+        match.mapping[:target] = Object.const_get(match.mapping[:target]) # Resolve symbol to constant, and replace target to avoid future lookups
+      end
       target = match.mapping[:target]
       response.merge! begin
         if Proc === target
@@ -595,21 +612,48 @@ module Scorched
 
   private
 
-    # Returns false if any of the filters halted the request. True otherwise.
-    def run_filters(type)
+    # Wraps the given block with the chain of around filters, outermost first, and calls it. Each filter is passed
+    # a proc representing the rest of the chain (the next around filter, or the wrapped block if there are no more),
+    # and is responsible for calling it to continue processing the request.
+    # As with before/after filters, a filter inherited by both an outer and inner controller (e.g. via `controller`
+    # sub-mapping) only runs once per request, tracked via the shared `env`.
+    def run_around_filters(&core)
+      tracker = filter_tracker(:around)
+      chain = filters[:around].to_a.reverse.reduce(core) do |inner, f|
+        proc do
+          if tracker.include?(f) || check_for_failed_condition(f[:conditions])
+            inner.call
+          else
+            tracker << f
+            instance_exec(inner, &f[:proc])
+          end
+        end
+      end
+      catch(:halt) { chain.call }
+    end
+
+    # Returns false if any of the before/after filters halted the request. True otherwise.
+    def run_ba_filters(type)
       halted = false
-      tracker = env['scorched.executed_filters'] ||= {before: Set.new, after: Set.new}
-      filters[type].reject { |f| tracker[type].include?(f) }.each do |f|
+      tracker = filter_tracker(type)
+      filters[type].reject { |f| tracker.include?(f) }.each do |f|
         unless check_for_failed_condition(f[:conditions]) || (halted && !f[:force])
-          tracker[type] << f
-          halted = true unless run_filter(f)
+          tracker << f
+          halted = true unless run_ba_filter(f)
         end
       end
       !halted
     end
 
-    # Returns false if the filter halted. True otherwise.
-    def run_filter(f)
+    # Returns the set of filters of the given type that have already executed for this request, tracked in `env` so
+    # an inherited filter isn't run twice across nested controller dispatches.
+    def filter_tracker(type)
+      tracker = env['scorched.executed_filters'] ||= {}
+      tracker[type] ||= Set.new
+    end
+
+    # Returns false if the before/after filter halted. True otherwise.
+    def run_ba_filter(f)
       catch(:halt) do
         instance_exec(&f[:proc])
         return true

data/lib/scorched/request.rb

@@ -33,7 +33,7 @@ module Scorched
     # The unescaped URL, excluding the escaped forward-slash and percent. The resulting string will always be safe
     # to unescape again in situations where the forward-slash or percent are expected and valid characters. 
     def unescaped_path
-      path_info.split(/(%25|%2F)/i).each_slice(2).map { |v, m| CGI.unescape(v) << (m || '') }.join('')
+      path_info.split(/(%25|%2F|\+)/i).each_slice(2).map { |v, m| CGI.unescape(v) << (m || '') }.join('')
     end
     
   private

data/lib/scorched/response.rb

@@ -5,10 +5,10 @@ module Scorched
     def merge!(response)
       return self if response == self
       if Rack::Response === response
-        response = [response.status, response.header, response]
+        response = [response.status, response.headers, response]
       end
       self.status, self.body = response[0], response[2]
-      self.header.merge!(response[1])
+      self.headers.merge!(response[1])
       self
     end
 
@@ -24,12 +24,12 @@ module Scorched
       self['Content-Type'] ||= 'text/html;charset=utf-8'
       @block = block if block
       if [204, 205, 304].include?(status.to_i)
-        header.delete "Content-Type"
-        header.delete "Content-Length"
+        delete_header "Content-Type"
+        delete_header "Content-Length"
         close
-        [status.to_i, header, []]
+        [status.to_i, headers, []]
       else
-        [status.to_i, header, body]
+        [status.to_i, headers, body]
       end
     end
 

data/lib/scorched/static.rb

@@ -12,7 +12,7 @@ module Scorched
   protected
 
     def file_server
-      @file_server ||= Rack::File.new(@dir)
+      @file_server ||= Rack::Files.new(@dir)
     end
   end
 end

data/lib/scorched/version.rb

@@ -1,3 +1,3 @@
 module Scorched
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/lib/scorched.rb

@@ -2,6 +2,7 @@ ENV['APP_ENV'] ||= ENV['RACK_ENV'] || 'development'
 
 # Gems
 require 'rack'
+require 'rack/session'
 require 'rack/accept'
 require 'scorched/accept'
 require 'tilt'

data/scorched.gemspec

@@ -13,10 +13,12 @@ Gem::Specification.new 'scorched', Scorched::VERSION do |s|
 
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_dependency 'rack', '~> 2.0'
+  s.add_dependency 'rack', '~> 3.0'
+  s.add_dependency 'rack-session', '~> 2.1'
   s.add_dependency 'rack-accept', '~> 0.4' # Used for Accept-Charset, Accept-Encoding and Accept-Language headers.
   s.add_dependency 'scorched-accept', '~> 0.1' # Used for Accept header.
   s.add_dependency 'tilt', '~> 2.0'
+  s.add_dependency 'logger', '~> 1.7'
   s.add_development_dependency 'rack-test', '>= 1.0'
   s.add_development_dependency 'rspec', '>= 3.4'
   s.add_development_dependency 'rake', '>= 10.4'

data/spec/controller_spec.rb

@@ -1,4 +1,5 @@
 require_relative './helper.rb'
+require 'securerandom'
 
 module Scorched
   describe Controller do
@@ -72,7 +73,7 @@ module Scorched
         response.status.should == 200
       end
 
-      it "unescapes all characters except for the forward-slash and percent sign" do
+      it "unescapes all characters except for the forward-slash, percent sign and plus" do
         app.map pattern: '/a (quite) big fish', target: generic_handler
         rt.get('/a%20%28quite%29%20big%20fish').status.should == 200
         app.map pattern: '/article/100%25 big%2Fsmall', target: generic_handler
@@ -80,6 +81,13 @@ module Scorched
         app.map pattern: '/*$', target: generic_handler
         rt.get('/page%2Fabout').status.should == 200
         rt.get('/page/about').status.should == 404
+
+        app.get('/foo/*') { |x| x }
+        app.map pattern: '/bar', target: Class.new(Scorched::Controller) {
+          get('/*') { |x| x }
+        }
+        rt.get('/foo/hello%2Bworld').body.should == 'hello+world'
+        rt.get('/bar/hello%2Bworld').body.should == 'hello+world'
       end
 
       it "unmatched path doesn't always begin with a forward slash" do
@@ -342,7 +350,7 @@ module Scorched
         inner_env['SCRIPT_NAME'].should == '/article'
         inner_env['PATH_INFO'].should == '/name'
       end
-
+      
       example "PATH_INFO and SCRIPT_NAME joined, should produce a full path" do
         app.controller '/article/' do
           get '/name' do
@@ -413,7 +421,7 @@ module Scorched
       end
     end
 
-    describe "before/after filters" do
+    describe "before/after/around filters" do
       they "run directly before and after the target action" do
         order = []
         app.get('/') { order << :action }
@@ -532,6 +540,101 @@ module Scorched
       end
     end
 
+    describe "after filters" do
+      they "wrap around the before/action/after cycle, outermost first" do
+        order = []
+        app.around { |cont| order << :first_before; cont.call; order << :first_after }
+        app.around { |cont| order << :second_before; cont.call; order << :second_after }
+        app.before { order << :before }
+        app.after { order << :after }
+        app.get('/') { order << :action }
+        rt.get('/')
+        order.should == %i{first_before second_before before action after second_after first_after}
+      end
+
+      they "run in the context of the controller (same as the route)" do
+        route_instance = nil
+        around_instance = nil
+        app.get('/') { route_instance = self }
+        app.around { |cont| around_instance = self; cont.call }
+        rt.get('/')
+        route_instance.should == around_instance
+      end
+
+      they "run even if no route matches" do
+        counter = 0
+        app.around { |cont| counter += 1; cont.call }
+        rt.delete('/').status.should == 404
+        counter.should == 1
+      end
+
+      they "can take an optional set of conditions" do
+        counter = 0
+        app.around(method: ['GET', 'PUT']) { |cont| counter += 1; cont.call }
+        app.get('/') { }
+        app.put('/') { }
+        rt.post('/')
+        rt.get('/')
+        rt.put('/')
+        counter.should == 2
+      end
+
+      they "skip the target action, and everything else in the chain, if the continuation is never called" do
+        action_called = false
+        app.before { }
+        app.around { |cont| }
+        app.get('/') { action_called = true }
+        rt.get('/').status.should == 200
+        action_called.should == false
+      end
+
+      they "still unwind (run code after the continuation) even if the action halts" do
+        order = []
+        app.around { |cont| order << :before; cont.call; order << :after }
+        app.get('/') { order << :action; halt 200, 'stopped' }
+        response = rt.get('/')
+        response.body.should == 'stopped'
+        order.should == %i{before action after}
+      end
+
+      they "still unwind even if the action raises, once the error is handled" do
+        order = []
+        app.around { |cont| order << :before; cont.call; order << :after }
+        app.get('/') { raise 'boom' }
+        app.error { |e| order << :error; halt 500 }
+        rt.get('/').status.should == 500
+        order.should == %i{before error after}
+      end
+      
+      describe "nesting" do
+        example "around filters inherit but only run once" do
+          around_counter = 0
+          app.around { |cont| around_counter += 1; cont.call }
+          subcontroller = app.controller { get('/') { 'wow' } }
+          subcontroller.filters[:around].should == app.filters[:around]
+
+          rt.get('/')
+          around_counter.should == 1
+
+          # Hitting the subcontroller directly should yield the same results.
+          around_counter = 0
+          Rack::Test::Session.new(subcontroller).get('/')
+          around_counter.should == 1
+        end
+
+        example "around filters wrap from outermost to innermost" do
+          order = []
+          app.around { |cont| order << :outer_before; cont.call; order << :outer_after }
+          app.controller do
+            around { |cont| order << :inner_before; cont.call; order << :inner_after }
+            get('/') { order << :action }
+          end
+          rt.get('/')
+          order.should == %i{outer_before inner_before action inner_after outer_after}
+        end
+      end
+    end
+
     describe "error filters" do
       let(:app) do
         Class.new(Scorched::Controller) do
@@ -962,14 +1065,14 @@ module Scorched
         app.get('/') { rack_session = session }
         rt.get('/')
         rack_session.should be_nil
-        app.middleware << proc { use Rack::Session::Cookie, secret: 'test' }
+        app.middleware << proc { use Rack::Session::Cookie, secret: SecureRandom.gen_random(64) }
         rt.get('/')
         rack_session.should be_a(Rack::Session::Abstract::SessionHash)
       end
 
       describe "flash" do
         before(:each) do
-          app.middleware << proc { use Rack::Session::Cookie, secret: 'test' }
+          app.middleware << proc { use Rack::Session::Cookie, secret: SecureRandom.gen_random(64) }
         end
 
         it "keeps session variables that live for one page load" do

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Tom Wardrop
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -16,14 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-session
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rack-accept
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
@@ -175,7 +202,6 @@ homepage: http://scorchedrb.com
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -190,8 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 4.0.13
 specification_version: 4
 summary: Light-weight, DRY as a desert, web framework for Ruby
 test_files: