rails_best_practices 0.5.6 → 0.6.1

data/lib/rails_best_practices/checks/dry_bundler_in_capistrano_check.rb

@@ -5,19 +5,40 @@ module RailsBestPractices
   module Checks
     # Check config/deploy.rb file to make sure using the bundler's capistrano recipe.
     #
-    # Implementation: check the method call,
-    # if there is a method call "namespace" with argument ":bundler", then it should use bundler's capistrano recipe.
+    # See the best practice details here http://rails-bestpractices.com/posts/51-dry-bundler-in-capistrano
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   only check the call nodes to see if there is bundler namespace in config/deploy.rb file,
+    #
+    #   if the message of call node is :namespace and the arguments of the call node is :bundler,
+    #   then it should use bundler's capistrano recipe.
     class DryBundlerInCapistranoCheck < Check
 
-      def interesting_nodes
+      def interesting_review_nodes
         [:call]
       end
 
-      def interesting_files
+      def interesting_review_files
         /config\/deploy.rb/
       end
 
-      def evaluate_start(node)
+      # check call node in review process to see if it is with message :namespace and arguments :bundler.
+      #
+      # the ruby code is
+      #
+      #     namespace :bundler do
+      #       ...
+      #     end
+      #
+      # then the call node is as follows
+      #
+      #     s(:call, nil, :namespace, s(:arglist, s(:lit, :bundler)))
+      def review_start_call(node)
         if :namespace == node.message and equal?(node.arguments[1], "bundler")
           add_error "dry bundler in capistrano"
         end

data/lib/rails_best_practices/checks/isolate_seed_data_check.rb

@@ -3,16 +3,33 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a migration file to make sure not to insert data in migration, move them to seed file.
+    # Make sure not to insert data in migration, move them to seed file.
     #
-    # Implementation: check if there are :create, :create!, and :new with :save or :save! exist, the migration file needs isolate seed data.
+    # See the best practice details here http://rails-bestpractices.com/posts/20-isolating-seed-data.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   1. check all local assignment and instance assignment nodes,
+    #   if the right value is a call node with message :new,
+    #   then remember their left value as new variables.
+    #
+    #   2. check all call nodes,
+    #   if the message is :create or :create!,
+    #   then it should be isolated to db seed.
+    #   if the message is :save or :save!,
+    #   and the subject is included in new variables,
+    #   then it should be isolated to db seed.
     class IsolateSeedDataCheck < Check
 
-      def interesting_nodes
+      def interesting_review_nodes
         [:call, :lasgn, :iasgn]
       end
 
-      def interesting_files
+      def interesting_review_files
         MIGRATION_FILES
       end
 
@@ -21,27 +38,61 @@ module RailsBestPractices
         @new_variables = []
       end
 
-      def evaluate_start(node)
+      # check local assignment node in review process.
+      #
+      # if the right value of the node is a call node with :new message,
+      # then remember it as new variables (@new_variables).
+      def review_start_lasgn(node)
+        remember_new_variable(node)
+      end
+
+      # check instance assignment node in review process.
+      #
+      # if the right value of the node is a call node with :new message,
+      # then remember it as new variables (@new_variables).
+      def review_start_iasgn(node)
+        remember_new_variable(node)
+      end
+
+      # check the call node in review process.
+      #
+      # if the message of the call node is :create or :create!,
+      # then you should isolate it to seed data.
+      #
+      # if the message of the call node is :save or :save!,
+      # and the subject of the call node is included in @new_variables,
+      # then you should isolate it to seed data.
+      def review_start_call(node)
         if [:create, :create!].include? node.message
           add_error("isolate seed data")
-        elsif [:lasgn, :iasgn].include? node.node_type
-          remember_new_variable(node)
         elsif [:save, :save!].include? node.message
           add_error("isolate seed data") if new_record?(node)
         end
       end
 
       private
-
-      def remember_new_variable(node)
-        unless node.grep_nodes({:node_type => :call, :message => :new}).empty?
-          @new_variables << node.left_value.to_s
+        # check local assignment or instance assignment node,
+        # if the right vavlue is a call node with message :new,
+        # then remember the left value as new variable.
+        #
+        # if the local variable node is
+        #
+        #     s(:lasgn, :role, s(:call, s(:const, :Role), :new, s(:arglist, s(:hash, s(:lit, :name), s(:lvar, :name)))))
+        #
+        # then the new variables (@new_variables) is
+        #
+        #     ["role"]
+        def remember_new_variable(node)
+          right_value = node.right_value
+          if :call == right_value.node_type && :new == right_value.message
+            @new_variables << node.left_value.to_s
+          end
         end
-      end
 
-      def new_record?(node)
-        @new_variables.include? node.subject.to_s
-      end
+        # see if the subject of the call node is included in the @new_varaibles.
+        def new_record?(node)
+          @new_variables.include? node.subject.to_s
+        end
     end
   end
 end

data/lib/rails_best_practices/checks/keep_finders_on_their_own_model_check.rb

@@ -3,28 +3,69 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a model to make sure finders are on their own model.
+    # Check model files to ake sure finders are on their own model.
     #
-    # Implementation: check if :find is called by other model.
+    # See the best practice details here http://rails-bestpractices.com/posts/13-keep-finders-on-their-own-model.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all call nodes in model files.
+    #
+    #   if the call node is a finder (find, all, first or last),
+    #   and the it calls the other model,
+    #   and there is a hash argument for finder,
+    #   then it should keep finders on its own model.
     class KeepFindersOnTheirOwnModelCheck < Check
-      
-      def interesting_nodes
+
+      FINDERS = [:find, :all, :first, :last]
+
+      def interesting_review_nodes
         [:call]
       end
 
-      def interesting_files
-        MODLE_FILES
+      def interesting_review_files
+        MODEL_FILES
       end
 
-      def evaluate_start(node)
-        add_error "keep finders on their own model" if others_finder?(node)
+      # check all the call nodes to see if there is a finder for other model.
+      #
+      # if the call node is
+      #
+      # 1. the message of call node is one of the :find, :all, :first or :last
+      # 2. the subject of call node is also a call node (it's the other model)
+      # 3. the any of its arguments is a hash (complex finder)
+      #
+      # then it should keep finders on its own model.
+      def review_start_call(node)
+        add_error "keep finders on their own model" if other_finder?(node)
       end
 
       private
-
-      def others_finder?(node)
-        [:find, :all, :first, :last].include? node.message and node.subject.node_type == :call and node.arguments.size > 1
-      end
+        # check if the call node is the finder of other model.
+        #
+        # the message of the node should be one of :find, :all, :first or :last,
+        # and the subject of the node should be with message :call (this is the other model),
+        # and any of its arguments is a hash, like
+        #
+        #     s(:call,
+        #       s(:call, s(:self), :comment, s(:arglist)),
+        #       :find,
+        #       s(:arglist, s(:lit, :all),
+        #         s(:hash,
+        #           s(:lit, :conditions),
+        #           s(:hash, s(:lit, :is_spam), s(:false)),
+        #           s(:lit, :limit),
+        #           s(:lit, 10)
+        #         )
+        #       )
+        #     )
+        def other_finder?(node)
+          FINDERS.include?(node.message) && :call == node.subject.node_type && node.arguments.children.any? { |node| :hash == node.node_type }
+        end
     end
   end
 end

data/lib/rails_best_practices/checks/law_of_demeter_check.rb

@@ -3,47 +3,76 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check to make sure not avoid the law of demeter.
-    # 
-    # Implementation: 
-    # 1. check all models to record belongs_to and has_one associations
-    # 2. check if calling belongs_to and has_one association's method or attribute
+    # Check to make sure not to avoid the law of demeter.
+    #
+    # See the best practice details here http://rails-bestpractices.com/posts/15-the-law-of-demeter.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   only check all model files to save model names and association names.
+    #
+    # Review process:
+    #   check all method calls to see if there is method call to the association object.
+    #   if there is a call node whose subject is an object of model (compare by name),
+    #   and whose message is an association of that model (also compare by name),
+    #   and outer the call node, it is also a call node,
+    #   then it violate the law of demeter.
     class LawOfDemeterCheck < Check
-      
-      def interesting_nodes
-        [:call, :class]
-      end
 
-      def initialize
-        super
-        @associations = {}
+      prepare_model_associations
+
+      def interesting_review_nodes
+        [:call]
       end
 
-      def evaluate_start(node)
-        if node.node_type == :class
-          remember_association(node)
-        elsif [:lvar, :ivar].include?(node.subject.subject.node_type) and node.subject != s(:lvar, :_erbout)
-          add_error "law of demeter" if need_delegate?(node)
+      # check the call node in review process,
+      #
+      # if the subject of the call node is also a call node,
+      # and the subject of the subject call node matchs one of the class names,
+      # and the message of the subject call node matchs one of the association name with the class name, like
+      #
+      #     s(:call,
+      #       s(:call, s(:ivar, :@invoice), :user, s(:arglist)),
+      #       :name,
+      #       s(:arglist)
+      #     )
+      #
+      # then it violates the law of demeter.
+      def review_start_call(node)
+        if [:lvar, :ivar].include?(node.subject.subject.node_type) && need_delegate?(node)
+          add_error "law of demeter"
         end
       end
 
       private
-
-      # remember belongs_to or has_one node
-      def remember_association(node)
-        (node.body.grep_nodes(:message => :belongs_to) + node.body.grep_nodes(:message => :has_one)).collect do |body_node|
-          class_name = node.subject.to_s.underscore
-          @associations[class_name] ||= []
-          @associations[class_name] << body_node.arguments[1].to_s
+        # check if the call node can use delegate to avoid violating law of demeter.
+        #
+        # if the subject of subject of the call node matchs any in model names,
+        # and the message of subject of the call node matchs any in association names,
+        # then it needs delegate.
+        #
+        # e.g. the source code is
+        #
+        #     @invoic.user.name
+        #
+        # then the call node is
+        #
+        #     s(:call, s(:call, s(:ivar, :@invoice), :user, s(:arglist)), :name, s(:arglist))
+        #
+        # as you see the subject of subject of the call node is [:ivar, @invoice],
+        # and the message of subject of the call node is :user
+        def need_delegate?(node)
+          @associations.each do |class_name, associations|
+            return true if equal?(node.subject.subject, class_name) && associations.find { |association| equal?(association, node.subject.message) }
+          end
+          false
         end
