rails_best_practices 1.18.1 → 1.19.0

data/lib/rails_best_practices/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module RailsBestPractices
-  VERSION = "1.18.1"
+  VERSION = "1.19.0"
 end

data/rails_best_practices.gemspec

@@ -16,7 +16,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
 
   s.add_dependency("activesupport")
-  s.add_dependency("code_analyzer", ">= 0.4.3")
+  # TODO: add a dependency for Rails >= 3 ?
+  s.add_dependency("code_analyzer", ">= 0.4.8")
   s.add_dependency("erubis")
   s.add_dependency("i18n")
   s.add_dependency("require_all")
@@ -29,7 +30,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency("slim")
   s.add_development_dependency("bundler")
   s.add_development_dependency("awesome_print")
-  s.add_development_dependency("rubocop", "= 0.30.1")
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/rails_best_practices/analyzer_spec.rb

@@ -104,7 +104,7 @@ module RailsBestPractices
         expect(result).to eq([
           "\e[31mapp/models/user.rb:10 - law of demeter\e[0m",
           "\e[31mapp/models/post.rb:100 - use query attribute\e[0m",
-          "\e[32m\nPlease go to http://rails-bestpractices.com to see more useful Rails Best Practices.\e[0m",
+          "\e[32m\nPlease go to https://rails-bestpractices.com to see more useful Rails Best Practices.\e[0m",
           "\e[31m\nFound 2 warnings.\e[0m"].join("\n") + "\n")
       end
     end

data/spec/rails_best_practices/prepares/route_prepare_spec.rb

@@ -5,669 +5,205 @@ module RailsBestPractices
     describe RoutePrepare do
       let(:runner) { Core::Runner.new(prepares: RoutePrepare.new) }
 
-      context "rails2" do
-        context "resources" do
-          it "should add resources route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(7)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
-          end
-
-          it "should add multiple resources route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, :users
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(14)
-          end
-
-          it "should add resources route with explict controller" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, controller: :blog_posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(7)
-            expect(routes.map(&:to_s)).to eq(["BlogPostsController#index", "BlogPostsController#show", "BlogPostsController#new", "BlogPostsController#create", "BlogPostsController#edit", "BlogPostsController#update", "BlogPostsController#destroy"])
-          end
-
-          it "should add resources route with only option" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, only: [:index, :show, :new, :create]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(4)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should add resources route with except option" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, except: [:edit, :update, :destroy]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(4)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should not add resources routes with only: :none" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, only: :none
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should not add resources routes with except: :all" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, except: :all
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should add resource routes with hash collection/member routes" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, only: [:show], collection: { list: :get }, member: { create: :post, update: :put, destroy: :delete }
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(5)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#create", "PostsController#update", "PostsController#destroy", "PostsController#list"])
-          end
-
-          it "should add resource routes with array collection/member routes" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts, only: [:show], collection: [:list], member: [:create, :update, :destroy]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(5)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#create", "PostsController#update", "PostsController#destroy", "PostsController#list"])
-          end
-
-          it "should add route with nested routes" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resources :posts do |post|
-                post.resources :comments
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(14)
-          end
-
-          it "should add route with namespace" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.namespace :admin do |admin|
-                admin.namespace :test do |test|
-                  test.resources :posts, only: [:index]
-                end
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq(["Admin::Test::PostsController#index"])
-          end
-        end
-
-        context "resource" do
-          it "should add resource route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(6)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
-          end
-
-          it "should add multiple resource route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts, :users
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(12)
-          end
-
-          it "should add resource route with only option" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts, only: [:show, :new, :create]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(3)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should add resource route with except option" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts, except: [:edit, :update, :destroy]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(3)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should not add resource routes with only: :none" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts, only: :none
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should not add resource routes with except: :all" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.resource :posts, except: :all
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
+      context "resources" do
+        it "should add resources route" do
+          content =<<-EOF
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts
           end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.size).to eq(7)
+          expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
         end
 
-        it "should add connect route" do
+        it "should add multiple resources route" do
           content =<<-EOF
-          ActionController::Routing::Routes.draw do |map|
-            map.connect 'vote', controller: "votes", action: "create", method: :post
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, :users
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["VotesController#create"])
+          expect(routes.size).to eq(14)
         end
 
-        it "should add connect route with all actions" do
+        it "should add resources route with explict controller" do
           content =<<-EOF
