scorched 0.27 → 1.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 492839ee866fd2c9d5eaf33de738c1661008ed93
-  data.tar.gz: 2ce3ad605482f1d5a96973cddb4fa4ab910d4db7
+  metadata.gz: 88dac2edee54f46c4bea80fdb1e9d521ae23eb5e
+  data.tar.gz: 8aff4a99ef904555fe547b3f305731fa818c3d46
 SHA512:
-  metadata.gz: 2cecfe761d1070e78f7b112dd158aed15768dbe3be19e9953c24c578b36b26487f3f4905632a4346326fe9d3eaa0a948dd7e9724c0aec6643b2bd2f80a02861e
-  data.tar.gz: 9f21239c86254de3d08c1c03672a053d7a6163b4afafe2c6aa662801702dd36a77b5ed4e93934fce5f74c8d7bf212e84f6cf6757767b7636b5f6f0f374eca374
+  metadata.gz: aa17c2cb4ad6bd62eaee321941016471273c1a73a3344e459c57ccd65687aba9ff352b3674e193024afbc5b3f6f65da20b69a35a5a7fddb3446179731200253b
+  data.tar.gz: d68e85e3ac64e463ac503d2c6621fee4b60798a055f613e4604287faa80e1753fd2cb03ffa2cf7240b9365100d3c76d3666d165147bc8e04bcfa3e5853ba6aaa

data/CHANGES.md

@@ -3,6 +3,11 @@ Changelog
 
 _Note that Scorched is yet to reach a v1.0 release. This means breaking changes may still be made. If upgrading the version of Scorched for your project, review this changelog carefully._
 
+### v1.0.0.pre
+* Refactored `process` method. Now named `respond`, and breaks out to other methods. The logic surrounding filters and halting has also been modified, as is now more intuitive in my opinion.
+* Removed `@_handled` instance variable, and the related `handled` condition.
+* `redirect` method signature has changed.
+* Scorched now depends on Rack 2.0 or above.
 ### v0.27
 * Fixed logic surrounding when a requested is considered "handled" (i.e. matched and dispatched) and exceptions that are raised after dispatch. In simpler terms, the `failed_condition` condition now has better logic in the event of an exception.
 ### v0.26

data/TODO.md

@@ -17,4 +17,3 @@ Refactor Considerations
 If I undergo a significant refactor of Scorched, here's a list of things I'd like to improve:
 
 * Create a basic plugin system for optional features which may incur a performance and/or complexity overhead, e.g. Symbol matchers, content for. This will also negate the need for any kind of `contrib` library.
-* Make route dispatching more modular, perhaps by simply breaking it out into more individual methods, making it more practical to override default behaviour.

data/examples/simple.ru

@@ -1,13 +1,18 @@
 require File.expand_path('../../lib/scorched.rb', __FILE__)
 
 class App < Scorched::Controller
-  get '/:name' do
-    @message = greeting(captures[:name])
-    render :hello
+  get '/' do
+    'root'
   end
 
-  def greeting(name)
-    "Howdy #{name}"
+  controller '/' do
+    get '/login' do
+      'login'
+    end
+
+    get '/logout' do
+      'logout'
+    end
   end
 end
 

data/lib/scorched/controller.rb

@@ -55,7 +55,7 @@ module Scorched
         [*encodings].any? { |encoding| env['rack-accept.request'].encoding? encoding }
       },
       failed_condition: proc { |conditions|
-        if !matches.empty? && matches.any? { |m| m.failed_condition } && !@_handled
+        if !matches.empty? && matches.any? { |m| m.failed_condition } && !@_dispatched
           matches.first.failed_condition && [*conditions].include?(matches.first.failed_condition[0])
         end
       },
@@ -71,9 +71,6 @@ module Scorched
       method: proc { |methods|
         [*methods].include?(request.request_method)
       },
-      handled: proc { |bool|
-        @_handled == bool
-      },
       proc: proc { |blocks|
         [*blocks].all? { |b| instance_exec(&b) }
       },
