rails_best_practices 0.5.6 → 0.6.1

data/lib/rails_best_practices/checks/overuse_route_customizations_check.rb

@@ -3,52 +3,164 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check config/routes.rb to make sure there are no much route customizations.
+    # Check config/routes.rb file to make sure there are no overuse route customizations.
     #
-    # Implementation: check member and collection route count, if more than customize_count, then it is overuse route customizations.
+    # See the best practice details here http://rails-bestpractices.com/posts/10-overuse-route-customizations.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   the check methods are different for rails2 and rails3 syntax.
+    #
+    #   for rails2
+    #
+    #   check all call nodes in route file.
+    #   if the message of call node is resources,
+    #   and the second argument of call node is a hash,
+    #   and the count of the pair (key/value) in hash is greater than @customize_count,
+    #   then these custom routes are overuse.
+    #
+    #   for rails3
+    #
+    #   check all iter nodes in route file.
+    #   if the subject of iter node is with message resources,
+    #   and in the block body of iter node, there are more than @customize_count call nodes,
+    #   whose message is :get, :post, :update or :delete,
+    #   then these custom routes are overuse.
     class OveruseRouteCustomizationsCheck < Check
-      
-      def interesting_nodes
+
+      VERBS = [:get, :post, :update, :delete]
+
+      def interesting_review_nodes
         [:call, :iter]
       end
-      
-      def interesting_files
-        /config\/routes.rb/
+
+      def interesting_review_files
+        ROUTE_FILE
       end
 
       def initialize(options = {})
         super()
         @customize_count = options['customize_count'] || 3
       end
-      
-      def evaluate_start(node)
-        add_error "overuse route customizations (customize_count > #{@customize_count})", node.file, node.subject.line if member_and_collection_count(node) > @customize_count
+
+      # check call node to see if the count of member and collection custom routes is more than @customize_count defined in review process.
+      # this is for rails2 syntax.
+      #
+      # if the message of call node is :resources,
+      # and the second argument of call node is a hash,
+      # and the count of the pair (key/value) in hash is greater than @customize_count, like
+      #
+      #     map.resources :posts, :member => { :create_comment => :post,
+      #                                        :update_comment => :update,
+      #                                        :delete_comment => :delete },
+      #                           :collection => { :comments => :get }
+      #
+      # then they are overuse route customizations.
+      def review_start_call(node)
+        if member_and_collection_count_for_rails2(node) > @customize_count
+          add_error "overuse route customizations (customize_count > #{@customize_count})", node.file, node.subject.line
+        end
+      end
+
+      # check iter node to see if the count of member and collection custom routes is more than @customize_count defined in review process.
+      # this is for rails3 syntax.
+      #
+      # if the subject of iter node is with message :resources,
+      # and in the block body of iter node, there are more than @customize_count call nodes,
+      # whose message is :get, :post, :update or :delete, like
+      #
+      #     resources :posts do
+      #       member do
+      #         post :create_comment
+      #         update :update_comment
+      #         delete :delete_comment
+      #       end
+      #
+      #       collection do
+      #         get :comments
+      #       end
+      #     end
+      #
+      # then they are overuse route customizations.
+      def review_start_iter(node)
+        if member_and_collection_count_for_rails3(node) > @customize_count
+          add_error "overuse route customizations (customize_count > #{@customize_count})", node.file, node.subject.line
+        end
       end
 
       private
-        def member_and_collection_count(node)
+        # check call node to calculate the count of member and collection custom routes.
+        # this is for rails2 syntax.
+        #
+        # if the message of call node is :resources,
+        # and the second argument is a hash,
+        # then calculate the pair (key/value) count,
+        # it is just the count of member and collection custom routes.
+        #
+        #     s(:call, s(:lvar, :map), :resources,
+        #       s(:arglist,
+        #         s(:lit, :posts),
+        #         s(:hash,
+        #           s(:lit, :member),
+        #           s(:hash,
+        #             s(:lit, :create_comment),
+        #             s(:lit, :post),
+        #             s(:lit, :update_comment),
+        #             s(:lit, :update),
+        #             s(:lit, :delete_comment),
+        #             s(:lit, :delete)
+        #           ),
+        #           s(:lit, :collection),
+        #           s(:hash,
+        #             s(:lit, :comments),
+        #             s(:lit, :get)
+        #           )
+        #         )
+        #       )
+        #     )
+        def member_and_collection_count_for_rails2(node)
           if :resources == node.message
-            member_and_collection_count_for_rails2(node)
-          elsif :iter == node.node_type and :resources == node.subject.message
-            member_and_collection_count_for_rails3(node)
+            hash_node = node.arguments[2]
+            if hash_node
+              (hash_node.grep_nodes_count(:node_type => :lit) - hash_node.grep_nodes_count(:node_type => :hash)) / 2
+            end
           end
         end
 
-        # this is the checker for rails3 style routes
+        # check iter node to calculate the count of member and collection custom routes.
+        # this is for rails3 syntax.
+        #
+        # if its subject is with message :resources,
+        # then calculate the count of call nodes, whose message is :get, :post, :update or :delete,
+        # it is just the count of member and collection custom routes.
+        #
+        #     s(:iter,
+        #       s(:call, nil, :resources, s(:arglist, s(:lit, :posts))),
+        #       nil,
+        #       s(:block,
+        #         s(:iter,
+        #           s(:call, nil, :member, s(:arglist)),
+        #           nil,
+        #           s(:block,
+        #             s(:call, nil, :post, s(:arglist, s(:lit, :create_comment))),
+        #             s(:call, nil, :post, s(:arglist, s(:lit, :update_comment))),
+        #             s(:call, nil, :post, s(:arglist, s(:lit, :delete_comment)))
+        #           )
+        #         ),
+        #         s(:iter,
+        #           s(:call, nil, :collection, s(:arglist)),
+        #           nil,
+        #           s(:call, nil, :get, s(:arglist, s(:lit, :comments)))
+        #         )
+        #       )
+        #     )
         def member_and_collection_count_for_rails3(node)
-          get_nodes = node.grep_nodes(:node_type => :call, :message => :get)
-          post_nodes = node.grep_nodes(:node_type => :call, :message => :post)
-          get_nodes.size + post_nodes.size
-        end
-        
-        # this is the checker for rails2 style routes
-        def member_and_collection_count_for_rails2(node)
-          hash_nodes = node.grep_nodes(:node_type => :hash)
-          return 0 if hash_nodes.empty?
-          hash_key_node = hash_nodes.first[1]
-          if :lit == hash_key_node.node_type and [:member, :collection].include? hash_key_node[1]
-            customize_hash = eval(hash_nodes.first.to_s)
-            (customize_hash[:member].size || 0) + (customize_hash[:collection].size || 0)
+          if :resources == node.subject.message
+            node.grep_nodes_count(:node_type => :call, :message => VERBS)
           end
         end
     end

data/lib/rails_best_practices/checks/replace_complex_creation_with_factory_method_check.rb

@@ -3,54 +3,68 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a controller file to make sure that complex model creation should not exist in controller, move it to model factory method
+    # Check a controller file to make sure that complex model creation should not exist in controller, should be replaced with factory method.
     #
-    # Implementation: check the count of variable attribute assignment calling before saving, 
-    # if more than defined attribute assignment count, then it's a complex creation.
+    # See the best practice details here http://rails-bestpractices.com/posts/6-replace-complex-creation-with-factory-method.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all method defines in the controller files,
+    #   if there are multiple attribute assignments apply to one subject,
+    #   and the subject is a local variable or an instance variable,
+    #   and after them there is a call node with message :save or :save!,
+    #   then these attribute assignments are complex creation, should be replaced with factory method.
     class ReplaceComplexCreationWithFactoryMethodCheck < Check
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:defn]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         CONTROLLER_FILES
       end
-      
+
       def initialize(options = {})
         super()
         @attrasgn_count = options['attribute_assignment_count'] || 2
       end
-      
-      def evaluate_start(node)
-        @variables = {}
-        node.recursive_children do |child|
-          case child.node_type
+
+      # check method define node to see if there are multiple attribute assignments, more than @attrasgn_count, on one local variable or instance variable before save in review process.
+      #
+      # it wll check every attrasgn nodes in method define node,
+      # if there are multiple attrasgn nodes who have the same subject,
+      # and the subject is a local variable or an instance variable,
+      # and after them, there is a call node with message :save or :save!,
+      # then these attribute assignments are complex creation, should be replaced with factory method.
+      def review_start_defn(node)
+        node.recursive_children do |child_node|
+          case child_node.node_type
           when :attrasgn
-            attribute_assignment(child)
+            remember_variable_use_count(child_node)
           when :call
-            call_assignment(child)
+            check_variable_save(child_node)
           else
           end
         end
-        @variables = nil
+        reset_variable_use_count
       end
-      
+
       private
-      
-      def attribute_assignment(node)
-        variable = node.subject
-        return if variable.nil? or ![:lvar, :ivar].include? node.subject.node_type
-        @variables[variable] ||= 0
-        @variables[variable] += 1
-      end
-      
-      def call_assignment(node)
-        if node.message == :save
-          variable = node.subject
-          add_error "replace complex creation with factory method (#{variable} attribute_assignment_count > #{@attrasgn_count})" if @variables[variable] > @attrasgn_count
+        # check the call node to see if it is with message :save or :save!,
+        # and the count attribute assignment on the subject of the call node is greater than @attrasgn_count defined,
+        # then it is a complex creation, should be replaced with factory method.
+        def check_variable_save(node)
+          if [:save, :save!].include? node.message
+            variable = node.subject
+            if variable_use_count[variable] > @attrasgn_count
+              add_error "replace complex creation with factory method (#{variable} attribute_assignment_count > #{@attrasgn_count})"
+            end
+          end
         end
-      end
     end
   end
 end

data/lib/rails_best_practices/checks/replace_instance_variable_with_local_variable_check.rb

@@ -5,18 +5,29 @@ module RailsBestPractices
   module Checks
     # Check a partail view file to make sure there is no instance variable.
     #
-    # Implementation: Check all instance variable, if exists, then it should be replaced with local variable
+    # See the best practice details here http://rails-bestpractices.com/posts/27-replace-instance-variable-with-local-variable.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all instance variable in partial view files,
+    #   if exist, then they should be replaced with local variable
     class ReplaceInstanceVariableWithLocalVariableCheck < Check
-      
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:ivar]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         PARTIAL_VIEW_FILES
       end
-      
-      def evaluate_start(node)
+
+      # check ivar node in partial view file,
+      # it is an instance variable, and should be replaced with local variable.
+      def review_start_ivar(node)
         add_error "replace instance variable with local variable"
       end
     end

data/lib/rails_best_practices/checks/use_before_filter_check.rb

@@ -3,39 +3,109 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a controller file to make sure to use before_filter to remove duplicate call in different action.
+    # Check a controller file to make sure to use before_filter to remove duplicated first code line in different action.
     #
-    # Implementation: Check all methods' first call, if they are duplicate, then should use before_filter.
+    # See the best practice detailed here http://rails-bestpractices.com/posts/22-use-before_filter.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all first code line in method definitions (actions),
+    #   if they are duplicated, then they should be moved to before_filter.
     class UseBeforeFilterCheck < Check
 
-      def interesting_nodes
+      def interesting_review_nodes
         [:class]
       end
 
-      def interesting_files
+      def interesting_review_files
         CONTROLLER_FILES
       end
 
-      def evaluate_start(node)
-        @methods = {}
-        node.grep_nodes({:node_type => :defn}).each { |method_node| remember_method(method_node) }
-        @methods.each do |first_call, method_nodes|
-          if method_nodes.size > 1
-            add_error "use before_filter for #{method_nodes.collect{|method_node| method_node.message_name}.join(',')}", 
-              node.file, method_nodes.collect{|method_node| method_node.line}.join(',')
+      # check class define node to see if there are method define nodes whose first code line are duplicated in review process.
+      #
+      # it will every defn nodes in the class node,
+      # if there are defn nodes who have the same first code line, like
+      #
+      #     s(:class, :PostsController, s(:const, :ApplicationController),
+      #       s(:scope,
+      #         s(:block,
+      #           s(:defn, :show, s(:args),
+      #             s(:scope,
+      #               s(:block,
+      #                 s(:iasgn, :@post,
+      #                   s(:call,
+      #                     s(:call, s(:call, nil, :current_user, s(:arglist)), :posts, s(:arglist)),
+      #                     :find,
+      #                     s(:arglist,
+      #                       s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :id)))
+      #                     )
+      #                   )
+      #                 )
+      #               )
+      #             )
+      #           ),
+      #           s(:defn, :edit, s(:args),
+      #             s(:scope,
+      #               s(:block,
+      #                 s(:iasgn, :@post,
+      #                   s(:call,
+      #                     s(:call, s(:call, nil, :current_user, s(:arglist)), :posts, s(:arglist)),
+      #                     :find,
+      #                     s(:arglist,
+      #                       s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :id)))
+      #                     )
+      #                   )
+      #                 )
+      #               )
+      #             )
+      #           )
+      #         )
+      #       )
+      #     )
+      #
+      # then these duplicated first code lines should be moved to before_filter.
+      def review_start_class(class_node)
+        @first_sentences = {}
+        class_node.grep_nodes({:node_type => :defn}) { |defn_node| remember_first_sentence(defn_node) }
+        @first_sentences.each do |first_sentence, defn_nodes|
+          if defn_nodes.size > 1
+            add_error "use before_filter for #{defn_nodes.collect(&:method_name).join(',')}", class_node.file, defn_nodes.collect(&:line).join(',')
           end
         end
       end
 
       private
-
-      def remember_method(method_node)
-        first_call = method_node.body[1]
-        unless first_call == s(:nil)
-          @methods[first_call] ||= []
-          @methods[first_call] << method_node
+        # check method define node, and remember the first sentence.
+        # first sentence may be :iasgn, :lasgn, :attrasgn, :call node, like
+        #
+        #     s(:defn, :show, s(:args),
+        #       s(:scope,
+        #         s(:block,
+        #           s(:iasgn, :@post,
+        #             s(:call,
+        #               s(:call, s(:call, nil, :current_user, s(:arglist)), :posts, s(:arglist)),
+        #               :find,
+        #               s(:arglist,
+        #                 s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :id)))
+        #               )
+        #             )
+        #           )
+        #         )
+        #       )
+        #     )
+        #
+        # the first sentence of defn node is :iasgn node.
+        def remember_first_sentence(defn_node)
+          first_sentence = defn_node.body[1]
+          unless first_sentence == s(:nil)
+            @first_sentences[first_sentence] ||= []
+            @first_sentences[first_sentence] << defn_node
+          end
         end
-      end
     end
   end
 end