sinatra-named-routes 0.1.0 → 0.1.1

data/Gemfile.lock

@@ -1,38 +1,38 @@
 PATH
   remote: .
   specs:
-    sinatra-named-routes (0.0.1)
+    sinatra-named-routes (0.1.0)
       sinatra
 
 GEM
   remote: http://rubygems.org/
   specs:
-    backports (2.3.0)
+    backports (2.5.1)
     diff-lcs (1.1.3)
     eventmachine (0.12.10)
     ffi (1.0.11)
-    guard (1.0.0)
+    guard (1.0.1)
       ffi (>= 0.5.0)
       thor (~> 0.14.6)
-    guard-rspec (0.6.0)
+    guard-rspec (0.7.0)
       guard (>= 0.10.0)
-    multi_json (1.0.4)
+    multi_json (1.2.0)
     rack (1.4.1)
     rack-protection (1.2.0)
       rack
     rack-test (0.6.1)
       rack (>= 1.0)
     rake (0.9.2.2)
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
-    simplecov (0.5.4)
-      multi_json (~> 1.0.3)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    simplecov (0.6.1)
+      multi_json (~> 1.0)
       simplecov-html (~> 0.5.3)
     simplecov-html (0.5.3)
     sinatra (1.3.2)

data/README.md

@@ -1,3 +1,69 @@
 # Sinatra Named Routes [![Build Status](https://secure.travis-ci.org/ckhampus/sinatra-named-routes.png)](http://travis-ci.org/ckhampus/sinatra-named-routes)
 
-This gem allows the use of named routes in Sinatra applications.
+This gem allows the use of named routes in Sinatra applications.
+
+## Usage
+
+To use this gem you must register it in your Sinatra application.
+
+```ruby
+require 'sinatra/base'
+require 'sinatra/named_routes'
+
+class MyApp < Sinatra::Base
+  register Sinatra::NamedRoutes
+end
+```
+
+The you use the `map` method to map a route to a name, and use that name when defining your routes.
+
+```ruby
+require 'sinatra/base'
+require 'sinatra/named_routes'
+
+class MyApp < Sinatra::Base
+  register Sinatra::NamedRoutes
+  
+  map :article, '/article/:id'
+  
+  get :article do
+    # get article bla bla ...
+  end
+end
+```
+
+To generate urls in extends Sinatras built-in methods like `url` and `to` but it does not break them. They work like before except that now you can also pass the route name and paramters. The parameters have to be always passed as the last argument. Otherwise the `url` work the same.
+
+```ruby
+# in your route or view you can write something like this
+url :article, false, :id => 123 # /article/123
+```
+
+The `map` method supports the same routes as Sinatra does.
+
+```ruby
+# named parameters
+map :article, '/article/:id'
+
+url :article, false, :id => 123 # /article/123
+  
+# splats
+map :article, '/article/*.*'
+
+url :article, false, [123, 'json'] # /article/123.json
+
+# regular expressions
+map :article, %r{/article/([\w]+).([\w]+)}
+
+url :article, false, [123, 'json'] # /article/123.json
+  
+# named captures
+map :article, %r{/article/(?<slug>[^/?#]+)}
+
+url :article, false, :slug => 'hello_world' # /article/hello_world
+
+# optional named captures
+map(:articles, %r{/articles(?<format>.[^/?#]+)?})
+
+url :articles, false, :format => '.html' # /articles.html
+```

data/lib/sinatra/named_routes.rb

@@ -5,7 +5,9 @@ module Sinatra
   module NamedRoutes
     module Helpers
 
-      # def uri(addr = nil, absolute = true, add_script_name = true, params = {})
+      # Generates the absolute URI for a given path in the app.
+      # Takes Rack routers and reverse proxies into account.
+      # Extended support passing in named route and parameters.
       def uri(*args)
         path = args.shift if args.first.is_a? Symbol
         params = args.pop if args.last.is_a? Array or args.last.is_a? Hash
@@ -19,13 +21,17 @@ module Sinatra
         end
 
       end
+
       alias :to :uri
       alias :url :uri
     end
 
+    # Maps a path to name.
     def map(name, path)
       NamedRoutes.routes[name] = Route.new path
     end
+    
+    alias :bind :map
 
     private
 
@@ -38,6 +44,7 @@ module Sinatra
     end
 
     def self.get_path(name, params = {})
+      raise ArgumentError, "No route with the name #{name} exists." if NamedRoutes.routes.nil?
       NamedRoutes.routes[name].build params
     end
 

data/lib/sinatra/route_parser.rb

@@ -1,164 +1,164 @@
-class Route
-  attr_reader :source
 
-  def initialize(route)
-    route = route.source if route.is_a? Regexp
+module Sinatra
+  module NamedRoutes
+    class Route
+      attr_reader :source
 
-    @source = route
-    @input = StringScanner.new(route)
-    @output = []
+      def initialize(route)
+        route = route.source if route.is_a? Regexp
 