-          ActionController::Routing::Routes.draw do |map|
-            map.connect 'internal/:action/*whatever', controller: "internal"
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, controller: :blog_posts
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["InternalController#*"])
+          expect(routes.size).to eq(7)
+          expect(routes.map(&:to_s)).to eq(["BlogPostsController#index", "BlogPostsController#show", "BlogPostsController#new", "BlogPostsController#create", "BlogPostsController#edit", "BlogPostsController#update", "BlogPostsController#destroy"])
         end
 
-        it "should add named route" do
+        it "should add resources route with only option" do
           content =<<-EOF
-          ActionController::Routing::Routes.draw do |map|
-            map.login '/player/login', controller: 'sessions', action: 'new', conditions: { method: :get }
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, only: [:index, :show, :new, :create]
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["SessionsController#new"])
+          expect(routes.size).to eq(4)
+          expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
         end
 
-        it "should add named route with with_options" do
+        it "should add resources route with except option" do
           content =<<-EOF
-          ActionController::Routing::Routes.draw do |map|
-            map.with_options(controller: "admin_session") do |session|
-              session.login '/login', action: 'new', method: :get
-            end
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, except: [:edit, :update, :destroy]
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["AdminSessionController#new"])
+          expect(routes.size).to eq(4)
+          expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
         end
 
-        it "should not take former resources for direct get/post" do
+        it "should not add resources routes with only: :none" do
           content =<<-EOF
-          ActionController::Routing::Routes.draw do |map|
-            map.resources :posts
-            map.stop 'sprints/stop', controller: 'sprints', action: 'stop'
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, only: :none
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.last.to_s).to eq("SprintsController#stop")
+          expect(routes.size).to eq(0)
         end
-      end
-
-      context "rails3" do
-        context "resources" do
-          it "should add resources route" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(7)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
-          end
-
-          it "should add multiple resources route" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, :users
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(14)
-          end
 
-          it "should add resources route with explict controller" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, controller: :blog_posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(7)
-            expect(routes.map(&:to_s)).to eq(["BlogPostsController#index", "BlogPostsController#show", "BlogPostsController#new", "BlogPostsController#create", "BlogPostsController#edit", "BlogPostsController#update", "BlogPostsController#destroy"])
-          end
-
-          it "should add resources route with only option" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, only: [:index, :show, :new, :create]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(4)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should add resources route with except option" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, except: [:edit, :update, :destroy]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(4)
-            expect(routes.map(&:to_s)).to eq(["PostsController#index", "PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should not add resources routes with only: :none" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, only: :none
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should not add resources routes with except: :all" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, except: :all
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should add resources routes with members" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              namespace :admin do
-                resources :posts, :only => [:edit, :update] do
-                  member do
-                    post 'link_to/:other_id' => 'posts#link_to_post'
-                    post 'extra_update' => 'posts#extra_update'
-                  end
-                end
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq([
-              "Admin::PostsController#edit",
-              "Admin::PostsController#update",
-              "Admin::PostsController#link_to_post",
-              "Admin::PostsController#extra_update"])
-          end
-
-          it "should add connect route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.connect 'vote', controller: "votes", action: "create", method: :post
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq(["VotesController#create"])
-          end
-
-          it "should add named route" do
-            content =<<-EOF
-            ActionController::Routing::Routes.draw do |map|
-              map.login '/player/login', controller: 'sessions', action: 'new', conditions: { method: :get }
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq(["SessionsController#new"])
+        it "should not add resources routes with except: :all" do
+          content =<<-EOF
+          RailsBestPracticesCom::Application.routes.draw do
+            resources :posts, except: :all
           end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.size).to eq(0)
         end
 
-        context "resource" do
-          it "should add resource route" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(6)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
-          end
-
-          it "should add multiple resource route" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts, :users
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(12)
-          end
-
-          it "should add resource route with only option" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts, only: [:show, :new, :create]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(3)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should add resource route with except option" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts, except: [:edit, :update, :destroy]
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(3)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
-          end
-
-          it "should not add resource routes with only: :none" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts, only: :none
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should not add resource routes with except: :all" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resource :posts, except: :all
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(0)
-          end
-
-          it "should add resource routes with get/post/put/patch/delete routes" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, only: [:show] do
-                get :list, on: :collection
-                collection do
-                  get :search
-                  match :available
-                end
-                post :create, on: :member
+        it "should add resources routes with members" do
+          content =<<-EOF
+          RailsBestPracticesCom::Application.routes.draw do
+            namespace :admin do
+              resources :posts, :only => [:edit, :update] do
                 member do
-                  put :update
-                  patch :update
-                end
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(7)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#list", "PostsController#search", "PostsController#available", "PostsController#create", "PostsController#update", "PostsController#update"])
-          end
-
-          it "should add custom resources routes with {}" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, only: [:show] { get :inactive, on: :collection }
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(2)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#inactive"])
-          end
-
-          it "should add resources routes with get %w() routes" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts, only: [:show] do
-                collection do
-                  get *%w(latest popular)
+                  post 'link_to/:other_id' => 'posts#link_to_post'
+                  post 'extra_update' => 'posts#extra_update'
                 end
               end
             end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(3)
-            expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#latest", "PostsController#popular"])
-          end
-
-          it "should add route with nested routes" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              resources :posts
-                resources :comments
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.size).to eq(14)
-          end
-
-          it "should add route with namespace" do
-            content =<<-EOF
-            RailsBestPracticesCom::Application.routes.draw do
-              namespace :admin do
-                namespace :test do
-                  resources :posts, only: [:index]
-                end
-              end
-            end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq(["Admin::Test::PostsController#index"])
           end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.map(&:to_s)).to eq([
+            "Admin::PostsController#edit",
+            "Admin::PostsController#update",
+            "Admin::PostsController#link_to_post",
+            "Admin::PostsController#extra_update"])
+        end
 
-          it "should add route with namespace, but without resources" do
-            content =<<-EOF
-            RailsBestPracticesCom::Appllication.routes.draw do
-              namespace :something do
-                get *%w(route_one route_two)
-                get :route_three, action: "custom_action"
+        it "should add resources routes with members inline" do
+          content =<<-EOF
+          RailsBestPracticesCom::Application.routes.draw do
+            namespace :admin do
+              resources :posts, :only => [:edit, :update] do
+                post :link_to_post, :extra_update, :retrieve, on: :member
               end
             end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq(["SomethingController#route_one", "SomethingController#route_two", "SomethingController#custom_action"])
-          end
-
-          it "should add route with scope" do
-            content =<<-EOF
-              RailsBestPracticesCom::Application.routes.draw do
-                scope module: "admin" do
-                  resources :posts, only: [:index]
-                end
-                resources :discussions, only: [:index], module: "admin"
-                scope "/admin" do
-                  resources :comments, only: [:index]
-                end
-                scope "/:username", controller: :users do
-                  get '/' => :show
-                  scope 'topic' do
-                    get 'preview', as: 'preview_user', action: 'preview'
-                  end
-                end
-              end
-            EOF
-            runner.prepare('config/routes.rb', content)
-            routes = Prepares.routes
-            expect(routes.map(&:to_s)).to eq([
-                                           "Admin::PostsController#index",
-                                           "Admin::DiscussionsController#index",
-                                           "CommentsController#index",
-                                           "UsersController#show",
-                                           "UsersController#preview"
-                                         ])
           end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.map(&:to_s)).to eq([
+            "Admin::PostsController#edit",
+            "Admin::PostsController#update",
+            "Admin::PostsController#link_to_post",
+            "Admin::PostsController#extra_update",
+            "Admin::PostsController#retrieve"])
         end
 
-        it "should add route for direct get/post" do
+        it "should add connect route" do
           content =<<-EOF
-          RailsBestPracticesCom::Application.routes.draw do
-            get 'posts/show'
-            post '/posts' => 'posts#create'
-            put '/posts/:id' => 'posts#update'
-            delete '/post/:id' => 'posts#destroy'
-            get '/agb' => 'high_voltage/pages#show', id: 'agb'
+          ActionController::Routing::Routes.draw do |map|
+            map.connect 'vote', controller: "votes", action: "create", method: :post
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.size).to eq(5)
-          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#create", "PostsController#update", "PostsController#destroy", "HighVoltage::PagesController#show"])
+          expect(routes.map(&:to_s)).to eq(["VotesController#create"])
         end
 
-        it "should add routes for another get/post" do
+        it "should add named route" do
           content =<<-EOF
-          RailsBestPracticesCom::Application.routes.draw
-            get "/login", to: 'sessions#new', as: :login
+          ActionController::Routing::Routes.draw do |map|
+            map.login '/player/login', controller: 'sessions', action: 'new', conditions: { method: :get }
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.size).to eq(1)
-          expect(routes.first.to_s).to eq("SessionsController#new")
+          expect(routes.map(&:to_s)).to eq(["SessionsController#new"])
         end
+      end
 
-        it "should add match route" do
+      context "resource" do
+        it "should add resource route" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            match '/auth/:provider/callback' => 'authentications#create'
+            resource :posts
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["AuthenticationsController#create"])
+          expect(routes.size).to eq(6)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create", "PostsController#edit", "PostsController#update", "PostsController#destroy"])
         end
 
-        it "should add match route with all actions" do
+        it "should add multiple resource route" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            match 'internal/:action/*whatever', controller: "internal"
+            resource :posts, :users
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["InternalController#*"])
+          expect(routes.size).to eq(12)
         end
 
-        it "should add root route" do
+        it "should add resource route with only option" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            root to: 'home#index'
+            resource :posts, only: [:show, :new, :create]
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["HomeController#index"])
+          expect(routes.size).to eq(3)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
         end
 
-        it "should add root shortcut route" do
+        it "should add resource route with except option" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            root 'home#index'
+            resource :posts, except: [:edit, :update, :destroy]
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.map(&:to_s)).to eq(["HomeController#index"])
+          expect(routes.size).to eq(3)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#new", "PostsController#create"])
         end
 
-        it "should do nothing for default route" do
+        it "should not add resource routes with only: :none" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            match ':controller(/:action(/:id(.:format)))'
+            resource :posts, only: :none
           end
           EOF
           runner.prepare('config/routes.rb', content)
@@ -675,11 +211,10 @@ module RailsBestPractices
           expect(routes.size).to eq(0)
         end
 
-        it "should do nothing for redirect" do
+        it "should not add resource routes with except: :all" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            match "/stories/:name" => redirect("/posts/%{name}")
-            match "/stories" => redirect {|p, req| "/posts/\#{req.subdomain}" }
+            resource :posts, except: :all
           end
           EOF
           runner.prepare('config/routes.rb', content)
@@ -687,68 +222,285 @@ module RailsBestPractices
           expect(routes.size).to eq(0)
         end
 
-        it "should parse customize route in nested resources" do
+        it "should add resource routes with get/post/put/patch/delete routes" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            resources :posts do
-              resources :comments
-              post :stop
+            resources :posts, only: [:show] do
+              get :list, on: :collection
+              collection do
+                get :search
+                match :available
+              end
+              post :create, on: :member
+              member do
+                put :update
+                patch :update
+              end
             end
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.last.to_s).to eq("PostsController#stop")
+          expect(routes.size).to eq(7)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#list", "PostsController#search", "PostsController#available", "PostsController#create", "PostsController#update", "PostsController#update"])
         end
 
-        it "should parse custom route for resource with explicit to and different action name" do
+        it "should add custom resources routes with {}" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            resources :posts do
-              get :halt, to: 'posts#stop'
-            end
+            resources :posts, only: [:show] { get :inactive, on: :collection }
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.last.to_s).to eq("PostsController#stop")
+          expect(routes.size).to eq(2)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#inactive"])
         end
 
-        it "should parse custom route for resource with symbol action name" do
+        it "should add resources routes with get %w() routes" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            resources :posts do
-              get :halt, to: :stop
+            resources :posts, only: [:show] do
+              collection do
+                get *%w(latest popular)
+              end
             end
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.last.to_s).to eq("PostsController#stop")
+          expect(routes.size).to eq(3)
+          expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#latest", "PostsController#popular"])
         end
 
-        it "should not take former resources for direct get/post" do
+        it "should add route with nested routes" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
             resources :posts
-            post "sprints/stop"
+              resources :comments
+            end
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.last.to_s).to eq("SprintsController#stop")
+          expect(routes.size).to eq(14)
         end
 
-        it "should not parse wrong route" do
+        it "should add route with namespace" do
           content =<<-EOF
           RailsBestPracticesCom::Application.routes.draw do
