scorched 0.15 → 0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 252309e125591f6ffd81a1ac36bb79c851aabce8
-  data.tar.gz: 4100f0dc1f942fb4067f32e27f966b8fb327c8d8
+  metadata.gz: 4f2b6b091aaaea15a4bd11fbcc7d70fc27e783d1
+  data.tar.gz: db2e3b73d7b0f2aa82472f90299915cdfa3e2c4a
 SHA512:
-  metadata.gz: 5cda7022f16ff4d70a47552dbb6563f86e8ece672036b221373a639990c48bd12fbedce6e7989eabe0cf9282a08621eec342a129ea9c74dadd66b0b289642b25
-  data.tar.gz: 6dc0e3f1aef90a462a610f33fc7ffc34f087f5426f7919c2ae555f3599aeb048668fb7c72e3e7e39b6ea4664eeb68048b060b255af6ae2687f9c7d578e5678ff
+  metadata.gz: e937339dd3d1470e201050a395d68f4cf3635c355683c5fee6a4570cc12044e7f584dd57bed84fb01c89ac3cc89ac73f026a1b88cd9dc06dd08fdd79bdf748d7
+  data.tar.gz: 3fb1e340771264fe6738d6ea030e0387cea91fc716fa6b651883194973b12b498dd7b0bee27a6994d64ea126a936c47da057fc45f8f6698793fad553685c58b5

data/CHANGES.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+### v0.16
+* A copy of the Rack env hash is now handed off to sub-controllers and other Rack-callable objects, with `PATH_INFO` and `SCRIPT_NAME` now set to appropriate values, bring Scorched inline with the Rack specification. This differs from the original behaviour which was to just forward on the original env hash unmodified.
+* URL helper method `absolute` and `url` now use the new env property `scorched.root_path` as their base path, rather than `SCRIPT_NAME`.
+* Helpers for HTTP methods `link` and `unlink` have been added.
+
 ### 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.

data/README.md

@@ -39,23 +39,23 @@ Scorched requires Ruby 2.0 or above. If you've got Ruby 2.0.0-p195 and newer, yo
 
 The Errors of Our Past (and Present!)
 ----------------------
-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.
+One of the mistakes made by a lot of other Ruby frameworks is to not leverage the power of the class. Consequentially, this makes 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 standard instance methods. The decision to allow developers to implement helpers and other common functionality as standard instance 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 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.
+Another design oversight of other frameworks is 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
 -----------------
-Scorched has a relatively simple design philosophy. The main objective is to keep Scorched lean and generic. Scorched refrains from expressing any opinion about how you design and structure your application. The general idea is to give developers the constructs to quickly put together small, medium and even large websites and applications.
+Scorched has a relatively simple design philosophy. The main objective is to keep Scorched lean and generic. Scorched refrains from expressing any opinion about how you should design and structure your application. The general idea is to give developers the constructs to quickly put together small, medium and even large websites and applications.
 
-There's little need for a framework to be opinionated if the opinions of the developer can be quickly and easily built into it on a per-application basis. To do this effectively, developers really need to understand Scorched, and the best way to facilitate that is to lower the learning curve by keeping the core design logical, predictable, and concise.
+There is little need for a framework to be opinionated if the opinions of the developer can be quickly and easily built into it on a per-application basis. To do this effectively, developers will really need to understand Scorched, and the best way to facilitate that is to lower the learning curve, by keeping the core design logical, predictable and concise.
 
 
 Magicians Not Welcome
 ---------------------
-Scorched aims to be raw and transparent. Magic has no place. A thoughtful and simple design means there's no requirement for magic. Because of that, most developers should be able to master scorched in an evening.
+Scorched aims to be raw and transparent. Magic has no place. A thoughtful and simple design means there's no requirement for magic. Because of that, most developers should be able to master Scorched in an evening.
 
-Part of what keeps Scorched lightweight, is that unlike other lightweight web frameworks that attempt to hide Rack in the background, Scorched makes no such attempts, very rarely providing functionality that overlaps with what's already provided by Rack. In fact, familiarity with Rack is somewhat of a pre-requisite to mastering Scorched.
+Part of what keeps Scorched lightweight is that unlike other lightweight web frameworks that attempt to hide Rack in the background, Scorched makes no such attempt, very rarely providing functionality that overlaps with what's already provided by Rack. In fact, familiarity with Rack is somewhat of a pre-requisite to mastering Scorched.
 
 
 First Impressions