@@ -118,7 +115,7 @@ module Scorched
         unless @instance_cache[key]
           builder = Rack::Builder.new
           to_load.each { |proc| builder.instance_exec(self, &proc) }
-          builder.run(lambda { |env| self.new(env).process })
+          builder.run(lambda { |env| self.new(env).respond })
           @instance_cache[key] = builder.to_app
         end
         loaded.merge(to_load)
@@ -274,7 +271,8 @@ module Scorched
 
     # This is where the magic happens. Applies filters, matches mappings, applies error handlers, catches :halt and
     # :pass, etc.
-    def process
+    # Returns a rack-compatible tuple
+    def respond
       inner_error = nil
       rescue_block = proc do |e|
         (env['rack.exception'] = e && raise) unless filters[:error].any? do |f|
@@ -285,61 +283,47 @@ module Scorched
       end
 
       begin
-        catch(:halt) do
-          if config[:strip_trailing_slash] == :redirect && request.path =~ %r{[^/]/+$}
-            query_string = request.query_string.empty? ? '' : '?' << request.query_string
-            redirect(request.path.chomp('/') + query_string, 307)
-          end
-          eligable_matches = matches.reject { |m| m.failed_condition }
-          pass if config[:auto_pass] && eligable_matches.empty?
-          run_filters(:before)
-          begin
-            # Re-order matches based on media_type, ensuring priority and definition order are respected appropriately.
-            eligable_matches.each_with_index.sort_by { |m,idx|
-              [
-                m.mapping[:priority] || 0,
-                [*m.mapping[:conditions][:media_type]].map { |type|
-                  env['scorched.accept'][:accept].rank(type, true)
-                }.max || 0,
-                -idx
-              ]
-            }.reverse.each { |match,idx|
-              request.breadcrumb << match
-              catch(:pass) {
-                begin
-                  catch(:halt) do
-                    dispatch(match)
-                  end
-                rescue
-                  @_handled = true
-                  raise
-                end
-                @_handled = true
-              }
-              break if @_handled
-              request.breadcrumb.pop
-            }
-            unless @_handled
-              response.status = (!matches.empty? && eligable_matches.empty?) ? 403 : 404
+        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
-          rescue => inner_error
-            rescue_block.call(inner_error)
-          end
-          run_filters(:after)
-          true
-        end || begin
-          run_filters(:before, true)
-          run_filters(:after, true)
+          }
         end
+        run_filters(:after)
       rescue => outer_error
         outer_error == inner_error ? raise : catch(:halt) { rescue_block.call(outer_error) }
       end
       response.finish
     end
 
+    # Tries to dispatch to each eligable match. If the first match _passes_, tries the second match and so on.
+    # If there are no eligable matches, or all eligable matches pass, an appropriate 4xx response status is set.
+    def try_matches
+      eligable_matches.each do |match,idx|
+        request.breadcrumb << match
+        catch(:pass) {
+          dispatch(match)
+          return true
+        }
+        request.breadcrumb.pop # Current match passed, so pop the breadcrumb before the next iteration.
+      end
+      response.status = (!matches.empty? && eligable_matches.empty?) ? 403 : 404
+    end
+
     # Dispatches the request to the matched target.
-    # Overriding this method provides the oppurtunity for one to have more control over how mapping targets are invoked.
+    # Overriding this method provides the opportunity for one to have more control over how mapping targets are invoked.
     def dispatch(match)
+      @_dispatched = true
       target = match.mapping[:target]
       response.merge! begin
         if Proc === target
@@ -359,24 +343,41 @@ module Scorched
     # 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.map { |mapping|
