sinatra-rroute 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38d10acac3a5452cbbce30a6290ea0e381b5a6c0
-  data.tar.gz: fae34365023bd7529d861cfb82f35e1eaacd6eba
+  metadata.gz: 540d92d8facd0fc96d90dbd1ebc535e452f1fd02
+  data.tar.gz: 16f27c900d637268d325a4ad7e18c35686aff6da
 SHA512:
-  metadata.gz: bff81eca8b56be9a0b66d08197268040e419f5beead89550918ec961946233b9a079472b069bfb28eb39f8b7a46e96bb9de9df5af93d94272f3c225e0f0a3d34
-  data.tar.gz: f3acaf70bdf9f67240eae87693cef2535548cd835aac1a87ce289cec3c6c1d9ccad47ff1a1df4a461fb0326377ab73da36ba924d919bf13a1844228d2eaae076
+  metadata.gz: 5db8fe0b35667a730b571c68783d69f35f56d01103c766182971e8abbd2df5f97fa91e8c3a09c0a26a7cc55b909dba19e1a0aca269bad0b37f72db19dee8eefd
+  data.tar.gz: 7736ecdaab8375ea1756aa1611c7e20581d728e9789229349c638ade0c7132bd94b25fc8dbe572597831ba5a62d7910de4378db97ba09aa99ace99c10ebe85bb

data/README.md

@@ -1,8 +1,14 @@
 # Sinatra-rroute
 
-Sinatra-rroute provides Rails-like routes for Sinatra. Using one of the `gget`/`ppost`/`ddelete`/... methods, a route is assigned a name, is mapped to a controller-like method and has a mask to be used by the provided `path` helper function. The `path` helper takes the name of a route, a set of keyword-value mappings, applies them to the mask and gives back the route with each keyword replaced by the associated value.
+Sinatra-rroute provides Rails-like routes for Sinatra. Using one of the
+`gget`/`ppost`/`ddelete`/... methods, a route is assigned a name, is mapped
+to a controller-like method and has a mask to be used by the provided
+`path` helper function. The `path` helper takes the name of a route, a set
+of keyword-value mappings, applies them to the mask and gives back the
+route with each keyword replaced by the associated value.
 
-Routes can also be namespaced. Namespaces can be nested. There can be multiple namespaces per app.
+Routes can also be namespaced. Namespaces can be nested. There can be
+multiple namespaces per app.
 
 ## Setup
 
@@ -22,7 +28,8 @@ Routes can also be namespaced. Namespaces can be nested. There can be multiple n
 
 ### Route Mapping
 
-Mapping routes to controller-like methods works by calling one of the sinatra-rroute mapping methods like so:
+Mapping routes to controller-like methods works by calling one of the
+sinatra-rroute mapping methods like so:
 
         # This will call Sinatra's `get' method behind the scenes.
         gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
@@ -32,9 +39,16 @@ Mapping routes to controller-like methods works by calling one of the sinatra-rr
         ppost '/[uU]ser/new/:name/:age/?' => :create_user, :as =>
           :new_user, :mask => '/user/new/:name/:age/'
 
-The above examples will map GET requests for routes matching the RegEx `'/[uU]ser/:name/:age/?'` to the function `user_info` and POST requests to the route matching the RegEx `'/[uU]ser/new/:name/:age/?'` to the function :create_user. The first route can be referenced as `user`, the second one as `new_user`.
+The above examples will map GET requests for routes matching the RegEx
+`'/[uU]ser/:name/:age/?'` to the function `user_info` and POST requests to
+the route matching the RegEx `'/[uU]ser/new/:name/:age/?'` to the function
+:create_user. The first route can be referenced as `user`, the second one
+as `new_user`.
 
-Here are all the supported mapping methods and their associated HTTP methods (all of them have the same signature, e.g. `gget('/route/regex/?' => :controller_method, :as => :route_name, :mask => '/route/mask/')`):
+Here are all the supported mapping methods and their associated HTTP
+methods (all of them have the same signature, e.g.
+`gget('/route/regex/?' => :controller_method, :as => :route_name, :mask =>
+'/route/mask/')`):
 
 
         | Rroute Method | HTTP Method |
