rails_best_practices 1.1.0 → 1.2.0

data/spec/rails_best_practices/prepares/mailer_prepare_spec.rb

@@ -9,6 +9,6 @@ describe RailsBestPractices::Prepares::MailerPrepare do
     end
     EOF
     runner.prepare('app/mailers/project_mailer.rb', content)
-    RailsBestPractices::Prepares.mailers.should == ["ProjectMailer"]
+    RailsBestPractices::Prepares.mailers.map(&:to_s).should == ["ProjectMailer"]
   end
 end

data/spec/rails_best_practices/prepares/model_prepare_spec.rb

@@ -7,98 +7,189 @@ describe RailsBestPractices::Prepares::ModelPrepare do
     runner.whiny = true
   end
 
-  it "should parse model associations" do
-    content =<<-EOF
-    class Project < ActiveRecord::Base
-      belongs_to              :portfolio
-      has_one                 :project_manager
-      has_many                :milestones
-      has_and_belongs_to_many :categories
+  context "models" do
+    it "class_name with modules ::" do
+      content =<<-EOF
+      class Blog::Post < ActiveRecord::Base
+      end
+      EOF
+      runner.prepare("app/models/admin/post.rb", content)
+      models = RailsBestPractices::Prepares.models
+      models.map(&:to_s).should == ["Blog::Post"]
     end
-    EOF
-    runner.prepare('app/models/project.rb', content)
-    model_associations = RailsBestPractices::Prepares.model_associations
-    model_associations.get_association("Project", "portfolio").should == {"meta" => "belongs_to", "class_name" => "Portfolio"}
-    model_associations.get_association("Project", "project_manager").should == {"meta" => "has_one", "class_name" => "ProjectManager"}
-    model_associations.get_association("Project", "milestones").should == {"meta" => "has_many", "class_name" => "Milestone"}
-    model_associations.get_association("Project", "categories").should == {"meta" => "has_and_belongs_to_many", "class_name" => "Category"}
-  end
 
-  it "should not raise error for finder_sql option" do
-    content =<<-EOF
-    class EventSubscription < ActiveRecord::Base
-      has_many :event_notification_template, :finder_sql => ?
+    it "class_name with modules" do
+      content =<<-EOF
+      module Blog
+        class Post < ActiveRecord::Base
+        end
+      end
+      EOF
+      runner.prepare("app/models/admin/post.rb", content)
+      models = RailsBestPractices::Prepares.models
+      models.map(&:to_s).should == ["Blog::Post"]
     end
-    EOF
-    content.sub!('?', '\'SELECT event_notification_templates.* from event_notification_templates where event_type_id=#{event_type_id} and delivery_method_id=#{delivery_method_id}\'')
-    lambda { runner.prepare('app/models/event_subscription.rb', content) }.should_not raise_error
   end
 
-  it "class_name with modules ::" do
-    content =<<-EOF
-    class Blog::Post < ActiveRecord::Base
+  context "associations" do
+    it "should parse model associations" do
+      content =<<-EOF
+      class Project < ActiveRecord::Base
+        belongs_to              :portfolio
+        has_one                 :project_manager
+        has_many                :milestones
+        has_and_belongs_to_many :categories
+      end
+      EOF
+      runner.prepare('app/models/project.rb', content)
+      model_associations = RailsBestPractices::Prepares.model_associations
+      model_associations.get_association("Project", "portfolio").should == {"meta" => "belongs_to", "class_name" => "Portfolio"}
+      model_associations.get_association("Project", "project_manager").should == {"meta" => "has_one", "class_name" => "ProjectManager"}
+      model_associations.get_association("Project", "milestones").should == {"meta" => "has_many", "class_name" => "Milestone"}
+      model_associations.get_association("Project", "categories").should == {"meta" => "has_and_belongs_to_many", "class_name" => "Category"}
+    end
+
+    context "with class_name option" do
+      it "should parse belongs_to" do
+        content =<<-EOF
+        class Post < ActiveRecord::Base
+          belongs_to :author, "class_name" => "Person"
+        end
+        EOF
+        runner.prepare("app/models/post.rb", content)
+        model_associations = RailsBestPractices::Prepares.model_associations
+        model_associations.get_association("Post", "author").should == {"meta" => "belongs_to", "class_name" => "Person"}
+      end
+
+      it "should parse has_one" do
+        content =<<-EOF
+        class Project < ActiveRecord::Base
+          has_one :project_manager, "class_name" => "Person"
+        end
+        EOF
+        runner.prepare("app/models/post.rb", content)
+        model_associations = RailsBestPractices::Prepares.model_associations
+        model_associations.get_association("Project", "project_manager").should == {"meta" => "has_one", "class_name" => "Person"}
+      end
+
+      it "should parse has_many" do
+        content =<<-EOF
+        class Project < ActiveRecord::Base
+          has_many :people, "class_name" => "Person"
+        end
+        EOF
+        runner.prepare("app/models/project.rb", content)
+        model_associations = RailsBestPractices::Prepares.model_associations
+        model_associations.get_association("Project", "people").should == {"meta" => "has_many", "class_name" => "Person"}
+      end
+
+      it "should parse has_and_belongs_to_many" do
+        content =<<-EOF
+        class Citizen < ActiveRecord::Base
+          has_and_belongs_to_many :nations, "class_name" => "Country"
+        end
+        EOF
+        runner.prepare("app/models/citizen.rb", content)
+        model_associations = RailsBestPractices::Prepares.model_associations
+        model_associations.get_association("Citizen", "nations").should == {"meta" => "has_and_belongs_to_many", "class_name" => "Country"}
+      end
     end