data/TODO.md

@@ -1,17 +1,13 @@
 To Do
 =====
-* If one or more matches are found, but their conditions don't pass, a 403 should be returned instead of a 404.
 * Make specs for Collection and Options classes more thorough, e.g. test all non-reading modifiers such as clear, delete, etc.
 
 
 Unlikely
 ========
-These features are unlikely to be implemented unless someone provides a good reason.
+These features are unlikely to be implemented unless someone provides good enough justification.
 
 * 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.
+* 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 lull anyone into 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 hysteria. 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.
 * Verbose logging - I originally intended to add some form of debug-style logging to show the complete flow of a request as it traverses through filters and controllers, etc. For a couple of reasons, I've decided to leave this out of Scorched. For those unfamiliar with the order in which filters and routes are invoked, it's better to learn through first-hand experience writing little test applications, rather than depending on debug logging.
-
-
-More things will be added as they're thought of and considered.

data/docs/02_fundamentals/02_configuration.md

@@ -19,9 +19,9 @@ Each configuration is listed below, with the default value of each included. Not
     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.
+    * `:redirect` - Strips and redirects URL's ending in a forward slash. Note that for efficiency sake, the redirection takes place in the first controller that has this option set to `:redirect`, hence a sub-controller that otherwise matches the request will never be invoked, even if it sets `:strip_trailing_slash` to something other than `:redirect`.
+    * `:ignore` - Internally ignores (pretends it doesn't exist) any trailing slash
+    * `false` - Does nothing. Respects the presence of a trailing forward flash, as it would any other trailing character.
 
 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.
 

data/docs/02_fundamentals/03_routing.md

@@ -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 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.
+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`, `patch`, `link` and `unlink`. These methods automatically define the corresponding `:method` condition, with the `get` helper also including `head` as an accepted HTTP method.
 
 Pattern Matching
 ----------------

data/docs/02_fundamentals/07_request_and_session_data.md

@@ -14,6 +14,8 @@ post '/' do
 end
 ```
 
+One of the few opinions Scorched does maintain (albeit without imposition), is that GET and POST data should be accessed by their respective methods. GET and POST data are semantically different, so if you're not concerned about where the data came from, it may be a good sign you're doing something wrong.
+
 Uploaded files are also accessible as ordinary fields, except the associated value is a hash of properties, instead of a string. An example of an application that accepts file uploads is included in the "examples" directory of the Scorched git repository.
 
 Cookies
@@ -28,7 +30,7 @@ def '/' do
 end
 ```
    
-For each of the above lines, the corresponding Rack methods are called, e.g. `Rack::Requeste#cookies`, `Rack::Response#set_cookie` and `Rack::Response#delete_cookie`. The values for setting and deleting a cookie can also be a hash, like `set_cookie` and `delete_cookie` can take directly. Deleting still works when a Hash is provided, as long as the `value` property is nil.
+For each of the above lines, the corresponding Rack methods are called, e.g. `Rack::Requeste#cookies`, `Rack::Response#set_cookie` and `Rack::Response#delete_cookie`. The values for setting and deleting a cookie can also be a hash, as per the documentation for `set_cookie` and `delete_cookie`. Deletion is still possible when a Hash is provided, as long as the `value` property is nil.
 
 ```ruby
 def '/' do
@@ -40,7 +42,7 @@ end
 
 Sessions
 --------
-Sessions are completely handled by Rack. For conveniance, a `session` helper is provided. This merely acts as an alias to `request['rack.session']` however. It was raise an exception if called without any Rack session middleware loaded, such as `Rack::Session::Cookie`.
+Sessions are completely handled by Rack. For convenience, Scorched provides a `session` helper. This merely acts as an alias to `request['rack.session']`. It will raise an exception if called without any Rack session middleware loaded, such as `Rack::Session::Cookie`.
 
 ```ruby
 class App < Scorched::Controller
@@ -54,10 +56,10 @@ class App < Scorched::Controller
 end
 ```
 
-###Flash
-A common requirement for websites, and especially web applications, is to provide a message on the next page load corresponding to an action that a user just performed. A common framework idiom that Scorched happily implements are flash session variables - special session data that lives for only a single page load.
+###Flash Session Data
+A common requirement for websites, especially web applications, is to provide a message on the next page load corresponding to an action that a user has just performed. A common framework idiom that Scorched happily implements are flash session variables - special session data that lives for only a single page load.
 
-This isn't as trivial to implement as it may sound at a glance, which is why Scorched provides this helper.
+This isn't as trivial to implement as it may sound at a glance, which is why Scorched provides this helper out-of-the-box.
 
 ```ruby
 get '/' do

data/docs/02_fundamentals/08_views.md

@@ -1,17 +1,19 @@
 Views
 =====
 
-Scorched uses Tilt to render templates in various supported formats. Because of this, views have been implemented as a single method, `render`.
+Scorched uses Tilt to render templates in various supported formats. Thanks of this abstraction, views have been implemented as a single method `render`.
 
-`render` can take a file path or a string as the template. If a symbol is given, it assumes it's a file path, were as a string is assumed to be the template markup. `render` can also takes a set of options.
+`render` can take a file path or a string as the template. If a symbol is given, it assumes it's a file path, where as a string is assumed to be the template markup. `render` can also take a set of options. These options get their defaults from the `render_defaults` hash, inherited by each sub-controller.
 
 * `:dir` - The directory containing the views. This can be absolute or relative to the current working directory.
 * `:layout` - The template to render _around_ the view.
 * `:engine` - The template engine to use if it can't be derived from the file name. This is always required for string templates. Can be any string or symbol that Tilt recognises, e.g :erb, :haml, :sass, etc.
+* `:locals` - Hash of local variables to be made available in the context of the view.
+* `:tilt` - Options to be passed directly to Tilt. Required to avoid conflicts between Scorched options and the options of some renderers.
 
-Any unrecognised options are passed through to Tilt and the corresponding rendering engine. A common example being the `:locals` option, used to set local variables made available within the scope of the view.
+Any unrecognised options are passed through to Tilt and the corresponding rendering engine. Where such options conflict with those used by Scorched (dependant on the rendering engine), the `:tilt` option provides an unambiguous means to directly pass through those options.
 
-Finally, `render` takes an optional block to be _yielded_ within the view being rendered, if supported by the rendering engine. Layout's use this feature.
+Finally, `render` takes an optional block to be _yielded_ within the view being rendered, if supported by the rendering engine. This feature is used internally as part of the implementation of layouts.
 
 Layouts
 -------
@@ -19,4 +21,4 @@ When a layout is given, a subsequent call to `render` is made, with the rendered
 
 Partials
 --------
-There are cases where a you may want a view to be composed of more than just a layout and a single view. The view may contain one or more sub-views, commonly referred to as partials. Scorched makes provisions for this by ignoring the default layout when `render` is called within a view, hence negating the requirement to explicitly override the layout.
+There are cases where you may want a view to be composed of more than just a layout and a single view. The view may contain one or more sub-views, commonly referred to as partials. Scorched makes provisions for this by ignoring the default layout when `render` is called within a view, hence negating the requirement to explicitly override the layout.

data/docs/02_fundamentals/09_sharing_request_state.md

@@ -12,6 +12,6 @@ before user_agent: /MSIE|Windows/ do
 end
 
 get '/' do
-  "Welcome to #{env['myapp.settings.site_name']}!"
+  "Welcome #{env['myapp.user.name']}!"
 end
 ```

data/docs/03_further_reading/running_unit_tests.md

@@ -3,4 +3,4 @@ Running Unit Tests
 
 If doing any development on Scorched, such as if you want to fork it or contribute patches to it, you will probably want to run the suite of tests that accompany it. The few dependancies required for running the Scorched unit tests are installed either when you install the Scorched gem, or by running `bundle` in the root of the Scorched source tree.
 
-All unit tests have been written using RSpec. To run the tests, `cd` into the root of the Scorched source tree from a terminal, and run `rspec`.
+All unit tests have been written using RSpec. To run the tests, `cd` into the root of the Scorched source tree from a terminal, and run `rspec`. Alternatively, you can run `rake spec` which will achieve the same result.

data/examples/simple.ru

@@ -0,0 +1,9 @@
+require File.expand_path('../../lib/scorched.rb', __FILE__)
+
+class App < Scorched::Controller
+  get '/' do
+    'hello world'
+  end
+end
+
+run App

data/lib/scorched/controller.rb

@@ -9,6 +9,8 @@ module Scorched
     include Scorched::Collection('before_filters')
     include Scorched::Collection('after_filters', true)
     include Scorched::Collection('error_filters')
+
+    attr_reader :request, :response
     
     config << {
       :auto_pass => false, # Automatically _pass_ request back to outer controller if no route matches.
@@ -166,9 +168,9 @@ module Scorched
       #     options(pattern = nil, priority = nil, **conds, &block)
       #     patch(pattern = nil, priority = nil, **conds, &block)
       def route(pattern = nil, priority = nil, **conds, &block)
-        target = lambda do |env|
-          env['scorched.response'].body = instance_exec(*env['scorched.request'].captures, &block)
-          env['scorched.response']
+        target = lambda do
+          response.body = instance_exec(*request.captures, &block)
+          response
         end
         [*pattern].compact.each do |pattern|
           self << {pattern: compile(pattern, true), priority: priority, conditions: conds, target: target}
@@ -176,7 +178,7 @@ module Scorched
         target
       end
       
-      ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'].each do |method|
+      ['get', 'post', 'put', 'delete', 'head', 'options', 'patch', 'link', 'unlink'].each do |method|
         methods = (method == 'get') ? ['GET', 'HEAD'] : [method.upcase]
         define_method(method) do |*args, **conds, &block|
           conds.merge!(method: methods)
@@ -239,8 +241,11 @@ module Scorched
       define_singleton_method :env do
         env
       end
-      env['scorched.request'] ||= Request.new(env)
-      env['scorched.response'] ||= Response.new
+      env['scorched.root_path'] ||= env['SCRIPT_NAME']
+      env['scorched.path_info'] ||= env['PATH_INFO']
+      env['scorched.script_name'] ||= env['SCRIPT_NAME']
+      @request = Request.new(env)
+      @response = Response.new
     end
     
     def action
@@ -266,7 +271,16 @@ module Scorched
               request.breadcrumb << match
               break if catch(:pass) {
                 target = match.mapping[:target]
-                response.merge! (Proc === target) ? instance_exec(env, &target) : target.call(env)
+                response.merge! begin
+                  if Proc === target
+                    instance_exec(&target)
+                  else
+                    target.call(env.merge(
+                      'SCRIPT_NAME' => request.matched_path,
+                      'PATH_INFO' => request.unmatched_path[match.path.length..-1]
+                    ))
+                  end
+                end
                 @_handled = true
               }
               request.breadcrumb.pop
@@ -347,16 +361,6 @@ module Scorched
       throw :pass
     end
     
-    # Convenience method for accessing Rack request.
-    def request
-      env['scorched.request']
-    end
-    
-    # Convenience method for accessing Rack response.
-    def response
-      env['scorched.response']
-    end
-    
     # Convenience method for accessing Rack session.
     def session
       env['rack.session']
@@ -453,7 +457,7 @@ module Scorched
         output
       end
     end
-    
+
     # 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)
@@ -462,7 +466,7 @@ module Scorched
         scheme: env['rack.url_scheme'],
         host: env['SERVER_NAME'],
         port: env['SERVER_PORT'].to_i,
-        path: env['SCRIPT_NAME']
+        path: env['scorched.root_path'],
       )
       if path
         path[0,0] = '/' unless path[0] == '/'
@@ -477,9 +481,9 @@ module Scorched
     def absolute(path = nil)
       return path if path && URI.parse(path).scheme
       return_path = if path
-        [request.script_name, path].join('/').gsub(%r{/+}, '/')
+        [env['scorched.root_path'], path].join('/').gsub(%r{/+}, '/')
       else
-        request.script_name
+        env['scorched.root_path']
       end
       return_path[0] == '/' ? return_path : return_path.insert(0, '/')
     end
@@ -533,4 +537,4 @@ module Scorched
       config[:logger].add(type, message)
     end
   end
-end
+end

data/lib/scorched/request.rb

@@ -25,8 +25,8 @@ module Scorched
     
     # The remaining portion of the path that has yet to be matched by any mappings.
     def unmatched_path
-      path = unescaped_path.partition(matched_path).last
-      path[0,0] = '/' if path.empty? || matched_path[-1] == '/'
+      path = unescaped_path.dup
+      path[0,0] = '/' if (path[0] != '/' && matched_path[-1] == '/') || path.empty?
       path
     end
     
@@ -42,4 +42,4 @@ module Scorched
       paths.join('/').gsub(%r{/+}, '/')
     end
   end
-end
+end

data/lib/scorched/version.rb

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

data/spec/controller_spec.rb

@@ -87,7 +87,9 @@ module Scorched
         app << {pattern: '/ab', target: Class.new(Scorched::Controller) do
           map(pattern: 'out', target: gh)
         end}
-        rt.get('/about').body.should == "ok"
+        resp = rt.get('/about')
+        resp.status.should == 200
+        resp.body.should == "ok"
       end
       
       it "unmatched path begins with forward slash if last match was up to or included a forward slash" do
@@ -264,7 +266,27 @@ module Scorched
         end}
         rt.get('/article/hello-world').body.should == 'hello-world'
       end
-      
+
+      they "have access to original unmangled PATH_INFO via 'scorched.path_info'" do
+        app << {pattern: '/article', target: Class.new(Scorched::Controller) do
+          get('/name') {
+            env['scorched.path_info']
+          }
+        end}
+        rt.get('/article/name').body.should == '/article/name'
+      end
+
+      it "propagates correclty mangles escaped PATH_INFO before passing to sub-controller" do
+        app << {pattern: '/:category', target: Class.new(Scorched::Controller) do
+          get('/:name') {
+            'hello'
+          }
+        end}
+        resp = rt.get('/big%20articles/article%20name')
+        resp.status.should == 200
+        resp.body.should == 'hello'
+      end
+
       describe "controller helper" do
         it "can be given no arguments" do
           app.controller do
@@ -411,6 +433,10 @@ module Scorched
         example "inherited filters which fail to satisfy their conditions are re-evaluated at every level" do
           order = []
           sub_class = app.controller do
+            def initialize(env)
+              super(env)
+              response.status = 500
+            end
             before { order << :third }
             get('/hello') { }
           end
@@ -420,7 +446,6 @@ module Scorched
           end
           app.before do
             order << :first
-            response.status = 500
           end
           rt.get('/hello')
           order.should == %i{first second third}
@@ -588,15 +613,21 @@ module Scorched
       end
       
       it "invokes the next match in parent controller if passed from filter" do
+        effects = []
         app.controller '/sub' do
           get('/') { }
           after do
-            response.body << 'hello'
+            effects.push 1
+            response.body << 'x'
             pass
           end
         end
-        app.get('/sub') { response.body << ' there' }
-        rt.get('/sub').body.should == 'hello there'
+        app.get('/sub') {
+          effects.push 2
+          response.body << 'y'
+        }
+        rt.get('/sub').body.should == 'y'
+        effects.should == [1, 2]
       end
       
       it "results in uncaught symbol if passing within filter of root controller " do
@@ -974,7 +1005,7 @@ module Scorched
       let(:root_app) do
         Class.new(Scorched::Controller)
       end
-      
+
       let(:app) do
         this = self
         builder = Rack::Builder.new
@@ -1001,6 +1032,13 @@ module Scorched
           my_app.get('/') { url(test_url) }
           rt.get('/myapp').body.should == test_url
         end
+        
+        it "generates URL from inside subcontroller defined with controller helper" do
+          root_app.controller '/sub2' do
+            get('/') { url('hi') }
+          end
+          rt.get('https://scorchedrb.com:73/sub2').body.should == 'https://scorchedrb.com:73/hi'
+        end
       end
       
       describe "absolute" do
@@ -1024,8 +1062,15 @@ module Scorched
           my_app.get('/') { absolute(test_url) }
           rt.get('/myapp').body.should == test_url
         end
+        
+        it "returns an absolute URL path for subcontroller defined with controller helper" do
+          root_app.controller '/sub2' do
+            get('/') { absolute }
+          end
+          rt.get('https://scorchedrb.com:73/sub2').body.should == '/'
+        end
       end
     end
 
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scorched
 version: !ruby/object:Gem::Version
-  version: '0.15'
+  version: '0.16'
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-05 00:00:00.000000000 Z
+date: 2013-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -123,7 +123,7 @@ files:
 - docs/03_further_reading/running_unit_tests.md
 - examples/file_upload.ru
 - examples/media_types.ru
-- examples/test.ru
+- examples/simple.ru
 - lib/scorched.rb
 - lib/scorched/collection.rb
 - lib/scorched/controller.rb

data/examples/test.ru

@@ -1,10 +0,0 @@
-require File.expand_path('../../lib/scorched.rb', __FILE__)
-
-class MyApp < Scorched::Controller
-  get '/*' do |part|
-    p part
-    part
-  end
-end
-    
-run MyApp