-      end
 
-      def need_delegate?(node)
-        @associations.each do |class_name, associations|
-          return true if node.subject.subject.to_s =~ /#{class_name}$/ and associations.find { |association| equal?(association, node.subject.message) }
+        # only check belongs_to and has_one association.
+        def association_methods
+          [:belongs_to, :has_one]
         end
-        false
-      end
     end
   end
 end

data/lib/rails_best_practices/checks/move_code_into_controller_check.rb

@@ -3,30 +3,50 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a view file to make sure there is no finder.
+    # Check a view file to make sure there is no finder, finder should be moved to controller.
     #
-    # Implementation: Check if view file contains finder, then the code should move to controller.
+    # See the best practice details here http://rails-bestpractices.com/posts/24-move-code-into-controller.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   only check all view files to see if there are finders, then the finders should be moved to controller.
     class MoveCodeIntoControllerCheck < Check
-      
-      FINDER = [:find, :all, :first, :last]
-      
-      def interesting_nodes
+
+      FINDERS = [:find, :all, :first, :last]
+
+      def interesting_review_nodes
         [:call]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         VIEW_FILES
       end
-      
-      def evaluate_start(node)
+
+      # check call nodes in review process.
+      #
+      # if the subject of the call node is a constant,
+      # and the message of the call node is one of the :find, :all, :first and :last,
+      # then it is a finder and should be moved to controller.
+      def review_start_call(node)
         add_error "move code into controller" if finder?(node)
       end
-      
-      private
 
-      def finder?(node)
-        node.subject.node_type == :const && FINDER.include?(node.message)
-      end
+      private
+        # check if the node is a finder call node.
+        # e.g. the following call node is a finder
+        #
+        #     s(:call,
+        #       s(:const, :Post),
+        #       :find,
+        #       s(:arglist, s(:lit, :all))
+        #     )
+        def finder?(node)
+          :const == node.subject.node_type && FINDERS.include?(node.message)
+        end
     end
   end
 end

data/lib/rails_best_practices/checks/move_code_into_helper_check.rb

@@ -5,14 +5,29 @@ module RailsBestPractices
   module Checks
     # Check a view file to make sure there is no complex options_for_select message call.
     #
-    # Implementation: Check if first argument of options_for_select is an array and contains more than two nodes, then it should be moved into helper.
+    # See the best practice details here http://rails-bestpractices.com/posts/26-move-code-into-helper.
+    #
+    # TODO: we need a better soluation, any suggestion?
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check al method calls to see if there is a complex options_for_select helper.
+    #
+    #   if the message of the call node is options_for_select,
+    #   and the first argument of the call node is array,
+    #   and the size of the array is greater than array_count defined,
+    #   then the options_for_select method should be moved into helper.
     class MoveCodeIntoHelperCheck < Check
-    
-      def interesting_nodes
+
+      def interesting_review_nodes
         [:call]
       end
-    
-      def interesting_files
+
+      def interesting_review_files
         VIEW_FILES
       end
 
@@ -21,15 +36,44 @@ module RailsBestPractices
         @array_count = options['array_count'] || 3
       end
 
-      def evaluate_start(node)
+      # check call node with message options_for_select (sorry we only check options_for_select helper now).
+      #
+      # if the first argument of options_for_select method call is an array,
+      # and the size of the array is more than @array_count defined,
+      # then the options_for_select helper should be moved into helper.
+      def review_start_call(node)
         add_error "move code into helper (array_count >= #{@array_count})" if complex_select_options?(node)
       end
-      
+
       private
-      
-      def complex_select_options?(node)
-        :options_for_select == node.message and :array == node.arguments[1].node_type and node.arguments[1].size > @array_count
-      end
+        # check if the arguments of options_for_select are complex.
+      #
+      # if the first argument is an array,
+      # and the size of array is greater than @array_count you defined,
+      # then it is complext, e.g.
+      #
+      #     s(:call, nil, :options_for_select,
+      #       s(:arglist,
+      #         s(:array,
+      #           s(:array,
+      #             s(:call, nil, :t, s(:arglist, s(:lit, :draft))),
+      #             s(:str, "draft")
+      #           ),
+      #           s(:array,
+      #             s(:call, nil, :t, s(:arglist, s(:lit, :published))),
+      #             s(:str, "published")
+      #           )
+      #         ),
+      #         s(:call,
+      #           s(:call, nil, :params, s(:arglist)),
+      #           :[],
+      #           s(:arglist, s(:lit, :default_state))
+      #         )
+      #       )
+      #     )
+        def complex_select_options?(node)
+          :options_for_select == node.message and :array == node.arguments[1].node_type and node.arguments[1].size > @array_count
+        end
     end
   end
-end
+end