-    EOF
-    runner.prepare("app/models/admin/post.rb", content)
-    models = RailsBestPractices::Prepares.models
-    models.should == ["Blog::Post"]
   end
 
-  it "class_name with modules" do
-    content =<<-EOF
-    module Blog
+  context "methods" do
+    it "should parse model methods" do
+      content =<<-EOF
       class Post < ActiveRecord::Base
+        def save; end
+        def find; end
       end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Post").map(&:method_name).should == ["save", "find"]
     end
-    EOF
-    runner.prepare("app/models/admin/post.rb", content)
-    models = RailsBestPractices::Prepares.models
-    models.should == ["Blog::Post"]
-  end
 
-  context "class_name" do
-    it "should parse belongs_to" do
+    it "should parse model methods with access control" do
       content =<<-EOF
       class Post < ActiveRecord::Base
-        belongs_to :author, "class_name" => "Person"
+        def save; end
+        def find; end
+        protected
+        def create_or_update; end
+        private
+        def find_by_sql; end
       end
       EOF
       runner.prepare("app/models/post.rb", content)
-      model_associations = RailsBestPractices::Prepares.model_associations
-      model_associations.get_association("Post", "author").should == {"meta" => "belongs_to", "class_name" => "Person"}
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Post").map(&:method_name).should == ["save", "find", "create_or_update", "find_by_sql"]
+      methods.get_methods("Post", "public").map(&:method_name).should == ["save", "find"]
+      methods.get_methods("Post", "protected").map(&:method_name).should == ["create_or_update"]
+      methods.get_methods("Post", "private").map(&:method_name).should == ["find_by_sql"]
     end
 
-    it "should parse has_one" do
+    it "should parse model methods with module ::" do
       content =<<-EOF
-      class Project < ActiveRecord::Base
-        has_one :project_manager, "class_name" => "Person"
+      class Admin::Blog::Post < ActiveRecord::Base
+        def save; end
+        def find; end
+      end
+      EOF
+      runner.prepare("app/models/admin/blog/post.rb", content)
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Admin::Blog::Post").map(&:method_name).should == ["save", "find"]
+    end
+
+    it "should parse model methods with module" do
+      content =<<-EOF
+      module Admin
+        module Blog
+          class Post < ActiveRecord::Base
+            def save; end
+            def find; end
+          end
+        end
+      end
+      EOF
+      runner.prepare("app/models/admin/blog/post.rb", content)
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Admin::Blog::Post").map(&:method_name).should == ["save", "find"]
+    end
+  end
+
+  context "scope" do
+    it "should treat named_scope as method" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        named_scope :active, :conditions => {:active => true}
       end
       EOF
       runner.prepare("app/models/post.rb", content)
-      model_associations = RailsBestPractices::Prepares.model_associations
-      model_associations.get_association("Project", "project_manager").should == {"meta" => "has_one", "class_name" => "Person"}
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Post").map(&:method_name).should == ["active"]
     end
 
-    it "should parse has_many" do
+    it "should treat scope as method" do
       content =<<-EOF
-      class Project < ActiveRecord::Base
-        has_many :people, "class_name" => "Person"
+      class Post < ActiveRecord::Base
+        scope :active, where(:active => true)
       end
       EOF
-      runner.prepare("app/models/project.rb", content)
-      model_associations = RailsBestPractices::Prepares.model_associations
-      model_associations.get_association("Project", "people").should == {"meta" => "has_many", "class_name" => "Person"}
+      runner.prepare("app/models/post.rb", content)
+      methods = RailsBestPractices::Prepares.model_methods
+      methods.get_methods("Post").map(&:method_name).should == ["active"]
     end
+  end
 
-    it "should parse has_and_belongs_to_many" do
+  context "no error" do
+    it "should raised for finder_sql option" do
       content =<<-EOF
-      class Citizen < ActiveRecord::Base
-        has_and_belongs_to_many :nations, "class_name" => "Country"
+      class EventSubscription < ActiveRecord::Base
+        has_many :event_notification_template, :finder_sql => ?
       end
       EOF
-      runner.prepare("app/models/citizen.rb", content)
-      model_associations = RailsBestPractices::Prepares.model_associations
-      model_associations.get_association("Citizen", "nations").should == {"meta" => "has_and_belongs_to_many", "class_name" => "Country"}
+      content.sub!('?', '\'SELECT event_notification_templates.* from event_notification_templates where event_type_id=#{event_type_id} and delivery_method_id=#{delivery_method_id}\'')
+      lambda { runner.prepare('app/models/event_subscription.rb', content) }.should_not raise_error
     end
   end
 end

data/spec/rails_best_practices/reviews/move_model_logic_into_model_review_spec.rb

@@ -16,9 +16,9 @@ describe RailsBestPractices::Reviews::MoveModelLogicIntoModelReview do
         else
           @post.popular = 0
         end
-      end
 
-      redirect_to post_url(@post)
+        redirect_to post_url(@post)
+      end
     end
     EOF
     runner.review('app/controllers/posts_controller.rb', content)
@@ -34,9 +34,26 @@ describe RailsBestPractices::Reviews::MoveModelLogicIntoModelReview do
         @post = Post.find(params[:id])
         @post.update_attributes(:is_published, true)
         @post.approved_by = current_user
+
+        redirect_to post_url(@post)
       end
+    end
+    EOF
+    runner.review('app/controllers/posts_controller.rb', content)
+    runner.should have(0).errors
+  end
+
+  it "should not move model logic into model with self calling" do
+    content = <<-EOF
+    class PostsController < ApplicationController
 
-      redirect_to post_url(@post)
+      def publish
+        self.step1
+        self.step2
+        self.step3
+        self.step4
+        self.step5
+      end
     end
     EOF
     runner.review('app/controllers/posts_controller.rb', content)

data/spec/rails_best_practices/reviews/needless_deep_nesting_review_spec.rb

@@ -108,6 +108,20 @@ describe RailsBestPractices::Reviews::NeedlessDeepNestingReview do
       runner.should have(0).errors
     end
 
+    it "should not needless deep nesting for shallow 4 levels" do
+      content = <<-EOF
+      resources :applications, shallow: true, only: [:index, :show, :create] do
+        resources :events, only: [:index, :show, :create, :subscribe, :push] do
+          resources :executions, only: [:index, :show] do
+            resources :execution_statuses, only: :index
+          end
+        end
+      end
+      EOF
+      runner.review('config/routes.rb', content)
+      runner.should have(0).errors
+    end
+
     it "should needless deep nesting with resource" do
       content = <<-EOF
       resources :posts do

data/spec/rails_best_practices/reviews/remove_unused_methods_in_models_review_spec.rb

