scorched 0.14 → 0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2583f96bd04c7a31f7edf598acd84eaa11689feb
-  data.tar.gz: 8148c65523e21d3aaa68b6dd2dd7ce0ac62eddac
+  metadata.gz: 252309e125591f6ffd81a1ac36bb79c851aabce8
+  data.tar.gz: 4100f0dc1f942fb4067f32e27f966b8fb327c8d8
 SHA512:
-  metadata.gz: 73ed932ce8783845f70c041da390eca59f9bb487b834191a31863a2e8f23290457317db4a8fccf574aaaba3d17530d5e8cd36a739491af61bda024daaab75086
-  data.tar.gz: 8ac3bd00774d449e68e40d90639a937c5b7963c9630b5aa86a478b283b8eb6f5586188bc7cc5bc85d48c6b7c8630b1c22a43aad551ad6488e47ebf6b529abafc
+  metadata.gz: 5cda7022f16ff4d70a47552dbb6563f86e8ece672036b221373a639990c48bd12fbedce6e7989eabe0cf9282a08621eec342a129ea9c74dadd66b0b289642b25
+  data.tar.gz: 6dc0e3f1aef90a462a610f33fc7ffc34f087f5426f7919c2ae555f3599aeb048668fb7c72e3e7e39b6ea4664eeb68048b060b255af6ae2687f9c7d578e5678ff

data/CHANGES.md

@@ -1,6 +1,10 @@
 Changelog
 =========
 
+### v0.15
+* Route DSL methods (`route`, `get`, `post`, ...) now accept an array of patterns as the pattern argument. Each pattern is defined as a separate mapping, sharing the same target proc. This provides a cleaner and more efficient solution to simply wrapping a route definition within a loop.
+* URI unescaping has been implemented for `Scorched::Request#unmatched_path`. This modification directly affects route matching. Previously, routes were matched against the escaped path, e.g. `/this%20has%20spaces`. Routes are now matched against the unescaped form `/this has spaces`. The only exception is the escaped forward-slash `%2F` and percent sign `%25` which remain unaltered for the fact their unescaped form as special meaning which you wouldn't be able to disambiguate. It's however safe to unescape the path a second time to resolve these characters.
+
 ### v0.14
 * If a matched mapping _passes_ the request and there are no other matching mappings, a 404 status is now set by default, rather than a 200 status.
 * Renamed `matched` condition to `handled` to be less ambiguous.

data/README.md

@@ -35,13 +35,13 @@ $ rackup hello_world.ru
 
 #### A Note on Requirements
 