@@ -51,18 +65,61 @@ Here are all the supported mapping methods and their associated HTTP methods (al
         | ttrace        | TRACE       |
         | cconnect      | CONNECT     |
 
-*The validity of some of those HTTP methods may be debatable, but it is nice to have them, nonetheless, in case you might need them one day.*
+*The validity of some of those HTTP methods may be debatable, but it is
+nice to have them, nonetheless, in case you might need them one day.*
 
-If you do not want to map routes to methods, but still give them names and masks, you can use the `mmap` function in combination with Sinatra's built-in `get`/`post`/`delete`/... functions:
+If you do not want to map routes to methods, but still give them names and
+masks, you can use the `mmap` function in combination with Sinatra's
+built-in `get`/`post`/`delete`/... functions:
 
         # Signature: mmap(regex, mask, name)
         get mmap('/user/:name/?', '/user/:name/', :user_info) do
           # ...
         end
 
+**Referencing controllers...**
+
+...works in two ways. Either they are referenced using
+symbols for simple class/module level or global controllers or they are
+referenced using strings representing nested controllers similar to the
+`:to` option of Rails' `get`/`post`/... routing methods:
+
+        # Symbol reference
+        gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
+          :user, :mask => '/user/:name/:age/'
+        
+        # String reference to nested controller (instance method)
+        gget '/[uU]ser/:name/:age/?' => 'Very::Deeply::Nested#controller',
+          :as => :user, :mask => '/user/:name/:age/'
+
+        # String reference to nested controller (class method)
+        gget '/[uU]ser/:name/:age/?' => 'Very::Deeply::Nested::controller',
+          :as => :user, :mask => '/user/:name/:age/'
+
+String references can point to either instance methods or class methods.
+For instance methods, the class is automatically instanciated and the
+method is called on this anonymous instance. So arguments can not be
+supplied for this instance (this would arguably be bad controller design
+anyway). Unlike with Rails,
+
+- case is significant in string references
+  (`'UpperCase::DeeplyNested::controller'`), but
+- strings can reference arbitrarily deeply nested controllers
+  (`'One::Two::Three::Four::Five::Six::Seven#controller'`).
+
+Have in mind, that for sinatra-rroute to be able to reach controllers,
+the controllers already have to be defined, i.e. modules/classes have to be
+required *before* being referenced in a `gget`/`ppost`/`mmap` call.
+
 ### Namespacing
 
-Sinatra-rroute comes with a `nnamespace` method which takes the name of a namespace and a block. Each route specified using one of the sinatra-rroute mapping functions (`gget`/`ppost`/`ddelete`/, also `mmap`) inside the block will be prefixed by the specified namespace prefix. Sinatra's built-in `get`/`post`/`delete`/... functions can be used within a namespace block, but are *not* affected by the namespacing. Namespaces can be nested. *Prefixes do have to specify leading and/or trailing slashes explicitely!*
+Sinatra-rroute comes with a `nnamespace` method which takes the name of a
+namespace and a block. Each route specified using one of the sinatra-rroute
+mapping functions (`gget`/`ppost`/`ddelete`/, also `mmap`) inside the block
+will be prefixed by the specified namespace prefix. Sinatra's built-in
+`get`/`post`/`delete`/... functions can be used within a namespace block,
+but are *not* affected by the namespacing. Namespaces can be nested.
+*Prefixes do have to specify leading and/or trailing slashes explicitely!*
 
 Here is an example:
 
@@ -82,7 +139,10 @@ Here is an example:
 
 ### Route Helper
 
-Sinatra-rroute comes with a `path` helper function. It takes the name of a route and a hash of key-value mappings and returns the path for that route according to its mask. Each "token" in a mask will be replaced by the value for the specified key in the mapping.
+Sinatra-rroute comes with a `path` helper function. It takes the name of a
+route and a hash of key-value mappings and returns the path for that route
+according to its mask. Each "token" in a mask will be replaced by the value
+for the specified key in the mapping.
 
         # Specify a route mapping.
         gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
@@ -90,7 +150,8 @@ Sinatra-rroute comes with a `path` helper function. It takes the name of a route
 
         # Redirect to this route.
         get '/friend/:name/:age/?' do
-          redirect to(path(:user, :name => params[:name], :age => params[:age]))
+          redirect to(path(:user, :name => params[:name], :age =>
+          params[:age]))
         end
         
         # Generate a link for the route in the view.
@@ -98,23 +159,36 @@ Sinatra-rroute comes with a `path` helper function. It takes the name of a route
         # This will render the following link:
         #   <a href="/user/John/32/">Get user info</a>
 
-The helper can be used in your view files as well as in your controller/model/application. It is handy for links, redirecting etc.
+The helper can be used in your view files as well as in your
+controller/model/application. It is handy for links, redirecting etc.
 
 ### Accessing Routes
 
-The full hash of all route-method mappings is attached to your Sinatra app's `settings` object available through the `settings.app_paths` variable.
+The full hash of all route-method mappings is attached to your Sinatra
+app's `settings` object available through the `settings.app_paths`
+variable.
 
-*Note*: The full list of all routes is only available after the last call of one of the sinatra-rroute mapping methods, of course.
+*Note*: The full list of all routes is only available after the last call
+of one of the sinatra-rroute mapping methods, of course.
 
-*Note*: When mixing sinatra-rroute mapping methods (`gget`/`ppost`/`delete`/`mmap`/...) and Sinatra's built-in `get`/`post`/`delete`/... the routes defined using the Sinatra built-ins will *not* show up in `settings.app_paths`!
+*Note*: When mixing sinatra-rroute mapping methods
+(`gget`/`ppost`/`delete`/`mmap`/...) and Sinatra's built-in
+`get`/`post`/`delete`/... the routes defined using the Sinatra built-ins
+will *not* show up in `settings.app_paths`!
 
 ## Mixing With Sinatra and Other Extensions
 
-Sinatra's built-in `get`/`post`/`delete`/... functions as well as other route-related extensions do work fine in combination with sinatra-rroute as long as they do not
+Sinatra's built-in `get`/`post`/`delete`/... functions as well as other
+route-related extensions do work fine in combination with sinatra-rroute as
+long as they do not
 
 - clash with sinatra-rroute's function names,
-- fiddle with the `settings.app_paths` variable of your Sinatra app or
-- redefine/overload Sinatra's built-in `get`/`post`/`delete` functions without letting sinatra-rroute know.
+- fiddle with the `settings.app_paths` variable of your Sinatra app,
+- redefine/overload Sinatra's built-in `get`/`post`/`delete` functions
+  without letting sinatra-rroute know or
+- redefine/overload/fiddle with the
+  `rroute_call_nested_controller_from_string` method which handles nested
+  controller references.
 
 ## *What about the weird method names?*
 
@@ -122,4 +196,6 @@ The names are
 
 - concise (as short as possible),
 - consistent (same name generatiion scheme) and
-- unobtrusive (they do not interfere with or overload Sinatra's and Rack's built-in routing methods, they also do not interfere with other Sinatra extensions).
+- unobtrusive (they do not interfere with or overload Sinatra's and Rack's
+  built-in routing methods, they also do not interfere with other Sinatra
+  extensions).

data/lib/sinatra/rroute.rb

@@ -40,6 +40,51 @@ module Sinatra
           end
           path
         end
+
+        # @visibility private
+        #
+        # Take the string representation of a nested instance method or of
+        # a class method and call the method.
+        #
+        # Notes:
+        #
+        # - The name is chosen to be long and unique enough to not be
+        #   accidentially overwritten
+        # - Arguments are not supported as the methods to use this function
+        #   on are controllers.
+        # - Unlike the `:to' option of Rails' `match' method (used by
+        #   `get'/`post'/...), strings are case-sensitive.
+        # - Unlike the `:to' option of Rails' `match' method
+        #   methods can be arbitrarily deeply nested.
+        #
+        # @param [String] string String representation of a method
+        #
+        # @example
+        #
+        #   # Instance method
+        #   rroute_call_nested_controller_from_string(
+        #     'Very::Deeply::Nested#controller')
+        #
+        #   # Class method
+        #   rroute_call_nested_controller_from_string(
+        #     'Very::Deeply::Nested::controller')
+        #
+        # @return [nil] Nothing.
+        def rroute_call_nested_controller_from_string(string)
+          method_sep = '#'
+          nesting_sep = '::'
+          if string =~ %r{#{method_sep}}
+            tokens = string.split(method_sep)
+            const = Kernel.const_get(tokens[0])
+            method = tokens[-1]
+            const.new.send(method.to_sym)
+          else
+            tokens = string.split(nesting_sep)
+            const = Kernel.const_get(tokens[0..-2].join(nesting_sep))
+            method = tokens[-1]
+            const.send(method.to_sym)
+          end
+        end
       end
     end
 
@@ -108,7 +153,8 @@ module Sinatra
         settings.app_prefixes.join
       controller = nil
       if mapping.values[0] != nil
-        controller = mapping.values[0].to_sym
+        # controller = mapping.values[0].to_sym
+        controller = mapping.values[0]
       end
       if mapping.keys[0].class == Regexp
         mapping_regex = mapping.keys[0]
@@ -399,7 +445,14 @@ module Sinatra
           # Adapt the RegEx representation.
           value[:regex] = value[:regex].source
           send(value[:http_method],
-               value[:regex]) { send value[:controller] }
+               value[:regex]) do
+            if value[:controller].class == Symbol
+              send value[:controller]
+            else
+              rroute_call_nested_controller_from_string(value[:controller]
+                                                          .to_s)
+            end
+          end
         end
       end
     end

data/lib/sinatra/rroute/version.rb

@@ -1,5 +1,5 @@
 module Sinatra
   module Rroute
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/spec/controllers/init.rb

@@ -0,0 +1 @@
+require_relative 'nested'

data/spec/controllers/nested.rb

@@ -0,0 +1,17 @@
+class TestApp < Sinatra::Base
+
+  module Nested
+    class Controller
+      class Reference
+        def controller
+          'I am nested controller. 95475e78-f2c9-11e3-ba43-60eb69544a6d'
+        end
+
+        def self.another_controller
+          'I am also nested 98985e7e-f2c9-11e3-b9d9-60eb69544a6d'
+        end
+      end
+    end
+  end
+
+end

data/spec/rroute_spec.rb

@@ -80,6 +80,26 @@ request" do
     end
   end
 
+  describe "#gget (3)" do
+    it "successfully dispatches a GET request and defines a route mask
+(using a nested controller reference - instance method)" do
+      get '/nested/controller/references'
+      expect(last_response).to be_ok
+      expect(last_response.body)
+        .to include('95475e78-f2c9-11e3-ba43-60eb69544a6d')
+    end
+  end
+
+  describe "#gget (4)" do
+    it "successfully dispatches a GET request and defines a route mask
+(using a nested controller reference - class method)" do
+      get '/nested/controller/references/another/one'
+      expect(last_response).to be_ok
+      expect(last_response.body)
+        .to include('98985e7e-f2c9-11e3-b9d9-60eb69544a6d')
+    end
+  end
+
   describe "#ppost" do
     it "successfully dispatches a POST request and defines a route mask" do
       post "/user/new/#{@user[:name]}/#{@user[:age]}/"

data/spec/test_app.rb

@@ -190,4 +190,19 @@ class TestApp < Sinatra::Base
   get mmap('/generate/paths/?', 'generate/paths/', :build_paths) do
     'Paths have been generated.'
   end
+
+  # Nested controller references
+
+  require 'controllers/init'
+
+  # Instance method
+  gget '/nested/controller/references' =>
+    'TestApp::Nested::Controller::Reference#controller', :as =>
+    :nested_controller_reference, :mask => '/nested/controller/references'
+
+  # Class method
+  gget '/nested/controller/references/another/one' =>
+    'TestApp::Nested::Controller::Reference::another_controller', :as =>
+    :another_nested_controller_reference, :mask =>
+    '/nested/controller/references/another/one'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-rroute
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - nounch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-25 00:00:00.000000000 Z
+date: 2014-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,6 +65,8 @@ files:
 - lib/sinatra/rroute.rb
 - lib/sinatra/rroute/version.rb
 - rroute.gemspec
+- spec/controllers/init.rb
+- spec/controllers/nested.rb
 - spec/rroute_spec.rb
 - spec/test_app.rb
 homepage: ''
@@ -92,6 +94,8 @@ signing_key:
 specification_version: 4
 summary: Rails-style routes with names, namespaces and `path' helper.
 test_files:
+- spec/controllers/init.rb
+- spec/controllers/nested.rb
 - spec/rroute_spec.rb
 - spec/test_app.rb
 has_rdoc: