rails_best_practices 1.1.0 → 1.2.0

data/lib/rails_best_practices/reviews.rb

@@ -26,3 +26,4 @@ require 'rails_best_practices/reviews/simplify_render_in_views_review'
 require 'rails_best_practices/reviews/simplify_render_in_controllers_review'
 require 'rails_best_practices/reviews/remove_empty_helpers_review'
 require 'rails_best_practices/reviews/restrict_auto_generated_routes_review'
+require 'rails_best_practices/reviews/remove_unused_methods_in_models_review'

data/lib/rails_best_practices/reviews/needless_deep_nesting_review.rb

@@ -40,6 +40,7 @@ module RailsBestPractices
         super()
         @counter = 0
         @nested_count = options['nested_count'] || 2
+        @shallow_nodes = []
       end
 
       # check all method_add_block node.
@@ -68,16 +69,18 @@ module RailsBestPractices
         # then check if @counter is greater than or equal to @nested_count,
         # if so, it is the needless deep nesting.
         def recursively_check(node)
+          shallow = @shallow_nodes.include? node
           if [:command_call, :command].include?(node[1].sexp_type) && ["resources", "resource"].include?(node[1].message.to_s)
             hash_node = node[1].arguments.grep_node(:sexp_type => :bare_assoc_hash)
-            return if hash_node && "true" == hash_node.hash_value("shallow").to_s
+            shallow = (hash_node && "true" == hash_node.hash_value("shallow").to_s) unless shallow
             @counter += 1
             node.block.statements.each do |stmt_node|
+              @shallow_nodes << stmt_node if shallow
               recursively_check(stmt_node)
             end
             @counter -= 1
           elsif [:command_call, :command].include?(node.sexp_type) && ["resources", "resource"].include?(node.message.to_s)
-            add_error "needless deep nesting (nested_count > #{@nested_count})", @file, node.line if @counter >= @nested_count
+            add_error "needless deep nesting (nested_count > #{@nested_count})", @file, node.line if @counter >= @nested_count && !@shallow_nodes.include?(node)
           end
         end
     end

data/lib/rails_best_practices/reviews/remove_unused_methods_in_models_review.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+require 'rails_best_practices/reviews/review'
+
+module RailsBestPractices
+  module Reviews
+    class RemoveUnusedMethodsInModelsReview < Review
+      include Klassable
+      include Completeable
+
+      EXCEPT_METHODS = %w(initialize validate to_xml to_json)
+
+      def interesting_nodes
+        [:module, :class, :call, :fcall, :command, :method_add_arg, :var_ref]
+      end
+
+      def initialize(options={})
+        super()
+        @model_methods = Prepares.model_methods
+        @except_methods = EXCEPT_METHODS + options['except_methods']
+      end
+
+      def start_call(node)
+        mark_used(node.message)
+      end
+
+      def start_fcall(node)
+        mark_used(node.message)
+      end
+
+      def start_var_ref(node)
+        mark_used(node)
+      end
+
+      def start_command(node)
+        unless %w(named_scope scope).include? node.message.to_s
+          mark_used(node.message)
+          node.arguments.all.each { |argument| mark_used(argument) }
+        end
+      end
+
+      def start_method_add_arg(node)
+        if "try" == node.message.to_s
+          method_name = node.arguments.all[0].to_s
+          call_method(method_name)
+        end
+      end
+
+      def on_complete
+        @model_methods.get_all_unused_methods.each do |method|
+          if !@except_methods.include?(method.method_name) && method.method_name !~ /=$/
+            add_error "remove unused methods (#{method.class_name}##{method.method_name})", method.file, method.line
+          end
+        end
+      end
+
+      private
+        def mark_used(method_node)
+          if :bare_assoc_hash == method_node.sexp_type
+            method_node.hash_values.each { |value_node| mark_used(value_node) }
+          elsif :array == method_node.sexp_type
+            method_node.array_values.each { |value_node| mark_used(value_node) }
+          else
+            method_name = method_node.to_s
+          end
+          call_method(method_name)
+        end
+
+        def call_method(method_name)
+          if @model_methods.has_method?(current_class_name, method_name)
+            @model_methods.get_method(current_class_name, method_name).mark_used
+          end
+          @model_methods.mark_extend_class_method_used(current_class_name, method_name)
+          @model_methods.possible_public_used(method_name)
+        end
+    end
+  end
+end

data/lib/rails_best_practices/reviews/restrict_auto_generated_routes_review.rb

@@ -68,7 +68,7 @@ module RailsBestPractices
           return unless Prepares.controllers.include? controller_name
           resources_methods = resources_methods(node)
           unless resources_methods.all? { |meth| Prepares.controller_methods.has_method?(controller_name, meth) }
-            only_methods = (resources_methods & Prepares.controller_methods.get_methods(controller_name)).map { |meth| ":#{meth}" }.join(", ")
+            only_methods = (resources_methods & Prepares.controller_methods.get_methods(controller_name).map(&:method_name)).map { |meth| ":#{meth}" }.join(", ")
             add_error "restrict auto-generated routes (:only => [#{only_methods}])"
           end
         end
@@ -79,7 +79,7 @@ module RailsBestPractices
           return unless Prepares.controllers.include? controller_name
           resource_methods = resource_methods(node)
           unless resource_methods.all? { |meth| Prepares.controller_methods.has_method?(controller_name, meth) }
-            only_methods = (resource_methods & Prepares.controller_methods.get_methods(controller_name)).map { |meth| ":#{meth}" }.join(", ")
+            only_methods = (resource_methods & Prepares.controller_methods.get_methods(controller_name).map(&:method_name)).map { |meth| ":#{meth}" }.join(", ")
             add_error "restrict auto-generated routes (:only => [#{only_methods}])"
           end
         end

data/lib/rails_best_practices/reviews/review.rb

@@ -16,7 +16,7 @@ module RailsBestPractices
       # then save it to as key in @variable_use_count hash, and add the call count (hash value).
       def remember_variable_use_count(node)
         variable_node = variable(node)
-        if variable_node
+        if variable_node && "self" != variable_node.to_s
           variable_use_count[variable_node.to_s] ||= 0
           variable_use_count[variable_node.to_s] += 1
         end

data/lib/rails_best_practices/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module RailsBestPractices
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end
 

data/rails_best_practices.yml

@@ -27,3 +27,4 @@ SimplifyRenderInControllersCheck: { }
 RemoveEmptyHelpersCheck: { }
 RemoveTabCheck: { }
 RestrictAutoGeneratedRoutesCheck: { }
+# RemoveUnusedMethodsInModelsCheck: { except_methods: [] }

data/spec/fixtures/lib/rails_best_practices/plugins/reviews/not_use_rails_root_review.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'rails_best_practices/reviews/review'
+
+module RailsBestPractices
+  module Plugins
+    module Reviews
+      class NotUseRailsRootReview < RailsBestPractices::Reviews::Review
+      end
+    end
+  end
+end

data/spec/rails_best_practices/core/check_spec.rb

@@ -38,4 +38,26 @@ describe RailsBestPractices::Core::Check do
       check.node_end(node)
     end
   end
+
+  context "callback" do
+    it "should add callback to start_call" do
+      execute = false
+      check.class.add_callback "start_call" do
+        execute = true
+      end
+      node = stub(:sexp_type => :call)
+      check.node_start(node)
+      execute.should be_true
+    end
+
+    it "should ad callbacks to end_call" do
+      execute = false
+      check.class.add_callback "end_call" do
+        execute = true
+      end
+      node = stub(:sexp_type => :call)
+      check.node_end(node)
+      execute.should be_true
+    end
+  end
 end

data/spec/rails_best_practices/core/controllers_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe RailsBestPractices::Core::Controllers do
-  it { should be_a_kind_of Array }
+  it { should be_a_kind_of RailsBestPractices::Core::Klasses }
 end

data/spec/rails_best_practices/core/error_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe RailsBestPractices::Core::Error do
   it "should return error with filename, line number and message" do
-    RailsBestPractices::Core::Error.new("app/models/user.rb", 100, "not good").to_s.should == "app/models/user.rb:100 - not good"
+    RailsBestPractices::Core::Error.new("app/models/user.rb", 100, "not good", "BogusReview").to_s.should == "app/models/user.rb:100 - not good"
   end
 end

data/spec/rails_best_practices/core/klasses_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Core::Klasses do
+  it { should be_a_kind_of Array }
+
+  context "Klass" do
+    it "should get to_s" do
+      klass = RailsBestPractices::Core::Klass.new("BlogPost", "Post", ["Admin"])
+      klass.to_s.should == "Admin::BlogPost"
+    end
+  end
+end

data/spec/rails_best_practices/core/mailers_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Core::Mailers do
+  it { should be_a_kind_of RailsBestPractices::Core::Klasses }
+end

data/spec/rails_best_practices/core/methods_spec.rb

@@ -6,17 +6,39 @@ describe RailsBestPractices::Core::Methods do
   before :each do
     methods.add_method("Post", "create")
     methods.add_method("Post", "destroy")
+    methods.add_method("Post", "save_or_update", {}, "protected")
+    methods.add_method("Post", "find_by_sql", {}, "private")
     methods.add_method("Comment", "create")
   end
 
   it "should get_methods" do
-    methods.get_methods("Post").to_a.should == ["create", "destroy"]
-    methods.get_methods("Comment").to_a.should == ["create"]
+    methods.get_methods("Post").map(&:method_name).should == ["create", "destroy", "save_or_update", "find_by_sql"]
+    methods.get_methods("Post", "public").map(&:method_name).should == ["create", "destroy"]
+    methods.get_methods("Post", "protected").map(&:method_name).should == ["save_or_update"]
+    methods.get_methods("Post", "private").map(&:method_name).should == ["find_by_sql"]
+    methods.get_methods("Comment").map(&:method_name).should == ["create"]
   end
 
   it "should has_method?" do
-    methods.should be_has_method("Post", "create")
-    methods.should be_has_method("Post", "destroy")
+    methods.should be_has_method("Post", "create", "public")
+    methods.should be_has_method("Post", "destroy", "public")
+    methods.should_not be_has_method("Post", "save_or_update", "public")
+    methods.should be_has_method("Post", "save_or_update", "protected")
+    methods.should_not be_has_method("Post", "find_by_sql", "public")
+    methods.should be_has_method("Post", "find_by_sql", "private")
     methods.should_not be_has_method("Comment", "destroy")
   end
+
+  it "should get_method" do
+    methods.get_method("Post", "create", "public").should_not be_nil
+    methods.get_method("Post", "create", "protected").should be_nil
+  end
+
+  it "should get_all_unused_methods" do
+    methods.get_method("Comment", "create").mark_used
+    methods.get_all_unused_methods("public").map(&:method_name).should == ["create", "destroy"]
+    methods.get_all_unused_methods("protected").map(&:method_name).should == ["save_or_update"]
+    methods.get_all_unused_methods("private").map(&:method_name).should == ["find_by_sql"]
+    methods.get_all_unused_methods.map(&:method_name).should == ["create", "destroy", "save_or_update", "find_by_sql"]
+  end
 end

data/spec/rails_best_practices/core/models_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe RailsBestPractices::Core::Models do
-  it { should be_a_kind_of Array }
-end
+  it { should be_a_kind_of RailsBestPractices::Core::Klasses }
+end

data/spec/rails_best_practices/core/runner_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Core::Runner do
+
+  before { RailsBestPractices::Core::Runner.base_path = 'spec/fixtures/' }
+
+  describe "load_plugin_reviews" do
+    it "should load plugins in lib/rails_best_practices/plugins/reviews" do
+      runner = RailsBestPractices::Core::Runner.new
+      runner.instance_variable_get('@reviews').map(&:class).should include(RailsBestPractices::Plugins::Reviews::NotUseRailsRootReview)
+    end
+  end
+end

data/spec/rails_best_practices/core_ext/sexp_spec.rb

@@ -365,17 +365,29 @@ describe Sexp do
   end
 
   describe "hash_keys" do
-    it "should get value for hash node" do
+    it "should get hash_keys for hash node" do
       node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(:sexp_type => :hash)
       node.hash_keys.should == ["first_name", "last_name"]
     end
 
-    it "should get value for bare_assoc_hash" do
+    it "should get hash_keys for bare_assoc_hash" do
       node = parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(:sexp_type => :bare_assoc_hash)
       node.hash_keys.should == ["first_name", "last_name"]
     end
   end
 
+  describe "hash_values" do
+    it "should get hash_values for hash node" do
+      node = parse_content("{first_name: 'Richard', last_name: 'Huang'}").grep_node(:sexp_type => :hash)
+      node.hash_values.map(&:to_s).should == ["Richard", "Huang"]
+    end
+
+    it "should get hash_values for bare_assoc_hash" do
+      node = parse_content("add_user :user, first_name: 'Richard', last_name: 'Huang'").grep_node(:sexp_type => :bare_assoc_hash)
+      node.hash_values.map(&:to_s).should == ["Richard", "Huang"]
+    end
+  end
+
   describe "array_size" do
     it "should get array size" do
       node = parse_content("['first_name', 'last_name']").grep_node(:sexp_type => :array)
@@ -388,6 +400,18 @@ describe Sexp do
     end
   end
 
+  describe "array_values" do
+    it "should get array values" do
+      node = parse_content("['first_name', 'last_name']").grep_node(:sexp_type => :array)
+      node.array_values.map(&:to_s).should == ["first_name", "last_name"]
+    end
+
+    it "should get empty array values" do
+      node = parse_content("[]").grep_node(:sexp_type => :array)
+      node.array_values.should == []
+    end
+  end
+
   describe "to_object" do
     it "should to array" do
       node = parse_content("['first_name', 'last_name']").grep_node(:sexp_type => :array)

data/spec/rails_best_practices/prepares/controller_prepare_spec.rb

@@ -7,86 +7,98 @@ describe RailsBestPractices::Prepares::ControllerPrepare do
     runner.whiny = true
   end
 
-  it "should parse controller methods" do
-    content =<<-EOF
-    class PostsController < ApplicationController
-      def index
-      end
-
-      def show
-      end
-    end
-    EOF
-    runner.prepare('app/controllers/posts_controller.rb', content)
-    methods = RailsBestPractices::Prepares.controller_methods
-    methods.get_methods("PostsController").should == ["index", "show"]
-  end
-
-  it "should parse controller methods with module ::" do
-    content =<<-EOF
-    class Admin::Blog::PostsController < ApplicationController
-      def index
-      end
-
-      def show
-      end
-    end
-    EOF
-    runner.prepare('app/controllers/admin/posts_controller.rb', content)
-    methods = RailsBestPractices::Prepares.controller_methods
-    methods.get_methods("Admin::Blog::PostsController").should == ["index", "show"]
-  end
-
-  it "should parse controller methods with module" do
-    content =<<-EOF
-    module Admin
-      module Blog
-        class PostsController < ApplicationController
-          def index
-          end
-
-          def show
-          end
-        end
+  context "methods" do
+    it "should parse controller methods" do
+      content =<<-EOF
+      class PostsController < ApplicationController
+        def index; end
+        def show; end
       end
+      EOF
+      runner.prepare('app/controllers/posts_controller.rb', content)
+      methods = RailsBestPractices::Prepares.controller_methods
+      methods.get_methods("PostsController").map(&:method_name).should == ["index", "show"]
     end
-    EOF
-    runner.prepare('app/controllers/admin/posts_controller.rb', content)
-    methods = RailsBestPractices::Prepares.controller_methods
-    methods.get_methods("Admin::Blog::PostsController").should == ["index", "show"]
-  end
 
-  describe "inherited_resources" do
-    it "extend inherited_resources" do
+    it "should parse model methods with access control" do
       content =<<-EOF
-      class PostsController < InheritedResources::Base
+      class PostsController < ApplicationController
+        def index; end
+        def show; end
+        protected
+        def resources; end
+        private
+        def resource; end
       end
       EOF
       runner.prepare('app/controllers/posts_controller.rb', content)
       methods = RailsBestPractices::Prepares.controller_methods
-      methods.get_methods("PostsController").should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+      methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "resources", "resource"]
+      methods.get_methods("PostsController", "public").map(&:method_name).should == ["index", "show"]
+      methods.get_methods("PostsController", "protected").map(&:method_name).should == ["resources"]
+      methods.get_methods("PostsController", "private").map(&:method_name).should == ["resource"]
     end
 
-    it "extend inherited_resources with actions" do
+    it "should parse controller methods with module ::" do
       content =<<-EOF
-      class PostsController < InheritedResources::Base
-        actions :index, :show
+      class Admin::Blog::PostsController < ApplicationController
+        def index; end
+        def show; end
       end
       EOF
-      runner.prepare('app/controllers/posts_controller.rb', content)
+      runner.prepare('app/controllers/admin/posts_controller.rb', content)
       methods = RailsBestPractices::Prepares.controller_methods
-      methods.get_methods("PostsController").should == ["index", "show"]
+      methods.get_methods("Admin::Blog::PostsController").map(&:method_name).should == ["index", "show"]
     end
 
-    it "DSL inherit_resources" do
+    it "should parse controller methods with module" do
       content =<<-EOF
-      class PostsController
-        inherit_resources
+      module Admin
+        module Blog
+          class PostsController < ApplicationController
+            def index; end
+            def show; end
+          end
+        end
       end
       EOF
-      runner.prepare('app/controllers/posts_controller.rb', content)
+      runner.prepare('app/controllers/admin/posts_controller.rb', content)
       methods = RailsBestPractices::Prepares.controller_methods
-      methods.get_methods("PostsController").should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+      methods.get_methods("Admin::Blog::PostsController").map(&:method_name).should == ["index", "show"]
+    end
+
+    context "inherited_resources" do
+      it "extend inherited_resources" do
+        content =<<-EOF
+        class PostsController < InheritedResources::Base
+        end
+        EOF
+        runner.prepare('app/controllers/posts_controller.rb', content)
+        methods = RailsBestPractices::Prepares.controller_methods
+        methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+      end
+
+      it "extend inherited_resources with actions" do
+        content =<<-EOF
+        class PostsController < InheritedResources::Base
+          actions :index, :show
+        end
+        EOF
+        runner.prepare('app/controllers/posts_controller.rb', content)
+        methods = RailsBestPractices::Prepares.controller_methods
+        methods.get_methods("PostsController").map(&:method_name).should == ["index", "show"]
+      end
+
+      it "DSL inherit_resources" do
+        content =<<-EOF
+        class PostsController
+          inherit_resources
+        end
+        EOF
+        runner.prepare('app/controllers/posts_controller.rb', content)
+        methods = RailsBestPractices::Prepares.controller_methods
+        methods.get_methods("PostsController").map(&:method_name).should == ["index", "show", "new", "create", "edit", "update", "destroy"]
+      end
     end
   end
 end