-    parse
-  end
-
-  # Public: Build URL with parameters.
-  #
-  # params - The hash or array of parameters to pass to URL.
-  #
-  # Returns the URL as a String.
-  def build(params = {})
-    path = []
-    params = {} if params.nil?
-
-    @output.each_index do |index|
-      item = @output[index]
-      next_item = @output.fetch(index + 1, nil)
-
-      case item[:token]
-      when :slash
-        @trailing_slash = item[:optional]
-        path << '/'
-      when :dot
-        @trailing_dot = item[:optional]
-        path << '.'
-      when :splat
-        if params.is_a? Hash
-          raise ArgumentError, 'No parameters passed.' if params[:splat].empty?
-          path << params[:splat].shift
-        else
-          raise ArgumentError, 'No enough parameters passed.' if params.empty?
-          path << params.shift
-        end
-      when :path
-        path << item[:value]
-      when :named_param
-        item_key = item[:value]
-
-        if params.has_key? item_key
-          path << params.delete(item_key)
-        else
-          raise ArgumentError, "No value passed for '#{item_key.to_s}'" unless item[:optional]
-        end
-      when :regexp
-        name = /#{item[:value]}/.names
+        @source = route
+        @input = StringScanner.new(route)
+        @output = []
 
-        if name.any?
-          name = name.first.to_sym
+        parse
+      end
 
-          if params.has_key? name
-            path << params.delete(name)
-          else
-            raise ArgumentError, "No value passed for '#{name.to_s}'" unless item[:optional]
-          end
-        else
-          if params.is_a? Hash
-            raise ArgumentError, 'No enough parameters passed.' if params[:captures].empty? and !item[:optional]
-            path << params[:captures].shift
-          else
-            raise ArgumentError, 'No enough parameters passed.' if params.empty?
-            path << params.shift
+      def build(params = {})
+        path = []
+        params = {} if params.nil?
+
+        @output.each_index do |index|
+          item = @output[index]
+          next_item = @output.fetch(index + 1, nil)
+
+          case item[:token]
+          when :slash
+            @trailing_slash = item[:optional]
+            path << '/'
+          when :dot
+            @trailing_dot = item[:optional]
+            path << '.'
+          when :splat
+            if params.is_a? Hash
+              raise ArgumentError, 'No parameters passed.' if params[:splat].empty?
+              path << params[:splat].shift
+            else
+              raise ArgumentError, 'No enough parameters passed.' if params.empty?
+              path << params.shift
+            end
+          when :path
+            path << item[:value]
+          when :named_param
+            item_key = item[:value]
+
+            if params.has_key? item_key
+              path << params.delete(item_key)
+            else
+              raise ArgumentError, "No value passed for '#{item_key.to_s}'" unless item[:optional]
+            end
+          when :regexp
+            name = /#{item[:value]}/.names
+
+            if name.any?
+              name = name.first.to_sym
+
+              if params.has_key? name
+                path << params.delete(name)
+              else
+                raise ArgumentError, "No value passed for '#{name.to_s}'" unless item[:optional]
+              end
+            else
+              if params.is_a? Hash
+                raise ArgumentError, 'No enough parameters passed.' if params[:captures].empty? and !item[:optional]
+                path << params[:captures].shift
+              else
+                raise ArgumentError, 'No enough parameters passed.' if params.empty?
+                path << params.shift
+              end
+            end
           end
         end
-      end
-    end
 
-    path = path.join
+        path = path.join
 
-    if @trailing_dot
-      path = path.chomp '.'
-    end
+        if @trailing_dot
+          path = path.chomp '.'
+        end
 
-    if @trailing_slash
-      path = path.chomp '/'
-    end
+        if @trailing_slash
+          path = path.chomp '/'
+        end
 
-    path
-  end
+        path
+      end
 
-  private
+      private
 
-  def is_optional?
-    @output.last[:optional] = @input.scan(/\?/) ? true : false
-  end
+      def is_optional?
+        @output.last[:optional] = @input.scan(/\?/) ? true : false
+      end
 
-  def parse
-    while token = parse_slash || parse_path || parse_named_param || 
-                  parse_dot || parse_splat || parse_regexp
-      @output << token
-      is_optional?
-    end
-  end
+      def parse
+        while token = parse_slash || parse_path || parse_named_param || 
+                      parse_dot || parse_splat || parse_regexp
+          @output << token
+          is_optional?
+        end
+      end
 
-  def parse_slash
-    if @input.scan(/\//)
-      {
-        :token => :slash
-      }
-    else
-      nil
-    end
-  end
+      def parse_slash
+        if @input.scan(/\//)
+          {
+            :token => :slash
+          }
+        else
+          nil
+        end
+      end
 
-  def parse_dot
-    if @input.scan(/\./)
-      {
-        :token => :dot
-      }
-    else
-      nil
-    end
-  end
+      def parse_dot
+        if @input.scan(/\./)
+          {
+            :token => :dot
+          }
+        else
+          nil
+        end
+      end
 
-  def parse_splat
-    if @input.scan(/\*/)
-      {
-        :token => :splat
-      }
-    else
-      nil
-    end
-  end
+      def parse_splat
+        if @input.scan(/\*/)
+          {
+            :token => :splat
+          }
+        else
+          nil
+        end
+      end
 
-  def parse_path
-    if @input.scan(/\w+/)
-      {
-        :token => :path,
-        :value => @input.matched
-      }
-    else
-      nil
-    end
-  end
+      def parse_path
+        if @input.scan(/\w+/)
+          {
+            :token => :path,
+            :value => @input.matched
+          }
+        else
+          nil
+        end
+      end
 
-  def parse_named_param
-    if @input.scan(/:[^\W]*/)
-      {
-        :token => :named_param,
-        :value => @input.matched.sub(':', '').to_sym
-      }
-    else
-      nil
-    end
-  end
+      def parse_named_param
+        if @input.scan(/:[^\W]*/)
+          {
+            :token => :named_param,
+            :value => @input.matched.sub(':', '').to_sym
+          }
+        else
+          nil
+        end
+      end
 
-  def parse_regexp
-    if @input.scan(/\([^\)]*\)/)
-      {
-        :token => :regexp,
-        :value => @input.matched
-      }
-    else
-      nil
+      def parse_regexp
+        if @input.scan(/\([^\)]*\)/)
+          {
+            :token => :regexp,
+            :value => @input.matched
+          }
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/sinatra/version.rb

@@ -1,5 +1,5 @@
 module Sinatra
   module NamedRoutes
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end

data/spec/route_parser_spec.rb

@@ -1,46 +1,46 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-describe Route do
+describe Sinatra::NamedRoutes::Route do
   it 'supports named parameters' do
-    route = Route.new('/hello/:person.:format')
+    route = Sinatra::NamedRoutes::Route.new('/hello/:person.:format')
     url = route.build :person => 'cristian', :format => 'json'
     url.should eql '/hello/cristian.json'
   end
 
   it 'throws exception if required named params are missing' do
     expect do
-      route = Route.new('/hello/:person.:format')
+      route = Sinatra::NamedRoutes::Route.new('/hello/:person.:format')
       url = route.build :person => 'cristian'
     end.to raise_exception ArgumentError
   end
 
   it 'supports splats' do
-    route = Route.new('/hello/*.*')
+    route = Sinatra::NamedRoutes::Route.new('/hello/*.*')
     url = route.build ['cristian', 'json']
     url.should eql '/hello/cristian.json'
   end
 
   it 'throws exception if required splats are missing' do
     expect do
-    route = Route.new('/hello/*.*')
+    route = Sinatra::NamedRoutes::Route.new('/hello/*.*')
     url = route.build ['cristian']
     end.to raise_exception ArgumentError
   end
 
   it 'supports splats mixed wih named parameters' do
-    route = Route.new('/hello/:person.*')
+    route = Sinatra::NamedRoutes::Route.new('/hello/:person.*')
     url = route.build :person => 'cristian', :splat => ['json']
     url.should eql '/hello/cristian.json'
   end
 
   it 'supports regular expressions' do
-    route = Route.new(%r{/hello/([\w]+).([\w]+)})
+    route = Sinatra::NamedRoutes::Route.new(%r{/hello/([\w]+).([\w]+)})
     url = route.build ['cristian', 'html']
     url.should eql '/hello/cristian.html'
   end
 
   it 'supports optional regular expressions mixed with named params' do
-    route = Route.new(%r{/hello/:lang/([\w]+).?([\w]+)?})
+    route = Sinatra::NamedRoutes::Route.new(%r{/hello/:lang/([\w]+).?([\w]+)?})
     url = route.build :lang => 'en', :captures => ['cristian', 'html']
     url.should eql '/hello/en/cristian.html'
 
@@ -51,7 +51,7 @@ describe Route do
   it 'supports named capture groups' do
     next if RUBY_VERSION < '1.9'
 
-    route = Route.new(%r{/hello/(?<person>[^/?#]+)})
+    route = Sinatra::NamedRoutes::Route.new(%r{/hello/(?<person>[^/?#]+)})
     url = route.build :person => 'cristian'
     url.should eql '/hello/cristian'
   end
@@ -59,7 +59,7 @@ describe Route do
   it 'supports optional named capture groups' do
     next if RUBY_VERSION < '1.9'
 
-    route = Route.new(%r{/page(?<format>.[^/?#]+)?})
+    route = Sinatra::NamedRoutes::Route.new(%r{/page(?<format>.[^/?#]+)?})
     url = route.build
     url.should eql '/page'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-named-routes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-11 00:00:00.000000000Z
+date: 2012-04-10 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &70197364991660 !ruby/object:Gem::Requirement
+  requirement: &70101493598320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70197364991660
+  version_requirements: *70101493598320
 description: Allows the use of named routes in Sinatra applications.
 email:
 - contact@cristianhampus.se