-        mapping[:pattern].match(to_match) do |match_data|
-          if match_data.pre_match == ''
-            if match_data.names.empty?
-              captures = match_data.captures
-            else
-              captures = Hash[match_data.names.map {|v| v.to_sym}.zip(match_data.captures)]
-              captures.each do |k,v|
-                captures[k] = symbol_matchers[k][1].call(v) if Array === symbol_matchers[k]
+      @_matches ||= begin
+        to_match = request.unmatched_path
+        to_match = to_match.chomp('/') if config[:strip_trailing_slash] == :ignore && to_match =~ %r{./$}
+        mappings.map { |mapping|
+          mapping[:pattern].match(to_match) do |match_data|
+            if match_data.pre_match == ''
+              if match_data.names.empty?
+                captures = match_data.captures
+              else
+                captures = Hash[match_data.names.map {|v| v.to_sym}.zip(match_data.captures)]
+                captures.each do |k,v|
+                  captures[k] = symbol_matchers[k][1].call(v) if Array === symbol_matchers[k]
+                end
               end
+              Match.new(mapping, captures, match_data.to_s, check_for_failed_condition(mapping[:conditions]))
             end
-            Match.new(mapping, captures, match_data.to_s, check_for_failed_condition(mapping[:conditions]))
           end
-        end
-      }.compact
+        }.compact
+      end
+    end
+
+    # Returns an ordered list of eligable matches.
+    # Orders matches based on media_type, ensuring priority and definition order are respected appropriately.
+    # Sorts by mapping priority first, media type appropriateness second, and definition order third.
+    def eligable_matches
+      @_eligable_matches ||= begin
+        matches.select { |m| m.failed_condition.nil? }.each_with_index.sort_by do |m,idx|
+          priority = m.mapping[:priority] || 0
+          media_type_rank = [*m.mapping[:conditions][:media_type]].map { |type|
+            env['scorched.accept'][:accept].rank(type, true)
+          }.max || 0
+          order = -idx
+          [priority, media_type_rank, order]
+        end.reverse
+      end
     end
 
     # Tests the given conditions, returning the name of the first failed condition, or nil otherwise.
@@ -397,9 +398,10 @@ module Scorched
     end
 
     # Redirects to the specified path or URL. An optional HTTP status is also accepted.
-    def redirect(url, status = (env['HTTP_VERSION'] == 'HTTP/1.1') ? 303 : 302)
+    def redirect(url, status: (env['HTTP_VERSION'] == 'HTTP/1.1') ? 303 : 302, halt: true)
       response['Location'] = absolute(url)
-      halt(status)
+      response.status = status
+      self.halt if halt
     end
 
     # call-seq:
@@ -523,10 +525,10 @@ module Scorched
 
     # Takes an optional URL, relative to the applications root, and returns a fully qualified URL.
     # Example: url('/example?show=30') #=> https://localhost:9292/myapp/example?show=30