-Scorched requires Ruby 2.0 or above. It's important to ensure your version of Ruby 2.0 includes [changeset 39919](http://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/39919) in order to avoid suffering from [random segmentation faults](http://bugs.ruby-lang.org/issues/8100). Ruby 2.0.0-p195 and newer include the fix, otherwise you can manually patch it during installation.
+Scorched requires Ruby 2.0 or above. If you've got Ruby 2.0.0-p195 and newer, you're good. Otherwise, you need to ensure that your version of Ruby 2.0 includes [changeset 39919](http://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/39919) in order to avoid suffering from [random segmentation faults](http://bugs.ruby-lang.org/issues/8100).
 
-The Errors of Our Past
+The Errors of Our Past (and Present!)
 ----------------------
-One of the mistakes made by a lot of other Ruby frameworks, was to not leverage the power of the class. The consequences of this made for some awkwardness. Helpers for example, are a classical reinvention of what classes and modules were already made to solve. Scorched implements Controllers as classes, which in addition to having their own DSL, allow defining and calling traditional instance methods. The decision to allow developers to implement helpers and other common functionality as proper methods not only makes Controllers somewhat more predictable and familiar, but of course allow such helpers to be inheritable via plain-old class inheritance.
+One of the mistakes made by a lot of other Ruby frameworks is to not leverage the power of the class. The consequences of this have made for some awkwardness. Helpers, for example, are a classical reinvention of what classes and modules are already made to solve. Scorched implements Controllers as classes, which, in addition to having their own DSL, allow you to define and call whatever you need as traditional instance methods. The decision to allow developers to implement helpers and other common functionality as proper methods not only makes Controllers somewhat more predictable and familiar, but also allows for such helpers to be inheritable via plain-old class inheritance.
 
-Perhaps another design oversight of other frameworks, has been the lack of consideration for the hierarchical nature of websites, and the fact that sub-directories are often expected to inherit attributes of their parents. Scorched supports sub-controllers to any arbitrary depth, with each controllers configuration, filters, route conditions, etc, applied along the way. This can assist many areas of web development, including security, restful interfaces, and interchangeable content types.
+Perhaps another design oversight of other frameworks has been the lack of consideration for the hierarchical nature of websites, and the fact that sub-directories are often expected to inherit attributes of their parents. Scorched supports sub-controllers to any arbitrary depth, with each controller's configuration, filters, route conditions, etc. applied along the way. This can help in many areas of web development, including security, restful interfaces, and interchangeable content types.
 
 
 Design Philosophy

data/Rakefile

@@ -11,8 +11,10 @@ task :test => :spec
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :release => [:spec, :'gem:install', :commit_version, :'gem:release', :clean]
+desc 'Releases a new version of Scorched.'
+task :release => [:prerelease, :spec, :'gem:install', :commit_version, :'gem:release', :clean]
 
+desc 'Commits and tags git repository as new version, pushing up to github'
 task :commit_version do
   sh "git commit --allow-empty -a -m 'v#{Scorched::VERSION} release.'  &&
     git tag -a #{Scorched::VERSION} -m 'v#{Scorched::VERSION} release.'  &&
@@ -20,6 +22,15 @@ task :commit_version do
     git push --tags"
 end
 
+desc 'Displays a pre-release message, requiring user input'
+task :prerelease do
+  puts <<-MSG
+
+About to release Scorched v#{Scorched::VERSION}. Please ensure CHANGES log is up-to-date, all relevant documentation is updated, and that any new files not under version control have been added/staged. Press any key to continue...
+  MSG
+  STDIN.gets
+end
+
 namespace :gem do
   require "bundler/gem_tasks"
 end

data/docs/02_fundamentals/03_routing.md

@@ -33,9 +33,9 @@ end
 
 You can see pretty clearly how these examples correspond to the pattern, priority, conditions and target options of a manual mapping. The pattern, priority and conditions behave exactly as they do for a manual mapping, with a couple of exceptions.
 
-The first exception is that the pattern must match to the end of the request path. This is mentioned in the _pattern matching_ section below.
+The first exception is that the pattern must match to the end of the request path. This is mentioned in the _pattern matching_ section below. You can also define a route with multiple patterns by using an array. This creates a different mapping for each URL, but using the same proc object and other arguments.
 
-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.
+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 arguments 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 `: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.
 
@@ -44,6 +44,10 @@ Pattern Matching
 All patterns attempt to match the remaining unmatched portion of the _request path_; the _request path_ being Rack's
 `path_info` request variable. The unmatched path will always begin with a forward slash if the previously matched portion of the path ended immediately before, or included as the last character, a forward slash. As an example, if the request was to "/article/21", then both "/article/" => "/21" and "/article" => "/21" would match.
 
+The `path_info` used to match against is unescaped, meaning percent-codes are resolved, e.g. `%20` resolves to a space. The two exceptions are the escaped forward-slash and percent sign, which remain escaped as `%2F` and `%25` respectively.
+
+> The forward-slash cannot be automatically escaped as it would make it impossible to disambiguate from an actual forward-slash in the URL (which has special meaning). The encoded percent-sign thus also needs to remain unescaped, otherwise it'd be impossible to safely unescape the escaped forward-slash in your application, if you needed to. If this all sounds very confusing, rest assured you probably won't ever encounter a scenario in which you'd have to think about this.
+
 All patterns must match from the beginning of the path. So even though the pattern "article" would match "/article/21", it wouldn't count as a match because the match didn't start at a non-zero offset.
 
 If a pattern contains named captures, unnamed captures will be lost - this is how named regex captures work in Ruby. So if you name one capture, make sure you name any other captures you may want to access.

data/examples/test.ru

@@ -1,12 +1,9 @@
 require File.expand_path('../../lib/scorched.rb', __FILE__)
 
 class MyApp < Scorched::Controller
-  controller '/' do
-
-  end
-  
-  after do
-    p @_matched
+  get '/*' do |part|
+    p part
+    part
   end
 end
     

data/lib/scorched/controller.rb

@@ -170,7 +170,9 @@ module Scorched
           env['scorched.response'].body = instance_exec(*env['scorched.request'].captures, &block)
           env['scorched.response']
         end
-        self << {pattern: compile(pattern, true), priority: priority, conditions: conds, target: target} if pattern
+        [*pattern].compact.each do |pattern|
+          self << {pattern: compile(pattern, true), priority: priority, conditions: conds, target: target}
+        end
         target
       end
       

data/lib/scorched/request.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Scorched
   class Request < Rack::Request
     # Keeps track of the matched URL portions and what object handled them. Useful for debugging and building
@@ -23,11 +25,16 @@ module Scorched
     
     # The remaining portion of the path that has yet to be matched by any mappings.
     def unmatched_path
-      path = path_info.partition(matched_path).last
+      path = unescaped_path.partition(matched_path).last
       path[0,0] = '/' if path.empty? || matched_path[-1] == '/'
       path
     end
-  
+    
+    # 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| URI.unescape(v) << (m || '') }.join('')
+    end
   private
     
     # Joins an array of path segments ensuring a single forward slash seperates them.

data/lib/scorched/version.rb

@@ -1,3 +1,3 @@
 module Scorched
-  VERSION = '0.14'
+  VERSION = '0.15'
 end

data/spec/controller_spec.rb

@@ -72,6 +72,16 @@ module Scorched
         response.status.should == 200
       end
       
+      it "unescapes all characters except for the forward-slash and percent sign" do
+        app << {pattern: '/a (quite) big fish', target: generic_handler}
+        rt.get('/a%20%28quite%29%20big%20fish').status.should == 200
+        app << {pattern: '/article/100%25 big%2Fsmall', target: generic_handler}
+        rt.get('/article/100%25%20big%2Fsmall').status.should == 200
+        app << {pattern: '/*$', target: generic_handler}
+        rt.get('/page%2Fabout').status.should == 200
+        rt.get('/page/about').status.should == 404
+      end
+      
       it "unmatched path doesn't always begin with a forward slash" do
         gh = generic_handler
         app << {pattern: '/ab', target: Class.new(Scorched::Controller) do
@@ -238,6 +248,13 @@ module Scorched
         end
         rt.get('/')
       end
+      
+      it "can take an array of patterns" do
+        app.get(['/', '/dog']) { 'rad' }
+        rt.get('/dog').status.should == 200
+        rt.get('/').status.should == 200
+        rt.get('/cat').status.should == 404
+      end
     end
     
     describe "sub-controllers" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: '0.14'
+  version: '0.15'
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-24 00:00:00.000000000 Z
+date: 2013-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack