sinatra-trails 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+*.swp
+*.swo
+.bundle
+.DS_Store
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in trails.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+
+task :default => [:spec]
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)

data/lib/sinatra/trails.rb

@@ -0,0 +1,302 @@
+require "sinatra/base"
+require "active_support/inflector"
+require "active_support/inflections"
+require "active_support/core_ext/string/inflections"
+
+libdir = File.dirname( __FILE__)
+$:.unshift(libdir) unless $:.include?(libdir)
+require "trails/version"
+
+module Sinatra
+  module Trails
+    class RouteNotDefined < Exception; end
+
+    class Route
+      attr_reader :name, :full_name, :scope, :keys, :to_route, :to_regexp
+      Match = Struct.new(:captures)
+
+      def initialize route, name, ancestors, scope
+        @name        = name.to_s
+        @full_name   = ancestors.map { |ancestor| Scope === ancestor ? ancestor.name : ancestor }.push(name).select{ |name| Symbol === name }.join('_')
+        @components  = Array === route ? route.compact : route.to_s.scan(/[^\/]+/)
+        @components.unshift *ancestors.map { |ancestor| ancestor.path if Scope === ancestor }.compact
+        @scope       = scope
+        @captures    = []
+        @to_route    = "/#{@components.join('/')}"
+        namespace    = ancestors.reverse.find { |ancestor| ancestor.class == Scope && ancestor.name }
+
+        @to_regexp, @keys = Sinatra::Base.send(:compile, to_route)
+        add_param 'resource', scope.name if [Resource, Resources].include?(scope.class)
+        add_param 'namespace', namespace.name if namespace
+        add_param 'action', name
+        scope.routes << self
+      end
+
+      def match str
+        if match_data = to_regexp.match(str)
+          Match.new(match_data.captures + @captures)
+        end
+      end
+
+      def to_path *args
+        query      = args.pop if Hash === args.last
+        components = @components.dup
+        components.each_with_index do |component, index|
+          next unless /^:/ === component
+          val = args.pop or raise ArgumentError.new("Please provide `#{component}`")
+          components[index] =
+          case val
+          when Numeric, String, Symbol then val
+          else val.to_param end
+        end
+        raise ArgumentError.new("Too many params where passed") unless args.empty?
+        "/#{components.join('/')}#{'?' + Rack::Utils.build_nested_query(query) if query}"
+      end
+
+      private
+      def add_param key, capture
+        unless keys.include? key
+          @keys << key
+          @captures << capture
+        end
+      end
+    end
+
+    class ScopeMatcher
+      def initialize scope, matchers
+        @scope = scope
+        @names, @matchers = matchers.partition { |el| Symbol === el }
+      end
+      
+      def match str
+        if @matchers.empty? && @names.empty?
+          Regexp.union(@scope.routes).match str
+        else
+          Regexp.union(*@matchers, *@names.map{ |name| @scope[name] }).match str
+        end
+      end
+    end
+
+    class Scope
+      attr_reader :name, :path, :ancestors, :routes
+
+      def initialize app, path, ancestors = []
+        @ancestors, @routes = ancestors, []
+        @path = path.to_s.sub(/^\//, '') if path
+        @name = path if Symbol === path
+        @sinatra_app = app
+      end
+
+      def map name, opts = {}, &block
+        path = opts.delete(:to) || name
+        route = Route.new(path, name, [*ancestors, self], self)
+        instance_eval &block if block_given?
+        route
+      end
+
+      def namespace path, &block
+        @routes += Scope.new(@sinatra_app, path, [*ancestors, self]).generate_routes!(&block)
+      end
+
+      def resource *names, &block
+        restful_routes Resource, names, &block
+      end
+
+      def resources *names, &block
+        restful_routes Resources, names, &block
+      end
+
+      def before *args, &block
+        opts = Hash === args.last ? args.pop : {}
+        @sinatra_app.before ScopeMatcher.new(self, args), opts, &block
+      end
+
+      def generate_routes! &block
+        instance_eval &block if block_given?
+        @routes
+      end
+
+      def routes_hash &block
+        Hash[*generate_routes!(&block).map{ |route| [route.full_name, route]}.flatten]
+      end
+
+      def route_for name
+        name = name.to_s
+        @routes.find{ |route| route.full_name == name || route.scope == self && route.name == name }
+      end
+      alias :[] :route_for
+
+      private
+      def method_missing name, *args, &block
+        return @sinatra_app.send(name, *args, &block) if @sinatra_app.respond_to?(name)
+        if route = route_for(name)
+          return route unless block_given?
+          @routes = @routes | route.scope.generate_routes!(&block)
+        else
+          super
+        end
+      end
+
+      def restful_routes builder, names, &block
+        opts = {}
+        hash = Hash === names.last ? names.pop : {}
+        hash.delete_if { |key, val| opts[key] = val if !(Symbol === val || Enumerable === val) }
+
+        nested = []
+        mash = Proc.new do |hash, acc|
+          hash.map do |key, val| 
+            case val
+            when Hash
+              [*acc, key, *mash.call(val, key).flatten]
+            when Array
+              nested += val.map{ |r| [*acc, key, r] } and next
+            else
+              [key, val]
+            end
+          end 
+        end
+
+        hash = (mash.call(hash) + nested).compact.map do |array|
+          array.reverse.inject(Proc.new{}) do |proc, name|
+            Proc.new{ send(builder == Resource ? :resource : :resources, name, opts, &proc) }
+          end.call
+        end
+
+        make = lambda do |name|
+          builder.new(@sinatra_app, name, [*ancestors, self], (@opts || {}).merge(opts))
+        end
+
+        if names.size == 1 && hash.empty?
+          @routes += make.call(names.first).generate_routes!(&block)
+        else
+          names.each { |name| @routes += make.call(name).generate_routes! }
+          instance_eval &block if block_given?
+        end
+      end
+    end
+
+    class Resource < Scope
+      attr_reader :opts
+      def initialize app, name, ancestors, opts
+        super app, name.to_sym, ancestors
+        @opts = opts
+      end
+
+      def member action
+        ancestors = [*self.ancestors, name]
+        path      = @plural_name ? [plural_name, ':id'] : [name]
+
+        ancestors.unshift(action) and path.push(action) unless action == :show
+        ancestors.reject!{ |ancestor| Resource === ancestor } if opts[:shallow]
+        Route.new(path, action.to_s, ancestors, self)
+      end
+
+      def generate_routes! &block
+        define_routes and super
+      end
+      
+      private
+      def define_routes
+        member(:show) and member(:new) and member(:edit)
+      end
+    end
+
+    class Resources < Resource
+      attr_reader :plural_name, :name_prefix
+
+      def initialize app, raw_name, ancestors, opts
+        super
+        @plural_name = name
+        @name        = name.to_s.singularize.to_sym
+        @path        = [plural_name, ":#{name}_id"]
+      end
+
+      def collection action
+        ancestors  = [*self.ancestors, action == :new ? name : plural_name]
+        path       = [plural_name]
+        ancestors.unshift(action) and path.push(action) unless action == :index
+
+        ancestors[0, ancestors.size - 2] = ancestors[0..-3].reject{ |ancestor| Resource === ancestor } if opts[:shallow]
+        Route.new(path, action.to_s, ancestors, self)
+      end
+
+      private
+      def define_routes
+        collection(:index) and collection(:new)
+        member(:show) and member(:edit)
+      end
+    end
+
+    def namespace name, &block
+      named_routes.merge! Scope.new(self, name).routes_hash(&block)
+    end
+
+    def map name, opts = {}, &block
+      namespace(nil) { map name, opts, &block }
+      route_for name
+    end
+
+    def resource *args, &block
+      namespace(nil) { resource *args, &block }
+    end
+
+    def resources *args, &block
+      namespace(nil) { resources *args, &block }
+    end
+
+    def route_for name
+      Trails.route_for(self, name).to_route
+    end
+
+    def path_for name, *args
+      Trails.route_for(self, name).to_path(*args)
+    end
+
+    def print_routes
+      trails       = named_routes.map { |name, route| [name, route.to_route] }
+      name_padding = trails.sort_by{ |e| e.first.size }.last.first.size + 3
+      trails.each do |name, route|
+        puts sprintf("%#{name_padding}s => %s", name, route) 
+      end
+    end
+
+    private
+    def named_routes
+      self::Routes.instance_variable_get :@routes
+    end
+
+    module Helpers
+      def path_for name, *args
+        Trails.route_for(self.class, name).to_path(*args)
+      end
+       
+      def url_for *args 
+        url path_for(*args) 
+      end
+    end
+
+    class << self
+      def route_for klass, name
+        klass.ancestors.each do |ancestor| 
+          next unless ancestor.class == Module && ancestor.include?(Helpers)
+          if route = ancestor.instance_variable_get(:@routes)[name]
+            return route
+          end
+        end
+        raise RouteNotDefined.new("The route `#{name}` is not defined")
+      end
+
+      def registered app
+        routes_module = Module.new do
+          include Helpers
+          @routes = Hash.new { |hash, key| hash[key.to_s] if Symbol === key }
+        end
+
+        app.const_set :Routes, routes_module
+        app.send :include, routes_module
+      end
+    end
+  end
+
+  Sinatra.register Trails
+end

data/lib/sinatra/trails/version.rb

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

data/spec/route_generation_spec.rb

@@ -0,0 +1,595 @@
+require 'spec_helper'
+
+describe 'trails' do
+  include Rack::Test::Methods
+
+  let(:app) do
+    app = Class.new(Sinatra::Base)
+    app.register Sinatra::Trails
+    app.set :environment, :test
+  end
+
+  describe 'map' do
+    describe 'basic' do
+      before :all do
+        app.map :home, :to => '/'
+        app.map :dashboard
+        app.map :edit_user, :to => '/users/:id/edit'
+      end
+
+      describe 'routes' do
+        it { app.route_for(:home).should       == '/' }
+        it { app.route_for(:dashboard).should  == '/dashboard' }
+        it { app.route_for('dashboard').should == '/dashboard' }
+        it { lambda{ app.route_for(:missing) }.should raise_error Sinatra::Trails::RouteNotDefined }
+      end
+
+      describe 'paths' do
+        it { app.path_for(:home).should       == '/' }
+        it { app.path_for(:home, :q => 'q', :a => 'a').should == '/?q=q&a=a' }
+
+        describe 'with placeholders' do
+          before { @mock_user = mock(:user, :to_param => 1)}
+          it { app.path_for(:edit_user, 1).should     == '/users/1/edit' }
+          it { app.path_for(:edit_user, @mock_user).should  == '/users/1/edit' }
+
+          describe 'wrong arg count' do
+            it 'should raise error when not passing :id' do
+              lambda { app.path_for(:edit_user) }.should raise_error(ArgumentError)
+            end
+
+            it 'should raise error when too many params are passed' do
+              lambda { app.path_for(:edit_user, 1, 2) }.should raise_error(ArgumentError)
+            end
+          end
+        end
+      end
+    end
+
+    describe 'with namespace' do
+      before :all do
+        app.namespace '/admin' do
+          map :dashboard
+          map :logout
+        end
+      end
+      it { app.route_for(:dashboard).should == '/admin/dashboard' }
+      it { app.route_for(:logout).should    == '/admin/logout' }
+    end
+
+    describe 'with named namespace' do
+      before :all do
+        app.namespace :admin do
+          map :dashboard
+        end
+      end
+      it { app.route_for(:admin_dashboard).should == '/admin/dashboard' }
+    end
+
+    describe 'with nested namespace' do
+      before :all do
+        app.namespace '/blog' do
+          map :users
+          namespace '/admin' do
+            map :dashboard
+            namespace '/auth' do
+              map :logout
+              map :login
+            end
+          end
+        end
+      end
+      it { app.route_for(:users).should     == '/blog/users' }
+      it { app.route_for(:dashboard).should == '/blog/admin/dashboard' }
+      it { app.route_for(:logout).should    == '/blog/admin/auth/logout' }
+      it { app.route_for(:login).should     == '/blog/admin/auth/login' }
+    end
+
+    describe 'with named nested namespace' do
+      before :all do
+        app.namespace :blog do
+          map :users
+          namespace :admin do
+            map :dashboard
+            namespace :auth do
+              map :logout
+              map :login
+            end
+          end
+        end
+      end
+      it { app.route_for(:blog_users).should             == '/blog/users' }
+      it { app.route_for(:blog_admin_dashboard).should   == '/blog/admin/dashboard' }
+      it { app.route_for(:blog_admin_auth_logout).should == '/blog/admin/auth/logout' }
+      it { app.route_for(:blog_admin_auth_login).should  == '/blog/admin/auth/login' }
+    end
+  end
+
+  describe 'resources' do
+    shared_examples_for 'generates routes for users' do
+      it { app.route_for(:users).should      == '/users' }
+      it { app.route_for(:new_user).should   == '/users/new' }
+      it { app.route_for(:user).should       == '/users/:id' }
+      it { app.route_for(:edit_user).should  == '/users/:id/edit' }
+    end
+
+    shared_examples_for 'generates routes for posts' do
+      it { app.route_for(:posts).should      == '/posts' }
+      it { app.route_for(:new_post).should   == '/posts/new' }
+      it { app.route_for(:post).should       == '/posts/:id' }
+      it { app.route_for(:edit_post).should  == '/posts/:id/edit' }
+    end
+
+    shared_examples_for 'generates routes for nested user posts collections' do
+      it { app.route_for(:user_posts).should     == '/users/:user_id/posts' }
+      it { app.route_for(:new_user_post).should  == '/users/:user_id/posts/new' }
+    end
+
+    shared_examples_for 'generates routes for nested user posts members' do
+      it { app.route_for(:user_post).should      == '/users/:user_id/posts/:id' }
+      it { app.route_for(:edit_user_post).should == '/users/:user_id/posts/:id/edit' }
+    end
+
+    shared_examples_for 'generates routes for nested user posts' do
+      it_should_behave_like 'generates routes for nested user posts collections'
+      it_should_behave_like 'generates routes for nested user posts members'
+    end
+
+    shared_examples_for 'generates routes for shallow user posts' do
+      it_should_behave_like 'generates routes for nested user posts collections'
+      it { app.route_for(:post).should      == '/posts/:id' }
+      it { app.route_for(:edit_post).should == '/posts/:id/edit' }
+    end
+
+    shared_examples_for 'generates routes for nested post comments collections' do
+      it { app.route_for(:post_comments).should     == '/posts/:post_id/comments' }
+      it { app.route_for(:new_post_comment).should  == '/posts/:post_id/comments/new' }
+    end
+
+    shared_examples_for 'generates routes for shallow post comments' do
+      it_should_behave_like 'generates routes for nested post comments collections'
+      it { app.route_for(:comment).should      == '/comments/:id' }
+      it { app.route_for(:edit_comment).should == '/comments/:id/edit' }
+    end
+
+    describe 'basic' do
+      before :all do
+        app.resources :users, 'posts' do
+          # map :flag
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for posts'
+      # it { app.route_for(:flag).should == '/flag' }
+    end
+
+    describe 'nested with block' do
+      before :all do
+        app.resources :users do
+          resources :posts
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for nested user posts'
+    end
+
+    describe 'with namespace' do
+      before :all do
+        app.namespace :admin do
+          resources :users
+        end
+      end
+      it { app.route_for(:admin_users).should          == '/admin/users' }
+      it { app.route_for(:new_admin_user).should       == '/admin/users/new' }
+      it { app.route_for(:admin_user).should           == '/admin/users/:id' }
+      it { app.route_for(:edit_admin_user).should      == '/admin/users/:id/edit' }
+    end
+
+    describe 'nested with block and namespace' do
+      before :all do
+        app.resources :users do
+          namespace :admin do
+            resources :posts
+          end
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it { app.route_for(:user_admin_posts).should     == '/users/:user_id/admin/posts' }
+      it { app.route_for(:new_user_admin_post).should  == '/users/:user_id/admin/posts/new' }
+      it { app.route_for(:user_admin_post).should      == '/users/:user_id/admin/posts/:id' }
+      it { app.route_for(:edit_user_admin_post).should == '/users/:user_id/admin/posts/:id/edit' }
+    end
+
+    describe 'deep nested' do
+      before :all do
+        app.resources :users do
+          resources :posts do
+            resources :comments
+          end
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for nested user posts'
+      describe 'exageration' do
+        it { app.route_for(:user_post_comments).should     == '/users/:user_id/posts/:post_id/comments' }
+        it { app.route_for(:new_user_post_comment).should  == '/users/:user_id/posts/:post_id/comments/new' }
+        it { app.route_for(:user_post_comment).should      == '/users/:user_id/posts/:post_id/comments/:id' }
+        it { app.route_for(:edit_user_post_comment).should == '/users/:user_id/posts/:post_id/comments/:id/edit' }
+      end
+    end
+
+    describe 'shallow deep nested' do
+      before :all do
+        app.resources :users, :shallow => true do
+          resources :posts do
+            resources :comments
+          end
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for shallow user posts'
+      it_should_behave_like 'generates routes for shallow post comments'
+    end
+
+    describe 'nested shallow' do
+      before :all do
+        app.resources :users, :shallow => true do
+          resources :posts
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for shallow user posts'
+    end
+
+    describe 'hash nested' do
+      before :all do
+        app.resources :users => :posts
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for nested user posts'
+    end
+
+    describe 'hash nested with block' do
+      before :all do
+        app.resources :users => :posts do
+          map :flag
+        end
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for nested user posts'
+      it { app.route_for(:flag).should == '/flag' }
+    end
+
+    describe 'nested shallow with hash' do
+      before :all do
+        app.resources :users => :posts, :shallow => true
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for shallow user posts'
+    end
+
+    describe 'deep nested with hash' do
+      before :all do
+        app.resources :users => {:posts => :comments}
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for nested user posts'
+      describe 'exageration' do
+        it { app.route_for(:user_post_comments).should     == '/users/:user_id/posts/:post_id/comments' }
+        it { app.route_for(:new_user_post_comment).should  == '/users/:user_id/posts/:post_id/comments/new' }
+        it { app.route_for(:user_post_comment).should      == '/users/:user_id/posts/:post_id/comments/:id' }
+        it { app.route_for(:edit_user_post_comment).should == '/users/:user_id/posts/:post_id/comments/:id/edit' }
+      end
+    end
+    
+    describe 'deep nested shallow with hash' do
+      before :all do
+        app.resources :users => {:posts => :comments}, :shallow => true
+      end
+      it_should_behave_like 'generates routes for users'
+      it_should_behave_like 'generates routes for shallow user posts'
+      it { app.route_for(:post_comments).should     == '/posts/:post_id/comments' }
+      it { app.route_for(:new_post_comment).should  == '/posts/:post_id/comments/new' }
+      it { app.route_for(:comment).should           == '/comments/:id' }
+      it { app.route_for(:edit_comment).should      == '/comments/:id/edit' }
+    end
+
+    describe 'nested with array' do
+      before :all do
+        app.resources :users => [:posts, :comments]
+      end
+      it { app.route_for(:users).should           == '/users' }
+      it { app.route_for(:user_comments).should   == '/users/:user_id/comments' }
+      it { app.route_for(:user_posts).should      == '/users/:user_id/posts' }
+    end
+  end
+
+  describe 'single resource' do
+    before :all do
+      app.resource :user => :profile
+    end
+    it { app.route_for(:user).should               == '/user' }
+    it { app.route_for(:new_user).should           == '/user/new' }
+    it { app.route_for(:edit_user).should          == '/user/edit' }
+    it { app.route_for(:user_profile).should       == '/user/profile' }
+    it { app.route_for(:new_user_profile).should   == '/user/profile/new' }
+    it { app.route_for(:edit_user_profile).should  == '/user/profile/edit' }
+  end
+
+  describe 'finding route for scope' do
+    before :all do
+      @scope = Sinatra::Trails::Scope.new(app, :admin)
+      @scope.generate_routes!{ map(:index) }
+    end
+
+    it { @scope.route_for(:admin_index).should_not be_nil }
+    it { @scope.route_for(:index).should_not be_nil }
+    it "should find resources index without full name"
+  end
+
+  describe 'finding route for resources' do
+    before :all do
+      @scope = Sinatra::Trails::Resources.new(app, :users, [], {})
+      @scope.generate_routes!
+    end
+    it { @scope.route_for(:users).should_not be_nil }
+    it { @scope.route_for(:new_user).should_not be_nil }
+    it { @scope.route_for(:edit_user).should_not be_nil }
+    it { @scope.route_for(:user).should_not be_nil }
+  end
+
+  describe 'finding route for resources' do
+    before :all do
+      @scope = Sinatra::Trails::Resources.new(app, :users, [], {})
+      @scope.generate_routes! do
+        resources :posts
+      end
+    end
+    it { @scope.route_for(:user_posts).should_not be_nil }
+    it { @scope.route_for(:new_user_post).should_not be_nil }
+    it { @scope.route_for(:edit_user_post).should_not be_nil }
+    it { @scope.route_for(:user_post).should_not be_nil }
+  end
+
+  describe 'sinatra integration' do
+    describe 'delegation to sinatra and helpers' do
+      before :all do
+        app.map(:home) { get(home){ path_for(:home) } }
+        app.instance_eval { get(map(:about)){ url_for(:about) } }
+      end
+
+      it "should get path for route" do
+        get '/home'
+        last_response.body.should == '/home'
+      end
+
+      it "should get url for route" do
+        get '/about'
+        last_response.body.should == 'http://example.org/about'
+      end
+    end
+
+    describe 'using route as scope' do
+      before :all do
+        app.resources(:users => :posts, :shallow => true) do
+          users do
+            get(member(:aprove)) { path_for(:aprove_user, params[:id]) }
+          end
+
+          user_posts do
+            get(member(:aprove)) { path_for(:aprove_post, params[:id]) }
+          end
+        end
+      end
+
+      it 'should define action for users member' do
+        get '/users/1/aprove'
+        last_response.body.should == '/users/1/aprove'
+      end
+
+      it 'should define action for user_posts member' do
+        get '/posts/1/aprove'
+        last_response.body.should == '/posts/1/aprove'
+      end
+    end
+
+    describe 'before without args' do
+      before :all do
+        app.instance_eval do
+          namespace(:admin) do 
+            before { @admin = true }
+            get map(:index, :to => '/') do
+              @admin.to_s
+            end
+          end
+
+          namespace(:not_admin) do
+            get map(:index, :to => '/') do
+              @admin.to_s
+            end
+          end
+        end
+      end
+
+      it 'should set before filter within scope' do
+        get '/admin'
+        last_response.body.should == 'true'
+      end
+
+      it 'should not set before filter outside scope' do
+        get '/not_admin'
+        last_response.body.should == ''
+      end
+    end
+
+    describe 'before passing routes' do
+      before :all do
+        app.instance_eval do
+          namespace(:admin) do 
+            get map(:index, :to => '/') do
+              @auth.to_s
+            end
+
+            get map(:sign_in, :to => '/sign_in') do
+              @auth.to_s
+            end
+
+            get map(:sign_up, :to => '/sign_up') do
+              @auth.to_s
+            end
+
+            before(admin_sign_in, admin_sign_up) { @auth = true }
+          end
+        end
+      end
+
+      it 'should set before filter for passed routes' do
+        get '/admin/sign_in'
+        last_response.body.should == 'true'
+        get '/admin/sign_up'
+        last_response.body.should == 'true'
+      end
+
+      it 'should not set before filter for not passed routes' do
+        get '/admin'
+        last_response.body.should == ''
+      end
+    end
+
+    describe 'before filter lazy match passing symbols' do
+      before :all do
+        app.instance_eval do
+          namespace(:admin) do 
+            before(:admin_sign_in, :admin_sign_up) { @auth = true }
+
+            get map(:index, :to => '/') do
+              @auth.to_s
+            end
+
+            get map(:sign_in, :to => '/sign_in') do
+              @auth.to_s
+            end
+
+            get map(:sign_up, :to => '/sign_up') do
+              @auth.to_s
+            end
+          end
+        end
+      end
+
+      it 'should set before filter for passed routes' do
+        get '/admin/sign_in'
+        last_response.body.should == 'true'
+        get '/admin/sign_up'
+        last_response.body.should == 'true'
+      end
+
+      it 'should not set before filter for not passed routes' do
+        get '/admin'
+        last_response.body.should == ''
+      end
+    end
+
+    describe 'having access to resource name' do
+      before :all do
+        app.resources(:users => :posts) do
+          get(users){ params[:resource].to_s }
+          get(user_posts){ params[:resource].to_s }
+        end
+      end
+
+      it 'should access resource name for users' do
+        get '/users'
+        last_response.body.should == 'user'
+      end
+
+      it 'should access resource name for nested posts' do
+        get '/users/1/posts'
+        last_response.body.should == 'post'
+      end
+    end
+
+    describe 'having access to namespace and action' do
+      before :all do
+        app.namespace(:admin) do
+          get(map(:index, :to => '/')){ params[:namespace].to_s }
+          get(map(:sign_in)){ params[:action].to_s }
+        end
+      end
+
+      it 'should access namespace' do
+        get '/admin'
+        last_response.body.should == 'admin'
+      end
+
+      it 'should access action' do
+        get '/admin/sign_in'
+        last_response.body.should == 'sign_in'
+      end
+    end
+
+    describe 'finding the right route for resources' do
+      it 'should find the right route' do
+        app.resources(:users) do
+          users.to_route.should     == '/users'
+          new_user.to_route.should  == '/users/new'
+          user.to_route.should      == '/users/:id'
+          edit_user.to_route.should == '/users/:id/edit'
+        end
+      end
+    end
+
+    describe 'having access to action for resources' do
+      before :all do
+        app.resources(:users) do
+          get(users){ params[:action].to_s }
+          get(new_user){ params[:action].to_s }
+          get(user){ params[:action].to_s }
+          get(edit_user){ params[:action].to_s }
+        end
+      end
+
+      it 'should set index as action' do
+        get '/users'
+        last_response.body.should == 'index'
+      end
+
+      it 'should set index as show' do
+        get '/users/1'
+        last_response.body.should == 'show'
+      end
+
+      it 'should set index as new' do
+        get '/users/new'
+        last_response.body.should == 'new'
+      end
+
+      it 'should set index as edit' do
+        get '/users/1/edit'
+        last_response.body.should == 'edit'
+      end
+    end
+  end
+
+  describe 'accessing routes from outside the app by module inclusion' do
+    let(:other_app) do
+      app = Class.new(Sinatra::Base)
+      app.register Sinatra::Trails
+      app.set :environment, :test
+    end
+
+    let(:klass) { Class.new }
+
+    before :all do
+      app.map :heaven
+      other_app.map :hell
+      klass.send :include, app::Routes
+      klass.send :include, other_app::Routes
+      @obj = klass.new
+    end
+     
+    it { @obj.path_for(:heaven).should == '/heaven' }
+    it { @obj.path_for(:hell).should   == '/hell' }
+    it { lambda{ @obj.path_for(:purgatory) }.should raise_error Sinatra::Trails::RouteNotDefined }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rspec'
+require 'rack/test'
+
+$:.unshift File.join(File.dirname( __FILE__), '..', 'lib') 
+
+require 'sinatra/trails'
+
+RSpec::Matchers.define :match_route do |expected|
+  match do |actual|
+    expected.match actual
+  end
+
+  description do
+    "should match route #{expected}"
+  end
+end

data/trails.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sinatra/trails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sinatra-trails"
+  s.version     = Sinatra::Trails::VERSION
+  s.authors     = ["Macario"]
+  s.email       = ["macarui@gmail.com"]
+  s.homepage    = "http://github.com/maca/trails"
+  s.summary     = %q{A named routes Sinatra DSL inspired by Rails routing}
+  s.description = %q{A named routes Sinatra DSL inspired by Rails routing}
+
+  s.rubyforge_project = "sinatra-trails"
+  s.add_dependency 'sinatra'
+  s.add_dependency 'i18n'
+  s.add_dependency 'activesupport', '>= 3.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rack-test'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-trails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Macario
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &70283828463680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70283828463680
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70283828463260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70283828463260
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70283828486540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70283828486540
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70283828486120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70283828486120
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70283828485660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70283828485660
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70283828485240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70283828485240
+description: A named routes Sinatra DSL inspired by Rails routing
+email:
+- macarui@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- lib/sinatra/trails.rb
+- lib/sinatra/trails/version.rb
+- spec/route_generation_spec.rb
+- spec/spec_helper.rb
+- trails.gemspec
+homepage: http://github.com/maca/trails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: sinatra-trails
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: A named routes Sinatra DSL inspired by Rails routing
+test_files:
+- spec/route_generation_spec.rb
+- spec/spec_helper.rb