-            match ':controller/:action' => '#index', as: :auto_complete
+            namespace :admin do
+              namespace :test do
+                resources :posts, only: [:index]
+              end
+            end
           end
           EOF
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
-          expect(routes.size).to eq(0)
+          expect(routes.map(&:to_s)).to eq(["Admin::Test::PostsController#index"])
+        end
+
+        it "should add route with namespace, but without resources" do
+          content =<<-EOF
+          RailsBestPracticesCom::Appllication.routes.draw do
+            namespace :something do
+              get *%w(route_one route_two)
+              get :route_three, action: "custom_action"
+            end
+          end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.map(&:to_s)).to eq(["SomethingController#route_one", "SomethingController#route_two", "SomethingController#custom_action"])
+        end
+
+        it "should add route with scope" do
+          content =<<-EOF
+            RailsBestPracticesCom::Application.routes.draw do
+              scope module: "admin" do
+                resources :posts, only: [:index]
+              end
+              resources :discussions, only: [:index], module: "admin"
+              scope "/admin" do
+                resources :comments, only: [:index]
+              end
+              scope "/:username", controller: :users do
+                get '/' => :show
+                scope 'topic' do
+                  get 'preview', as: 'preview_user', action: 'preview'
+                end
+              end
+            end
+          EOF
+          runner.prepare('config/routes.rb', content)
+          routes = Prepares.routes
+          expect(routes.map(&:to_s)).to eq([
+                                          "Admin::PostsController#index",
+                                          "Admin::DiscussionsController#index",
+                                          "CommentsController#index",
+                                          "UsersController#show",
+                                          "UsersController#preview"
+                                        ])
+        end
+      end
+
+      it "should add route for direct get/post" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          get 'posts/show'
+          post '/posts' => 'posts#create'
+          put '/posts/:id' => 'posts#update'
+          delete '/post/:id' => 'posts#destroy'
+          get '/agb' => 'high_voltage/pages#show', id: 'agb'
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.size).to eq(5)
+        expect(routes.map(&:to_s)).to eq(["PostsController#show", "PostsController#create", "PostsController#update", "PostsController#destroy", "HighVoltage::PagesController#show"])
+      end
+
+      it "should add routes for another get/post" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw
+          get "/login", to: 'sessions#new', as: :login
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.size).to eq(1)
+        expect(routes.first.to_s).to eq("SessionsController#new")
+      end
+
+      it "should add match route" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          match '/auth/:provider/callback' => 'authentications#create'
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.map(&:to_s)).to eq(["AuthenticationsController#create"])
+      end
+
+      it "should add match route with all actions" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          match 'internal/:action/*whatever', controller: "internal"
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.map(&:to_s)).to eq(["InternalController#*"])
+      end
+
+      it "should add root route" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          root to: 'home#index'
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.map(&:to_s)).to eq(["HomeController#index"])
+      end
+
+      it "should add root shortcut route" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          root 'home#index'
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.map(&:to_s)).to eq(["HomeController#index"])
+      end
+
+      it "should do nothing for default route" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          match ':controller(/:action(/:id(.:format)))'
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.size).to eq(0)
+      end
+
+      it "should do nothing for redirect" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          match "/stories/:name" => redirect("/posts/%{name}")
+          match "/stories" => redirect {|p, req| "/posts/\#{req.subdomain}" }
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.size).to eq(0)
+      end
+
+      it "should parse customize route in nested resources" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          resources :posts do
+            resources :comments
+            post :stop
+          end
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.last.to_s).to eq("PostsController#stop")
+      end
+
+      it "should parse custom route for resource with explicit to and different action name" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          resources :posts do
+            get :halt, to: 'posts#stop'
+          end
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.last.to_s).to eq("PostsController#stop")
+      end
+
+      it "should parse custom route for resource with symbol action name" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          resources :posts do
+            get :halt, to: :stop
+          end
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.last.to_s).to eq("PostsController#stop")
+      end
+
+      it "should not take former resources for direct get/post" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          resources :posts
+          post "sprints/stop"
+        end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.last.to_s).to eq("SprintsController#stop")
+      end
+
+      it "should not parse wrong route" do
+        content =<<-EOF
+        RailsBestPracticesCom::Application.routes.draw do
+          match ':controller/:action' => '#index', as: :auto_complete
         end
+        EOF
+        runner.prepare('config/routes.rb', content)
+        routes = Prepares.routes
+        expect(routes.size).to eq(0)
       end
     end
   end