sinatra-rroute 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38d10acac3a5452cbbce30a6290ea0e381b5a6c0
+  data.tar.gz: fae34365023bd7529d861cfb82f35e1eaacd6eba
+SHA512:
+  metadata.gz: bff81eca8b56be9a0b66d08197268040e419f5beead89550918ec961946233b9a079472b069bfb28eb39f8b7a46e96bb9de9df5af93d94272f3c225e0f0a3d34
+  data.tar.gz: f3acaf70bdf9f67240eae87693cef2535548cd835aac1a87ce289cec3c6c1d9ccad47ff1a1df4a461fb0326377ab73da36ba924d919bf13a1844228d2eaae076

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rroute.gemspec
+gemspec
+
+group :test do
+  gem 'sinatra'
+  gem 'rack/test'
+  gem 'rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 nounch
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,125 @@
+# 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.
+
+Routes can also be namespaced. Namespaces can be nested. There can be multiple namespaces per app.
+
+## Setup
+
+1. Include `sinatra-rroute` in your Gemfile:
+
+        gem 'sinatra-rroute'
+
+2. Require it in your Sinatra app:
+
+        require 'sinatra/rroute'
+
+3. Register it in your app:
+
+        register Sinatra::Rroute
+
+## Usage
+
+### Route Mapping
+
+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 =>
+          :user, :mask => '/user/:name/:age/'
+
+        # This will call Sinatra's `post' method behind the scenes.
+        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`.
+
+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 |
+        |---------------+-------------|
+        | gget          | GET         |
+        | ppost         | POST        |
+        | pput          | PUT         |
+        | ppatch        | PATCH       |
+        | hhead         | HEAD        |
+        | ddelete       | DELETE      |
+        | ooptions      | OPTIONS     |
+        | llink         | LINK        |
+        | uunlink       | UNLINK      |
+        | 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.*
+
+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
+
+### 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!*
+
+Here is an example:
+
+        nnamespace '/api' do
+          nnamespace '/v1' do
+            gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
+              :user, :mask => '/user/:name/:age/'
+        
+            ppost '/[uU]ser/new/:name/:age/?' => :create_user, :as =>
+              :new_user, :mask => '/user/new/:name/:age/'
+          end
+        
+          gget '/documentation/?' => :api_documentation, :as =>
+            :api_docs, :mask => '/documentation/'
+        end
+
+
+### 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.
+
+        # Specify a route mapping.
+        gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
+          :user, :mask => '/user/:name/:age/'
+
+        # Redirect to this route.
+        get '/friend/:name/:age/?' do
+          redirect to(path(:user, :name => params[:name], :age => params[:age]))
+        end
+        
+        # Generate a link for the route in the view.
+        <a href="<%= path(:user, :name => 'John', :age => 32) %>">Get user info</a>
+        # 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.
+
+### 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.
+
+*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`!
+
+## 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
+
+- 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.
+
+## *What about the weird method names?*
+
+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).

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+
+desc 'Run RSpec tests'
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.rspec_opts = '-c'
+end
+
+task :default do
+  puts <<-STRINGSTRINGSTRING
+Run `rake -T' to see a list of all available tasks.
+STRINGSTRINGSTRING
+end

data/lib/sinatra/rroute.rb

@@ -0,0 +1,431 @@
+module Sinatra
+  module Rroute
+    private
+    def self.registered(app)
+      app.set :app_paths, {}
+      app.set :app_prefixes, []
+      app.helpers do
+        # @!visibility public
+        #
+        # Return a path for a given route mask.
+        #
+        # @param [String] name The name of a route for which a mask has
+        #   been specified.
+        # @param [Hash{Symbol=>Object}] options Hash of Symbol tokens to be
+        #   replaced by the associated value. The token (symbol) has to
+        #   have the exact name specified in the mask for this route.
+        #
+        # @example
+        #
+        #   # The mask for this route has been defined like this:
+        #   #   gget '/[uU]ser/:name/:age/?' => :user_info, :as =>
+        #   #     user, :mask => '/user/:name/:age/'
+        #   path :user, :name => 'John', :age => 32
+        #   # => '/user/John/32/'
+        #
+        #
+        # @return [String] Path for the specified route. Every token for
+        #   this route is replaced by the specified value in `options'.
+        def path(name, *options)
+          keywords = options[0]
+          # Take the last string as path mask.
+          # (Important: Make a duplicate. Do not reference the original
+          # mask/regex in `settings.app_paths'!)
+          path = settings.app_paths[name.to_sym][:mask].dup ||
+            settings.app_paths[name.to_sym][:regex].dup
+          if keywords != nil
+            keywords.each do |keyword, value|
+              path.gsub! /:#{keyword.to_s}/, value.to_s
+            end
+          end
+          path
+        end
+      end
+    end
+
+    public
+
+    # @!visibility public
+    #
+    # Merge paths into `settings.app_paths' which holds all paths defined
+    # for the app.
+    #
+    # @param [Hash{Symbol=>Hash}] paths Paths to be merged into
+    #   `settings.app_paths'. The hash has to have the structure outlined
+    #   below.
+    #
+    # @example
+    #
+    #   paths({:route =>
+    #           {:http_method =>:get,
+    #             :regex =>"/route/:name/?",
+    #             :controller =>nil,
+    #             :mask =>"/route/:name"},
+    #           :color =>
+    #           {:http_method =>:get,
+    #             :regex =>"/api/new/color/:name/:value/?",
+    #             :controller =>:show_color,
+    #             :mask =>"/api/new/color/:name/:value"},
+    #           :blue =>
+    #           {:http_method =>:post,
+    #             :regex =>"/important/api/blue/:name/:value/?",
+    #             :controller =>:post_blue,
+    #             :mask =>"/important/api/blue/:name/:value"},
+    #           :something =>
+    #           {:http_method =>:get,
+    #             :regex =>"/something/:name/:value/?",
+    #             :controller =>:api_something,
+    #             :mask =>"/something/:name/:value"}})
+    #
+    # @return [nil] Nothing.
+    def paths(paths)
+      settings.app_paths.merge! paths
+      generate_paths
+    end
+
+
+    # @!visibility public
+    #
+    # Define a route mapping a path to a controller with a HTTP method, a
+    # name and a mask for route generation.
+    #
+    # @param [Hash{String=>Symbol}] mapping Mapping of a route RegEx to a
+    #   controller function.
+    # @param [Symbol] http_method The HTTP method used for this route
+    #   (`:get', `post', `patch', ...)
+    # @param [Hash] options Optional: Options for this mapping. Allowed
+    #   values: `:as => :route_name', `:mask => "/mask/for/route/:value/"'
+    #
+    # @example
+    #
+    #   ppath({'/[Pp]ost?/info/:id/?' => :post_info}, :get, :as =>
+    #     :post, :mask => '/post/:info/')
+    #
+    # @return [nil] Nothing.
+    def ppath(mapping, http_method, *options)
+      options = options[0]
+      prefix = settings.app_prefixes.empty? ? '' :
+        settings.app_prefixes.join
+      controller = nil
+      if mapping.values[0] != nil
+        controller = mapping.values[0].to_sym
+      end
+      if mapping.keys[0].class == Regexp
+        mapping_regex = mapping.keys[0]
+      else
+        mapping_regex = Regexp.new(mapping.keys[0])
+      end
+      settings.app_paths.merge!({options[:as].to_sym => {
+                                    :http_method => http_method || :get,
+                                    :regex => %r{#{prefix}\
+#{mapping_regex.source}} || Regexp.new(''),
+                                    :controller => controller,
+                                    :mask => prefix + options[:mask]}}) ||
+        ''
+      generate_paths
+    end
+
+    # @!visibility public
+    # @!method gget(mapping, *options)
+    #
+    #   Map a request using the HTTP GET method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     gget '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method ppost(mapping, *options)
+    #
+    #   Map a request using the HTTP POST method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     ppost '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method pput(mapping, *options)
+    #
+    #   Map a request using the HTTP PUT method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     pput '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method ppatch(mapping, *options)
+    #
+    #   Map a request using the HTTP PATCH method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     ppatch '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method hhead(mapping, *options)
+    #
+    #   Map a request using the HTTP HEAD method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     hhead '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method ddelete(mapping, *options)
+    #
+    #   Map a request using the HTTP DELETE method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     ddelete '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method ooptions(mapping, *options)
+    #
+    #   Map a request using the HTTP OPTIONS method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     ooptions '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method llink(mapping, *options)
+    #
+    #   Map a request using the HTTP LINK method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     llink '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method uunlink(mapping, *options)
+    #
+    #   Map a request using the HTTP UNLINK method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     uunlink '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method ttrace(mapping, *options)
+    #
+    #   Map a request using the HTTP TRACE method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     ttrace '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    # @!visibility public
+    # @!method cconnect(mapping, *options)
+    #
+    #   Map a request using the HTTP CONNECT method to a controller method.
+    #
+    #   @param [Hash] mapping Mapping from a route RegEx to a controller
+    #     function.
+    #   @param [Hash] options Optional: Options for this route. Allowed
+    #     values: `:as => :route_name',
+    #     `:mask => "/mask/for/route/:value/"'
+    #
+    #   @example
+    #
+    #     cconnect '/[Uu]sers?/:name/:age/?' => :user_info, :as =>
+    #       :user, :mask => '/user/:name/:args/'
+    #
+    #   @return [nil] Nothing.
+
+    {:gget => :get,
+      :ppost => :post,
+      :pput => :put,
+      :ppatch => :patch,
+      :hhead => :head,
+      :ddelete => :delete,
+      :ooptions => :options,
+      :llink => :link,
+      :uunlink => :unlink,
+      :ttrace => :trace,
+      :cconnect => :connect}.each do |method_name, http_method|
+      define_method method_name do |options|
+        # Do some `magic'/hacking to get the same `get' route drawer method
+        # interface that Rails has. People are used to it/get to get used
+        # to it quickly.
+        key = (options.keys - [:as, :regex, :controller, :mask])[0]
+        ppath({key => options[key]}, http_method, options)
+      end
+    end
+
+    # @!visibility public
+    #
+    # Map a route RegEx to a controller method with a name and a mask for
+    # path generation.
+    #
+    # Since this method is meant to be used together with Sinatra's
+    # built-in `get'/`post'/`patch'/... mapper methods, it does not to
+    # map the route to a controller function since this would bypass
+    # Sinatra's built-in mapper method.
+    #
+    # @param [String] regex Route RegEx.
+    # @param [String] mask Mask for route generation.
+    # @name [Symbol] name Name to reference this route for route generation
+    #   etc.
+    #
+    # @example
+    #
+    #   get mmap('/[Uu]ser/:name/:age/?', '/user/:name/:age/', :user) do
+    #     # ...
+    #   end
+    #
+    # @return [nil] Nothing.
+    def mmap(regex, mask, name)
+      options = {}
+      options[:regex] = regex
+      options[:mask] = mask
+      options[:as] = name
+      options[:controller] = nil
+      ppath({regex => nil}, nil, options)
+
+      # Prepend the prefix to the returned RegExp.
+      mapping_regex = regex == Regexp ? regex : Regexp.new(regex)
+      prefix = settings.app_prefixes.empty? ? '' :
+        settings.app_prefixes.join
+      output = %r{#{prefix}#{mapping_regex.source}}.source ||
+        Regexp.new('')
+      # Return the right type of object depending on the input.
+      regex.class == Regexp ? Regexp.new(output) : output
+    end
+
+    # @!visibility public
+    #
+    # Generate all route mappings from the paths in `settings.app_paths'.
+    #
+    # @return [nil] Nothing.
+    def generate_paths
+      settings.app_paths.each do |name, value|
+        if value[:controller] != nil
+          # Paths merged using `paths' should be allowed to to be specified
+          # as strings. So they have to be converted here.
+          if value[:regex].class != Regexp
+            value[:regex] = Regexp.new(value[:regex])
+          end
+          # Adapt the RegEx representation.
+          value[:regex] = value[:regex].source
+          send(value[:http_method],
+               value[:regex]) { send value[:controller] }
+        end
+      end
+    end
+
+    # @!visibility public
+    #
+    # Namespace a all routes defined within the given block using the
+    # mapping methods `gget'/`ppost'/`ppatch'/...
+    #
+    # Sinatra's built-in mapping methods `get'/`post'/`patch' are NOT
+    # affected by the namespacing.
+    #
+    # @param [String] prefix Namespace to be used. HAS to include leading
+    #   and/or trailing slashes!
+    # @yield [] Block containing route mapping method calls
+    #   (`gget'/`ppost'/`ppatch'/...) and/or other relevant application
+    #   code. Can also include calls to Sinatra's built-in mapping methods
+    #   (`get'/`post'/`patch'/...) which will not be affected by the
+    #   namespacing.
+    #
+    # @return [nil] Nothing.
+    def nnamespace(prefix, &block)
+      settings.app_prefixes << prefix
+      block.call
+      settings.app_prefixes.pop
+    end
+  end
+  register Rroute
+end

data/lib/sinatra/rroute/version.rb

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

data/rroute.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinatra/rroute/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinatra-rroute"
+  spec.version       = Sinatra::Rroute::VERSION
+  spec.authors       = ["nounch"]
+  spec.email         = ["nounch@outlook.com"]
+  spec.summary       =
+    "Rails-style routes with names, namespaces and `path' helper."
+  spec.description   = <<-DESCRIPTION
+Sinatra-rraoute provides `gget'/`ppost'/`ddelete'/... methods which work
+just like Sinatra's built-in `get'/`post'/`delete'/... methods, but which
+map named routes to functions so that they can be referenced in redirects
+etc.
+
+The `path' helper will return a route for a certain route name and the
+given values for this route and comes in handy in both, the
+controller/model component of the application, and the view where you can
+use it to render links, assets URLs, AJAX calls...
+
+The nestable `nnamespace' method is useful for API versioning and does not
+interfere with other namespace extensions for Sinatra.
+    DESCRIPTION
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/spec/rroute_spec.rb

@@ -0,0 +1,216 @@
+require 'rspec'
+require 'rack/test'
+require 'sinatra/base'
+require_relative '../lib/sinatra/rroute'
+require_relative 'test_app'
+
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+end
+
+describe "Rroute" do
+  # Setup
+
+  def app
+    TestApp
+  end
+
+  before(:each) do
+    @user = { :name => 'John', :age => 32}
+  end
+
+
+  # Tests
+
+
+  describe "#paths" do
+    it "merges route mappings into `settings.app_paths' uppon a GET \
+request" do
+      get '/paths/randomname/randomdescription/'
+      paths = {:paths_test_path =>
+        {:http_method=>:get,
+          :regex =>"/paths/:name/:description/?",
+          :controller =>:paths_test,
+          :mask =>"/paths/:name/:description/"},
+        :route =>
+        {:http_method =>:get,
+          :regex =>"/route/:name/?",
+          :controller =>nil,
+          :mask =>"/route/:name"},
+        :color =>
+        {:http_method =>:get,
+          :regex =>"/api/new/color/:name/:value/?",
+          :controller =>:show_color,
+          :mask =>"/api/new/color/:name/:value"},
+        :blue =>
+        {:http_method =>:post,
+          :regex =>"/important/api/blue/:name/:value/?",
+          :controller =>:post_blue,
+          :mask =>"/important/api/blue/:name/:value"},
+        :something =>
+        {:http_method =>:get,
+          :regex =>"/something/:name/:value/?",
+          :controller =>:api_something,
+          :mask =>"/something/:name/:value"}}
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(paths.inspect)
+    end
+  end
+
+
+  describe "#gget" do
+    it "successfully dispatches a GET request and defines a route mask" do
+      get "/user/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:user][:mask]).to eq("/user/:name/:age\
+/")
+      expect(last_response.body).to eq("/user/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#gget (2)" do
+    it "successfully dispatches a GET request and defines a route mask
+(using a RegExp-quoted string as route)" do
+      get "/regex/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq("/regex/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#ppost" do
+    it "successfully dispatches a POST request and defines a route mask" do
+      post "/user/new/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:new_user][:mask]).to eq("/user/new/\
+:name/:age/")
+      expect(last_response.body).to eq("/user/new/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#pput" do
+    it "successfully dispatches a PUT request and defines a route mask" do
+      put "/user/change/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:change_user][:mask]).to eq("/user/\
+change/:name/:age/")
+      expect(last_response.body).to eq("/user/change/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#ddelete" do
+    it "successfully dispatches a DELETE request and defines a route \
+mask" do
+      delete "/user/delete/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:delete_user][:mask]).to eq("/user/\
+delete/:name/:age/")
+      expect(last_response.body).to eq("/user/delete/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#hhead" do
+    it "successfully dispatches a HEAD request and defines a route \
+  mask" do
+      head "/user/head/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:head_user][:mask]).to eq("/user/\
+head/:name/:age/")
+      expect(last_response.body).to be_empty
+    end
+  end
+
+  describe "#ppath" do
+    it "successfully dispatches a GET request and defines a route \
+mask (using `ppath')" do
+      get "/user/moreinfo/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:more_user_info][:mask]).to eq("/user/\
+moreinfo/:name/:age/")
+      expect(last_response.body).to eq("/user/moreinfo/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#nnampespace" do
+    it "successfully dispatches a GET request and defines a route \
+mask (using `nnamespace' and `gget')" do
+      # /api/v1/beta
+      get "/api/v1/beta/user/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:api_user_beta][:mask]).to eq("/api/\
+v1/beta/user/:name/:age/")
+      expect(last_response.body).to eq("/api/v1/beta/user/#{@user[:name]}/\
+#{@user[:age]}/")
+
+      # /api/v1/alpha
+      get "/api/v1/alpha/user/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:api_user_alpha][:mask]).to eq("/api/\
+v1/alpha/user/:name/:age/")
+      expect(last_response.body).to eq("/api/v1/alpha/user/\
+#{@user[:name]}/#{@user[:age]}/")
+
+      # `mmap' in a `nnamespace' block
+      get "/api/v1/overview/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:api_overview][:mask]).to eq("/api/\
+v1/overview/:name/:age/")
+      expect(last_response.body).to eq("/api/v1/overview/\
+#{@user[:name]}/#{@user[:age]}/")
+    end
+  end
+
+  describe "#nnampespace (2)" do
+    it "successfully dispatches a GET request and defines a route mask \
+  (using `nnamespace' and Sinatra's `get', `post', `put' and `delete')" do
+      # GET
+      get "/user/sinatra/get/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('User GET')
+      # POST
+      post "/user/sinatra/post/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('User POST')
+    end
+  end
+
+  describe "#mmap" do
+    it "successfully dispatches a GET request and defines a route \
+mask (using `mmap' and Sinatra's built-in `get')" do
+      get "/user/mmap/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:mmap_user][:mask]).to eq("/user/mmap/\
+:name/:age/")
+      expect(last_response.body).to eq("/user/mmap/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#mmap (2)" do
+    it "successfully dispatches a GET request and defines a route \
+mask (using `mmap', Sinatra's built-in `get' and a quoted string as route)" do
+      get "/user/mmap/regex/#{@user[:name]}/#{@user[:age]}/"
+      expect(last_response).to be_ok
+      expect(app.settings.app_paths[:mmap_user][:mask]).to eq("/user/mmap/\
+:name/:age/")
+      expect(last_response.body).to eq("/user/mmap/regex/#{@user[:name]}/\
+#{@user[:age]}/")
+    end
+  end
+
+  describe "#generate_paths" do
+    it "successfully dispatches a GET request and generates \
+`settings.app_paths')" do
+      get '/generate/paths/'
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq 'Paths have been generated.'
+      expect(app.settings.app_paths).not_to be(nil)
+    end
+  end
+end

data/spec/test_app.rb

@@ -0,0 +1,193 @@
+require 'sinatra'
+require_relative '../lib/sinatra/rroute'
+
+class TestApp < Sinatra::Base
+  register Sinatra::Rroute
+
+  # `paths'
+
+  gget '/paths/:name/:description/?' => :paths_test, :as =>
+    :paths_test_path, :mask => '/paths/:name/:description/'
+
+  paths({:route =>
+          {:http_method =>:get,
+            :regex =>"/route/:name/?",
+            :controller =>nil,
+            :mask =>"/route/:name"},
+          :color =>
+          {:http_method =>:get,
+            :regex =>"/api/new/color/:name/:value/?",
+            :controller =>:show_color,
+            :mask =>"/api/new/color/:name/:value"},
+          :blue =>
+          {:http_method =>:post,
+            :regex =>"/important/api/blue/:name/:value/?",
+            :controller =>:post_blue,
+            :mask =>"/important/api/blue/:name/:value"},
+          :something =>
+          {:http_method =>:get,
+            :regex =>"/something/:name/:value/?",
+            :controller =>:api_something,
+            :mask =>"/something/:name/:value"}})
+  @@merged_paths = settings.app_paths.dup
+
+  def paths_test
+    @@merged_paths.inspect
+  end
+
+  def show_color
+    '#FF0000'
+  end
+
+  def post_blue
+    'This is a blue post.'
+  end
+
+  def api_something
+    'API...'
+  end
+
+  #########################################################################
+  # NOTE
+  #
+  # For the tests to work correctly do not define more routes above this
+  # point in the file or modify `settings.app_paths' in any other way
+  # without also adjusting the `paths' variable in the `#paths' RSpec block
+  # in `rroute_integration_spec.rb'!
+  #########################################################################
+
+
+  # GET
+
+  gget '/user/:name/:age/?' => :do_show_user_info, :as =>
+    :user, :mask => '/user/:name/:age/'
+
+  def do_show_user_info
+    path :user, :name => params[:name], :age => params[:age]
+  end
+
+  # GET (using a RegExp-quoted string as route)
+
+  gget %r{/regex/:name/:age/?} => :show_regex, :as =>
+    :regex, :mask => '/regex/:name/:age/'
+
+  def show_regex
+    path :regex, :name => params[:name], :age => params[:age]
+  end
+
+  # POST
+
+  ppost '/user/new/:name/:age/?' => :do_create_new_user, :as =>
+    :new_user, :mask => '/user/new/:name/:age/'
+
+  def do_create_new_user
+    path :new_user, :name => params[:name], :age => params[:age]
+  end
+
+  # PUT
+
+  pput '/user/change/:name/:age/?' => :do_change_user, :as =>
+    :change_user, :mask => '/user/change/:name/:age/'
+
+  def do_change_user
+    path :change_user, :name => params[:name], :age => params[:age]
+  end
+
+  # DELETE
+
+  ddelete '/user/delete/:name/:age/?' => :do_delete_user, :as =>
+    :delete_user, :mask => '/user/delete/:name/:age/'
+
+  def do_delete_user
+    path :delete_user, :name => params[:name], :age => params[:age]
+  end
+
+  # HEAD
+
+  hhead '/user/head/:name/:age/?' => :do_head_user, :as =>
+    :head_user, :mask => '/user/head/:name/:age/'
+
+  def do_head_user
+    # Because this is a controller method for a HEAD request, the following
+    # response should NOT be sent! This is default Sinatra behavior.
+    path :head_user, :name => params[:name], :age => params[:age]
+  end
+
+  # GET (using `ppath')
+
+  ppath({'/user/moreinfo/:name/:age/?' =>
+          :show_more_user_info}, :get, :as => :more_user_info, :mask =>
+        '/user/moreinfo/:name/:age/')
+
+  def show_more_user_info
+    path :more_user_info, :name => params[:name], :age => params[:age]
+  end
+
+  # GET (using `nnamespace' and `gget')
+
+  nnamespace '/api' do
+    nnamespace '/v1' do
+      nnamespace '/beta' do
+        gget '/user/:name/:age/?' => :api_do_show_user_info_beta, :as =>
+          :api_user_beta, :mask => '/user/:name/:age/'
+
+        def api_do_show_user_info_beta
+          path :api_user_beta, :name => params[:name], :age => params[:age]
+        end
+      end
+
+      nnamespace '/alpha' do
+        gget '/user/:name/:age/?' => :api_do_show_user_info_alpha, :as =>
+          :api_user_alpha, :mask => '/user/:name/:age/'
+
+        def api_do_show_user_info_alpha
+          path :api_user_alpha, :name => params[:name], :age =>
+            params[:age]
+        end
+      end
+
+      get mmap('/overview/:name/:age/?', '/overview/:name/:age/',
+               :api_overview) do
+        path :api_overview, :name => params[:name], :age => params[:age]
+      end
+    end
+  end
+
+  nnamespace '/api' do
+    nnamespace '/v1' do
+      nnamespace '/beta' do
+        get '/user/sinatra/get/:name/:age/?' do
+          'User GET'
+        end
+
+        post '/user/sinatra/post/:name/:age/?' do
+          'User POST'
+        end
+      end
+    end
+  end
+
+  # GET (using `mmap' and Sinatra's built-in `get')
+
+  get mmap('/user/mmap/:name/:age/?', '/user/mmap/:name/:age/',
+           :mmap_user) do
+    path :mmap_user, :name => params[:name], :age => params[:age]
+  end
+
+  # GET (using `mmap', Sinatra's built-in `get' and a quoted string as
+  # route)
+
+  get mmap(%r{/user/mmap/regex/([\w]+)/([\w]+)/?},
+           '/user/mmap/regex/:name/:age/', :mmap_regex_user) do |name, age|
+    path :mmap_regex_user, :name => name, :age => age
+  end
+
+  # `generate_paths'
+
+  # Callign `mmap' invokes `generate_paths' and registers a new route.
+  # Consequence: `settings.app_paths' cannot be `nil' anymore. This is
+  # what the test can test check.
+  get mmap('/generate/paths/?', 'generate/paths/', :build_paths) do
+    'Paths have been generated.'
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-rroute
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- nounch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Sinatra-rraoute provides `gget'/`ppost'/`ddelete'/... methods which work
+  just like Sinatra's built-in `get'/`post'/`delete'/... methods, but which
+  map named routes to functions so that they can be referenced in redirects
+  etc.
+
+  The `path' helper will return a route for a certain route name and the
+  given values for this route and comes in handy in both, the
+  controller/model component of the application, and the view where you can
+  use it to render links, assets URLs, AJAX calls...
+
+  The nestable `nnamespace' method is useful for API versioning and does not
+  interfere with other namespace extensions for Sinatra.
+email:
+- nounch@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sinatra/rroute.rb
+- lib/sinatra/rroute/version.rb
+- rroute.gemspec
+- spec/rroute_spec.rb
+- spec/test_app.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rails-style routes with names, namespaces and `path' helper.
+test_files:
+- spec/rroute_spec.rb
+- spec/test_app.rb
+has_rdoc: