rails_best_practices 0.5.6 → 0.6.1

data/lib/rails_best_practices/checks/move_code_into_model_check.rb

@@ -5,49 +5,47 @@ module RailsBestPractices
   module Checks
     # Check a view file to make sure there is no complex logic call for model.
     #
-    # Implementation: Check if a local variable or instance variable called greater than 2 times in if or unless conditional statement, then it should more code into model.
+    # See the best practice details here http://rails-bestpractices.com/posts/25-move-code-into-model.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check if there are multiple method calls or attribute assignments apply to one subject,
+    #   and the subject is a local variable or instance variable,
+    #   then they should be moved into model.
     class MoveCodeIntoModelCheck < Check
 
-      def interesting_nodes
-        [:if, :unless]
+      def interesting_review_nodes
+        [:if]
       end
 
-      def interesting_files
+      def interesting_review_files
         VIEW_FILES
       end
 
-      def evaluate_start(node)
-        @variables = {}
-        node.conditional_statement.grep_nodes(:node_type => :call).each { |call_node| remember_call(call_node) }
-        check_errors
-      end
-
-      private
-
-      def check_errors
-        @variables.each do |node, count|
-          add_error "move code into model (#{node})", node.file, node.line if count > 2
-        end
+      def initialize(options={})
+        super()
+        @use_count = options['use_count'] || 2
       end
 
-      def remember_call(call_node)
-        variable_node = variable(call_node)
-        if variable_node
-          @variables[variable_node] ||= 0
-          @variables[variable_node] += 1
+      # check if node to see whose conditional statementnodes contain multiple call nodes with same subject who is a local variable or instance variable.
+      #
+      # it will check every call and attrasgn nodes in the conditional statement nodes.
+      #
+      # if there are multiple call and attrasgn nodes who have the same subject,
+      # and the subject is a local variable or an instance variable,
+      # then the conditional statement nodes should be moved into model.
+      def review_start_if(node)
+        node.conditional_statement.grep_nodes(:node_type => [:call, :attrasgn]) { |child_node| remember_variable_use_count(child_node) }
+
+        variable_use_count.each do |variable_node, count|
+          add_error "move code into model (#{variable_node} use_count > #{@use_count})", variable_node.file, variable_node.line if count > @use_count
         end
-      end
 
-      def variable(call_node)
-        while call_node.subject.node_type == :call
-          call_node = call_node.subject
-        end
-        subject_node = call_node.subject
-        if [:ivar, :lvar].include?(subject_node.node_type) and subject_node[1] != :_erbout
-          subject_node
-        else
-          nil
-        end
+        reset_variable_use_count
       end
     end
   end

data/lib/rails_best_practices/checks/move_finder_to_named_scope_check.rb

@@ -3,32 +3,62 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a controller file to make sure finder is simple.
+    # Check a controller file to make sure there are no complex finder.
     #
-    # Complex finder in controller is a code smell, use namd_scope instead.
+    # See the best practice details here http://rails-bestpractices.com/posts/1-move-finder-to-named_scope.
     #
-    # Implementation: check method :find, :all, :first, :last with hash parameters.
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all method calls in controller files.
+    #   if there is any call node with message find, all, first or last,
+    #   and it has a hash argument,
+    #   then it is a complex finder, and should be moved to model's named scope.
     class MoveFinderToNamedScopeCheck < Check
-      
+
       FINDER = [:find, :all, :first, :last]
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:call]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         CONTROLLER_FILES
       end
 
-      def evaluate_start(node)
+      # check call node if its message is one of :find, :all, :first or :last,
+      # and it has a hash argument,
+      # then the call node is the finder that should be moved to model's named_scope.
+      def review_start_call(node)
         add_error "move finder to named_scope" if finder?(node)
       end
-      
+
       private
-      
-      def finder?(node)
-        node.subject.node_type == :const && FINDER.include?(node.message) && node.arguments.children.any? {|node| node.node_type == :hash}
-      end
+        # check if the call node is a finder.
+        #
+        # if the subject of call node is a constant,
+        # and the message of call node is one of find, all, first or last,
+        # and any of its arguments is a hash,
+        # then it is a finder. e.g.
+        #
+        #     s(:call, s(:const, :Post), :find,
+        #       s(:arglist, s(:lit, :all),
+        #         s(:hash,
+        #           s(:lit, :conditions),
+        #           s(:hash, s(:lit, :state), s(:str, "public")),
+        #           s(:lit, :limit),
+        #           s(:lit, 10),
+        #           s(:lit, :order),
+        #           s(:str, "created_at desc")
+        #         )
+        #       )
+        #     )
+        def finder?(call_node)
+          :const == call_node.subject.node_type && FINDER.include?(call_node.message) && call_node.arguments.children.any? { |node| :hash == node.node_type }
+        end
     end
   end
-end
+end

data/lib/rails_best_practices/checks/move_model_logic_into_model_check.rb

@@ -3,47 +3,51 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a controller file to make sure that model logic should not exist in controller, move it into a model.
+    # Check a controller file to make sure that complex model logic should not exist in controller, should be moved into a model.
     #
-    # Implementation: check the count of method calling of a model, 
-    # if it is more than defined called count, then it contains model logic.
+    # See the best practice details here http://rails-bestpractices.com/posts/7-move-model-logic-into-the-model.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all method defines in the controller files,
+    #   if there are multiple method calls or attribute assignments apply to one subject,
+    #   and the subject is a local variable or an instance variable,
+    #   then they are complex model logic, and they should be moved into model.
     class MoveModelLogicIntoModelCheck < Check
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:defn]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         CONTROLLER_FILES
       end
 
       def initialize(options = {})
         super()
-        @called_count = options['called_count'] || 4
+        @use_count = options['use_count'] || 4
       end
 
-      def evaluate_start(node)
-        @variables = {}
-        node.recursive_children do |child|
-          case child.node_type
-          when :attrasgn, :call
-            call_node(child)
-          end
+      # check method define node to see if there are multiple method calls and attribute assignments (more than @use_count defined) on one local variable or instance varialbe in review process.
+      #
+      # it will check every call and attrasgn nodes,
+      # if there are multiple call and attrasgn nodes who have the same subject,
+      # and the subject is a local variable or an instance variable,
+      # then these method calls and attribute assignments should be moved into model.
+      def review_start_defn(node)
+        node.grep_nodes(:node_type => [:call, :attrasgn]) do |child_node|
+          remember_variable_use_count(child_node)
         end
-        
-        @variables.each do |variable, count|
-          add_error "move model logic into model (#{variable} called_count > #{@called_count})" if count > @called_count
+
+        variable_use_count.each do |variable_node, count|
+          add_error "move model logic into model (#{variable_node} use_count > #{@use_count})" if count > @use_count
         end
-        @variables = nil
-      end
 
-      private
-      
-      def call_node(node)
-        variable = node.subject
-        return if variable.nil? or ![:lvar, :ivar].include? node.subject.node_type
-        @variables[variable] ||= 0
-        @variables[variable] += 1
+        reset_variable_use_count
       end
     end
   end

data/lib/rails_best_practices/checks/needless_deep_nesting_check.rb

@@ -3,17 +3,40 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check config/routes.rb to make sure not to use too deep nesting routes.
+    # Check config/routes.rb file to make sure not to use too deep nesting routes.
     #
-    # Implementation: check nested route count, if more than nested_count, then it is needless deep nesting.
+    # See the best practice details here http://rails-bestpractices.com/posts/11-needless-deep-nesting.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   chech all iter nodes in route file.
+    #
+    #   it is a recursively check in :iter node,
+    #
+    #   if it is a :iter node,
+    #   increment @counter at the beginning of resources,
+    #   decrement @counter at the end of resrouces,
+    #   recursively check nodes in iter's block body.
+    #
+    #   if it is a :block node,
+    #   then recursively check all child nodes in block node.
+    #
+    #   if it is a :call node,
+    #   and the message of the node is :resources or :resource,
+    #   and the @counter is greater than @nested_count defined,
+    #   then it is a needless deep nesting.
     class NeedlessDeepNestingCheck < Check
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:call, :iter]
       end
 
-      def interesting_files
-        /config\/routes.rb/
+      def interesting_review_files
+        ROUTE_FILE
       end
 
       def initialize(options = {})
@@ -21,46 +44,84 @@ module RailsBestPractices
         @counter = 0
         @nested_count = options['nested_count'] || 2
       end
-      
-      def evaluate_start(node)
-        check_nested_count(node)
+
+      # check all iter node in review process.
+      #
+      # It is a recursively check,
+      #
+      # if it is a :iter node, like
+      #
+      #     resources posts do
+      #       ...
+      #     end
+      # increment @counter at the beginning of resources,
+      # decrement @counter at the end of iter resources,
+      # recursively check the block body.
+      #
+      # if it is a :block node, like
+      #
+      #     resources :posts do
+      #       resources :comments
+      #       resources :votes
+      #     end
+      #
+      # just recursively check each child node in block node.
+      #
+      # if it is a :call node with message :resources or :resource, like
+      #
+      #     resources :comments
+      #
+      # test if the @counter is greater than or equal to @nested_count,
+      # if so, it is a needless deep nesting.
+      def review_start_iter(node)
+        recursively_check(node)
       end
 
       private
-        def check_nested_count(node)
-          if :iter == node.node_type
-            check_for_rails3(node)
-          elsif :resources == node.message and node.subject
-            check_for_rails2(node)
-          end
-        end
-
-        def check_for_rails3(node)
-          nested_count_for_rails3(node)
-        end
-
-        def check_for_rails2(node)
-          if node.subject == s(:call, nil, :map, s(:arglist))
-            @counter = 0
-          else
-            @counter += 1
-            add_error "needless deep nesting (nested_count > #{@nested_count})" if @counter >= @nested_count
-          end
-        end
-
-        def nested_count_for_rails3(node)
-          if :iter == node.node_type and :resources == node.subject.message and !node.message
+        # check nested route.
+        #
+        # if the node type is :iter,
+        # and the subject of the node is with message :resources or :resource, like
+        #
+        #     s(:iter,
+        #       s(:call, nil, :resources,
+        #         s(:arglist, s(:lit, :posts))
+        #       ),
+        #       nil,
+        #       s(:call, nil, :resources,
+        #         s(:arglist, s(:lit, :comments))
+        #       )
+        #     )
+        #
+        # then increment the @counter, recursively check the block body, and decrement the @counter.
+        #
+        # if the node type is :block, it is the block body of :iter node, like
+        #
+        #     s(:block,
+        #       s(:call, nil, :resources, s(:arglist, s(:lit, :comments))),
+        #       s(:call, nil, :resources, s(:arglist, s(:lit, :votes)))
+        #     )
+        #
+        # then check the each child node in the block.
+        #
+        # if the node type is :call,
+        # and the message of node is :resources or :resource, like
+        #
+        #     s(:call, nil, :resources, s(:arglist, s(:lit, :comments)))
+        #
+        # then check if @counter is greater than or equal to @nested_count,
+        # if so, it is the needless deep nesting.
+        def recursively_check(node)
+          if :iter == node.node_type && :resources == node.subject.message
             @counter += 1
-            nested_count_for_rails3(node[3])
+            recursively_check(node.body)
             @counter -= 1
           elsif :block == node.node_type
             node.children.each do |child_node|
-              if :resources == child_node.message and nil == child_node.subject and @counter + 1 > @nested_count
-                add_error "needless deep nesting (nested_count > #{@nested_count})", child_node.file, child_node.line
-              end
+              recursively_check(child_node)
             end
-          elsif :call == node.node_type and :resources == node.message
-            add_error "needless deep nesting (nested_count > #{@nested_count})", node.file, node.line if @counter + 1 > @nested_count
+          elsif :call == node.node_type && [:resources, :resource].include?(node.message)
+            add_error "needless deep nesting (nested_count > #{@nested_count})", node.file, node.line if @counter >= @nested_count
           end
         end
     end

data/lib/rails_best_practices/checks/not_use_default_route_check.rb

@@ -3,23 +3,54 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check config/routes to make sure not use default route that rails generated.
+    # Check config/routes file to make sure not use default route that rails generated.
     #
-    # Implementation: compare route sentence to see if it is equal to rails default route.
+    # See the best practice details here http://rails-bestpractices.com/posts/12-not-use-default-route-if-you-use-restful-design
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all method call to see if any method call is the same as rails default route.
+    #
+    #     map.connect ':controller/:action/:id'
+    #     map.connect ':controller/:action/:id.:format'
+    #
+    #   or
+    #
+    #     match ':controller(/:action(/:id(.:format)))'
     class NotUseDefaultRouteCheck < Check
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:call]
       end
-      
-      def interesting_files
-        /config\/routes.rb/
+
+      def interesting_review_files
+        ROUTE_FILE
       end
-      
-      def evaluate_start(node)
-        if node == s(:call, s(:lvar, :map), :connect, s(:arglist, s(:str, ":controller/:action/:id"))) or
-           node == s(:call, s(:lvar, :map), :connect, s(:arglist, s(:str, ":controller/:action/:id.:format"))) or
-           node == s(:call, nil, :match, s(:arglist, s(:str, ":controller(/:action(/:id(.:format)))")))
+
+      # check all method calls, it just compare with rails default route
+      #
+      # rails2
+      #
+      #     s(:call, s(:lvar, :map), :connect,
+      #       s(:arglist, s(:str, ":controller/:action/:id"))
+      #     )
+      #     s(:call, s(:lvar, :map), :connect,
+      #       s(:arglist, s(:str, ":controller/:action/:id.:format"))
+      #     )
+      #
+      # rails3
+      #
+      #     s(:call, nil, :match,
+      #       s(:arglist, s(:str, ":controller(/:action(/:id(.:format)))"))
+      #     )
+      def review_start_call(node)
+        if s(:call, s(:lvar, :map), :connect, s(:arglist, s(:str, ":controller/:action/:id"))) == node ||
+           s(:call, s(:lvar, :map), :connect, s(:arglist, s(:str, ":controller/:action/:id.:format"))) == node ||
+           s(:call, nil, :match, s(:arglist, s(:str, ":controller(/:action(/:id(.:format)))"))) == node
           add_error "not use default route"
         end
       end