-    def url(path = nil)
+    def url(path = nil, scheme: nil)
       return path if path && URI.parse(path).scheme
       uri = URI::Generic.build(
-        scheme: env['rack.url_scheme'],
+        scheme: scheme || env['rack.url_scheme'],
         host: env['SERVER_NAME'],
         port: env['SERVER_PORT'].to_i,
         path: env['scorched.root_path'],
@@ -588,20 +590,26 @@ module Scorched
 
   private
 
-    def run_filters(type, forced_only = false)
+    # Returns false if any of the filters halted the request. True otherwise.
+    def run_filters(type)
+      halted = false
       tracker = env['scorched.executed_filters'] ||= {before: Set.new, after: Set.new}
-      filters[type].reject{ |f| tracker[type].include?(f) || (forced_only && !f[:force]) }.each do |f|
-        unless check_for_failed_condition(f[:conditions])
+      filters[type].reject { |f| tracker[type].include?(f) }.each do |f|
+        unless check_for_failed_condition(f[:conditions]) || (halted && !f[:force])
           tracker[type] << f
-          if forced_only
-            catch(:halt) do
-              instance_exec(&f[:proc]); true
-            end or log.warn "Ignored halt while running forced filters."
-          else
-            instance_exec(&f[:proc])
-          end
+          halted = true unless run_filter(f)
         end
       end
+      !halted
+    end
+
+    # Returns false if the filter halted. True otherwise.
+    def run_filter(f)
+      catch(:halt) do
+        instance_exec(&f[:proc])
+        return true
+      end
+      return false
     end
 
     def log(type = nil, message = nil)

data/lib/scorched/match.rb

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

data/lib/scorched/response.rb

@@ -33,6 +33,8 @@ module Scorched
       end
     end
 
+    attr_accessor :halted
+
     alias :to_a :finish
     alias :to_ary :finish
   end

data/lib/scorched/version.rb

@@ -1,3 +1,3 @@
 module Scorched
-  VERSION = '0.27'
+  VERSION = '1.0.0.pre'
 end

data/scorched.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new 'scorched', Scorched::VERSION do |s|
 
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_dependency 'rack', '~> 1.4'
+  s.add_dependency 'rack', '~> 2.0'
   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', '~> 1.4'

data/spec/controller_spec.rb

@@ -189,7 +189,7 @@ module Scorched
 
       it "can coerce symbol-matched values" do
         app << {pattern: '/:numeric', target: proc { |env| [200, {}, [request.captures[:numeric].class.name]] }}
-        rt.get('/45').body.should == 'Fixnum'
+        rt.get('/45').body.should == 'Integer'
       end
 
       it "matches routes based on priority, otherwise giving precedence to those defined first" do
@@ -681,15 +681,25 @@ module Scorched
         rt.get('/').status.should == 600
       end
 
+      it "prevents matches from being invoked if a before filter has halted" do
+        app.before { halt}
+        app.get('/') { "success" }
+        rt.get('/').body.should_not == 'success'
+      end
+
       describe "within filters" do
-        it "short circuits filters if halted within filter" do
-          app.before { halt }
+        it "only short circuits other filters of same type if halted within filter" do
           app.after { response.status = 600 }
-          rt.get('/').status.should_not == 600
+          app.after { halt }
+          app.after { response.status = 601 }
+          rt.get('/').status.should == 600
+
+          app.before { halt }
+          rt.get('/').status.should == 600
         end
 
         it "forced filters are always run" do
-          app.before { halt }
+          app.after { halt }
           app.after(force: true) { response.status = 600 }
           app.after { response.status = 700 } # Shouldn't run because it's not forced
           app.get('/') { 'hello' }
@@ -720,7 +730,7 @@ module Scorched
       end
 
       it "allows the HTTP status to be overridden" do
-        app.get('/') { redirect '/somewhere', 308 }
+        app.get('/') { redirect '/somewhere', status: 308 }
         rt.get('/').status.should == 308
       end
 
@@ -736,9 +746,11 @@ module Scorched
 
       it "works in filters" do
         app.error { redirect '/somewhere' }
-        app.get('/') { raise "Some error" }
-        rt.get('/').location.should == '/somewhere'
+        app.get('/error') { raise "Some error" }
+        rt.get('/error').location.should == '/somewhere'
+
         app.before { redirect '/somewhere_else' }
+        app.get('/') { redirect '/meow' }
         rt.get('/').location.should == '/somewhere_else'
       end
     end
@@ -778,17 +790,6 @@ module Scorched
         }.to raise_error(ArgumentError)
       end
 
-      it "is not considered a match if a mapping passes the request" do
-        app.get('/*') { pass }
-        app.get('/nopass') {  }
-        handled = nil
-        app.after { handled = @_handled }
-        rt.get('/').status.should == 404 # 404 if matched, but passed
-        handled.should be_falsey
-        rt.get('/nopass').status.should == 200
-        handled.should be_truthy
-      end
-
       it "is still considered a match if an exception is raised" do
         app.post('/') {  }
         app.get('/') { raise "Test error"}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: '0.27'
+  version: 1.0.0.pre
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2017-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rack-accept
   requirement: !ruby/object:Gem::Requirement
@@ -186,12 +186,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Light-weight, DRY as a desert, web framework for Ruby