@@ -0,0 +1,387 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Reviews::RemoveUnusedMethodsInModelsReview do
+  let(:runner) { RailsBestPractices::Core::Runner.new(
+    :prepares => [RailsBestPractices::Prepares::ModelPrepare.new, RailsBestPractices::Prepares::ControllerPrepare.new],
+    :reviews => RailsBestPractices::Reviews::RemoveUnusedMethodsInModelsReview.new({'except_methods' => ['set_cache']})
+  ) }
+
+  context "private" do
+    it "should remove unused methods" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def find; end
+        private
+        def find_by_sql; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def get
+          Post.new.find
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(1).errors
+      runner.errors[0].to_s.should == "app/models/post.rb:4 - remove unused methods (Post#find_by_sql)"
+    end
+
+    it "should not remove unused methods with except_methods" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def set_cache; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused methods with var_ref" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def find;
+          find_by_sql
+        end
+        private
+        def find_by_sql; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def get
+          Post.new.find
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused methods with callback" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        after_save :expire_cache
+        private
+        def expire_cache; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with command" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def fetch
+          get(:position => 'first')
+        end
+        private
+        def get(options={}); end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def get
+          Post.new.fetch
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with call" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def conditions
+          self.build_conditions({})
+        end
+        private
+        def build_conditions(conditions={}); end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def get
+          Post.new.conditions
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with message" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def save
+          transaction true do
+            self.update
+          end
+        end
+        private
+        def transaction(force); end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def create
+          Post.new.save
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with validation condition" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        validates_uniqueness_of :login, :if => :email_blank?
+        private
+        def email_blank?; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with aasm" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        aasm_state :accepted, :enter => [:update_datetime]
+        private
+        def update_datetime; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused method with initialize" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        private
+        def initialize; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+  end
+
+  context "public" do
+    it "should remove unused methods" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def fetch; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(1).errors
+      runner.errors[0].to_s.should == "app/models/post.rb:2 - remove unused methods (Post#fetch)"
+    end
+
+    it "should not remove unused methods" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def fetch; end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def show
+          @post.fetch
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused methods for attribute assignment" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def user=(user); end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should not remove unused methods for try" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        def find(user_id); end
+      end
+      EOF
+      runner.prepare('app/models/post.rb', content)
+      runner.review('app/models/post.rb', content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def find
+          Post.new.try(:find, current_user.id)
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+  end
+
+  context "protected" do
+    it "should not remove unused methods" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        protected
+        def test; end
+      end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      runner.review("app/models/post.rb", content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def test
+          Post.new.test
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(1).errors
+      runner.errors[0].to_s.should == "app/models/post.rb:3 - remove unused methods (Post#test)"
+    end
+
+    it "should not remove unused methods" do
+      post_content =<<-EOF
+      class Post < ActiveRecord::Base
+        protected
+        def test; end
+      end
+      EOF
+      blog_post_content =<<-EOF
+      class BlogPost < Post
+        def play
+          test
+        end
+      end
+      EOF
+      runner.prepare("app/models/post.rb", post_content)
+      runner.prepare("app/models/blog_post.rb", blog_post_content)
+      runner.review("app/models/post.rb", post_content)
+      runner.review("app/models/blog_post.rb", blog_post_content)
+      content =<<-EOF
+      class BlogPostsController < ApplicationController
+        def play
+          BlogPost.new.play
+        end
+      end
+      EOF
+      runner.review('app/controllers/posts_controller.rb', content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+  end
+
+  context "named_scope" do
+    it "should not remove unused named_scope" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        named_scope :active, :conditions => {:active => true}
+      end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      runner.review("app/models/post.rb", content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def index
+          @posts = Post.active
+        end
+      end
+      EOF
+      runner.review("app/controllers/posts_controller.rb", content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should remove unused named_scope" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        named_scope :active, :conditions => {:active => true}
+      end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      runner.review("app/models/post.rb", content)
+      runner.on_complete
+      runner.should have(1).errors
+      runner.errors[0].to_s.should == "app/models/post.rb:2 - remove unused methods (Post#active)"
+    end
+  end
+
+  context "scope" do
+    it "should not remove unused scope" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        scope :active, where(:active => true)
+      end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      runner.review("app/models/post.rb", content)
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def index
+          @posts = Post.active
+        end
+      end
+      EOF
+      runner.review("app/controllers/posts_controller.rb", content)
+      runner.on_complete
+      runner.should have(0).errors
+    end
+
+    it "should remove unused named_scope" do
+      content =<<-EOF
+      class Post < ActiveRecord::Base
+        scope :active, where(:active => true)
+      end
+      EOF
+      runner.prepare("app/models/post.rb", content)
+      runner.review("app/models/post.rb", content)
+      runner.on_complete
+      runner.should have(1).errors
+      runner.errors[0].to_s.should == "app/models/post.rb:2 - remove unused methods (Post#active)"
+    end
+  end
+end