rails_best_practices 0.10.1 → 1.0.0

data/lib/rails_best_practices/reviews/replace_instance_variable_with_local_variable_review.rb

@@ -18,7 +18,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:ivar]
+        [:var_ref]
       end
 
       def interesting_files
@@ -27,8 +27,10 @@ module RailsBestPractices
 
       # check ivar node in partial view file,
       # it is an instance variable, and should be replaced with local variable.
-      def start_ivar(node)
-        add_error "replace instance variable with local variable"
+      def start_var_ref(node)
+        if node.to_s.start_with?('@')
+          add_error "replace instance variable with local variable"
+        end
       end
     end
   end

data/lib/rails_best_practices/reviews/review.rb

@@ -10,15 +10,15 @@ module RailsBestPractices
       def url
         "#"
       end
-      # remember use count for the local or instance variable in the call or attrasgn node.
+      # remember use count for the variable in the call or assign node.
       #
-      # find the local variable or instance variable in the call or attrasgn node,
+      # find the variable in the call or assign node,
       # 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
-          variable_use_count[variable_node] ||= 0
-          variable_use_count[variable_node] += 1
+          variable_use_count[variable_node.to_s] ||= 0
+          variable_use_count[variable_node.to_s] += 1
         end
       end
 
@@ -32,32 +32,13 @@ module RailsBestPractices
         @variable_use_count = nil
       end
 
-      # find local variable or instance variable in the most inner call node, e.g.
-      #
-      # if the call node is
-      #
-      #     s(:call, s(:ivar, :@post), :editors, s(:arglist)),
-      #
-      # or it is
-      #
-      #     s(:call,
-      #       s(:call, s(:ivar, :@post), :editors, s(:arglist)),
-      #       :include?,
-      #       s(:arglist, s(:call, nil, :current_user, s(:arglist)))
-      #     )
-      #
-      # then the variable both are s(:ivar, :@post).
-      #
+      # find variable in the call or field node.
       def variable(node)
-        while node.subject.node_type == :call
+        while [:call, :field, :method_add_arg, :method_add_block].include?(node.subject.sexp_type)
           node = node.subject
         end
-        subject_node = node.subject
-        if [:ivar, :lvar].include?(subject_node.node_type) and subject_node[1] != :_erbout
-          subject_node
-        else
-          nil
-        end
+        return if [:fcall, :hash].include?(node.subject.sexp_type)
+        node.subject
       end
 
       # get the models from Prepares.
@@ -80,16 +61,6 @@ module RailsBestPractices
       def model_attributes
         @model_attributes ||= Prepares.model_attributes
       end
-
-      # compare two sexp nodes' to_s.
-      #
-      #     equal?(":test", :test) => true
-      #     equai?("@test", :test) => true
-      def equal?(node, expected_node)
-        actual = node.to_s.downcase
-        expected = expected_node.to_s.downcase
-        actual == expected || actual == ':' + expected || actual == '@' + expected
-      end
     end
   end
 end

data/lib/rails_best_practices/reviews/simplify_render_in_controllers_review.rb

@@ -10,7 +10,7 @@ module RailsBestPractices
     # Implementation:
     #
     # Review process:
-    #   check all render method calls in controller files,
+    #   check all render method commands in controller files,
     #   if there is a key 'action', 'template' or 'file' in the argument,
     #   then they should be replaced by simplified syntax.
     class SimplifyRenderInControllersReview < Review
@@ -19,19 +19,23 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:call]
+        [:command]
       end
 
       def interesting_files
         CONTROLLER_FILES
       end
 
-      # check call node in the controller file,
+      # check command node in the controller file,
       # if its message is render and the arguments contain a key action, template or file,
       # then it should be replaced by simplified syntax.
-      def start_call(call_node)
-        if :render == call_node.message && call_node.arguments[1].to_s =~ /"(action|template|file)" =>/
-          add_error 'simplify render in controllers'
+      def start_command(node)
+        if "render" == node.message.to_s
+          keys = node.arguments.all[0].hash_keys
+          if keys && keys.size == 1 &&
+             (keys.include?("action") || keys.include?("template") || keys.include?("file"))
+            add_error 'simplify render in controllers'
+          end
         end
       end
     end

data/lib/rails_best_practices/reviews/simplify_render_in_views_review.rb

@@ -10,7 +10,7 @@ module RailsBestPractices
     # Implementation:
     #
     # Review process:
-    #   check all render method calls in view files,
+    #   check all render method commands in view files,
     #   if there is a key 'partial' in the argument, then they should be replaced by simplified syntax.
     class SimplifyRenderInViewsReview < Review
       def url
@@ -18,19 +18,22 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:call]
+        [:command]
       end
 
       def interesting_files
         VIEW_FILES
       end
 
-      # check call node in view file,
+      # check command node in view file,
       # if its message is render and the arguments contain a key partial,
       # then it should be replaced by simplified syntax.
-      def start_call(call_node)
-        if :render == call_node.message && call_node.arguments[1].to_s =~ /"partial" =>/
-          add_error 'simplify render in views'
+      def start_command(node)
+        if "render" == node.message.to_s
+          hash_node =  node.arguments.all[0]
+          if hash_node && hash_node.hash_keys && hash_node.hash_keys.include?("partial")
+            add_error 'simplify render in views'
+          end
         end
       end
     end

data/lib/rails_best_practices/reviews/use_before_filter_review.rb

@@ -13,9 +13,6 @@ module RailsBestPractices
     #   check all first code line in method definitions (actions),
     #   if they are duplicated, then they should be moved to before_filter.
     class UseBeforeFilterReview < Review
-
-      PROTECTED_PRIVATE_CALLS = [[:call, nil, :protected, [:arglist]], [:call, nil, :private, [:arglist]]]
-
       def url
         "http://rails-bestpractices.com/posts/22-use-before_filter"
       end
@@ -35,87 +32,32 @@ module RailsBestPractices
 
       # check class define node to see if there are method define nodes whose first code line are duplicated.
       #
-      # it will check every defn nodes in the class node until protected or private identification,
-      # 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)))
-      #                     )
-      #                   )
-      #                 )
-      #               )
-      #             )
-      #           )
-      #         )
-      #       )
-      #     )
-      #
+      # it will check every def nodes in the class node until protected or private identification,
+      # if there are defn nodes who have the same first code line,
       # then these duplicated first code lines should be moved to before_filter.
-      def start_class(class_node)
+      def start_class(node)
         @first_sentences = {}
 
-        class_node.body.children.each do |child_node|
-          break if PROTECTED_PRIVATE_CALLS.include? child_node
-          remember_first_sentence(child_node) if :defn == child_node.node_type
+        node.body.statements.each do |statement_node|
+          break if :var_ref == statement_node.sexp_type && ["protected", "private"].include?(statement_node.to_s)
+          remember_first_sentence(statement_node) if :def == statement_node.sexp_type
         end
-        @first_sentences.each do |first_sentence, defn_nodes|
-          if defn_nodes.size > @customize_count
-            add_error "use before_filter for #{defn_nodes.collect(&:method_name).join(',')}", class_node.file, defn_nodes.collect(&:line).join(',')
+        @first_sentences.each do |first_sentence, def_nodes|
+          if def_nodes.size > @customize_count
+            add_error "use before_filter for #{def_nodes.map { |node| node.method_name.to_s }.join(',')}", node.file, def_nodes.map(&:line).join(',')
           end
         end
       end
 
       private
         # 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]
+        def remember_first_sentence(node)
+          first_sentence = node.body.statements.first
+          return unless first_sentence
+          first_sentence = first_sentence.remove_line_and_column
           unless first_sentence == s(:nil)
             @first_sentences[first_sentence] ||= []
-            @first_sentences[first_sentence] << defn_node
+            @first_sentences[first_sentence] << node
           end
         end
     end

data/lib/rails_best_practices/reviews/use_model_association_review.rb

@@ -12,7 +12,7 @@ module RailsBestPractices
     # Review process:
     #   check model define nodes in all controller files,
     #   if there is an attribute assignment node with message xxx_id=,
-    #   and after it, there is a call node with message :save or :save!,
+    #   and after it, there is a call node with message "save" or "save!",
     #   and the subjects of attribute assignment node and call node are the same,
     #   then model association should be used instead of xxx_id assignment.
     class UseModelAssociationReview < Review
@@ -21,7 +21,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:defn]
+        [:def]
       end
 
       def interesting_files
@@ -30,56 +30,44 @@ module RailsBestPractices
 
       # check method define nodes to see if there are some attribute assignments that can use model association instead.
       #
-      # it will check attribute assignment node with message xxx_id=, and call node with message :save or :save!
+      # it will check attribute assignment node with message xxx_id=, and call node with message "save" or "save!"
       #
       # 1. if there is an attribute assignment node with message xxx_id=,
       #    then remember the subject of attribute assignment node.
-      # 2. after assignment, if there is a call node with message :save or :save!,
+      # 2. after assignment, if there is a call node with message "save" or "save!",
       #    and the subject of call node is one of the subject of attribute assignment node,
       #    then the attribute assignment should be replaced by using model association.
-      def start_defn(node)
-        @attrasgns = {}
+      def start_def(node)
+        @assignments = {}
         node.recursive_children do |child|
-          case child.node_type
-          when :attrasgn
+          case child.sexp_type
+          when :assign
             attribute_assignment(child)
           when :call
             call_assignment(child)
           else
           end
         end
-        @attrasgns = nil
+        @assignments = nil
       end
 
       private
-        # check an attribute assignment node, if its message is xxx_id, like
-        #
-        #     s(:attrasgn, s(:ivar, :@post), :user_id=,
-        #       s(:arglist,
-        #         s(:call, s(:call, nil, :current_user, s(:arglist)), :id, s(:arglist))
-        #       )
-        #     )
-        #
-        # then remember the subject of the attribute assignment in @attrasgns.
-        #
-        #     @attrasgns => { s(:ivar, :@post) => true }
+        # check an attribute assignment node, if its message is xxx_id,
+        # then remember the subject of the attribute assignment in @assignments.
         def attribute_assignment(node)
-          if node.message.to_s =~ /_id=$/
-            subject = node.subject
-            @attrasgns[subject] = true
+          if node.left_value.message.to_s =~ /_id$/
+            subject = node.left_value.subject.to_s
+            @assignments[subject] = true
           end
         end
 
-        # check a call node with message :save or :save!,
-        # if the subject of call node exists in @attrasgns, like
-        #
-        #     s(:call, s(:ivar, :@post), :save, s(:arglist))
-        #
+        # check a call node with message "save" or "save!",
+        # if the subject of call node exists in @assignments,
         # then the attribute assignment should be replaced by using model association.
         def call_assignment(node)
-          if [:save, :save!].include? node.message
-            subject = node.subject
-            add_error "use model association (for #{subject})" if @attrasgns[subject]
+          if ["save", "save!"].include? node.message.to_s
+            subject = node.subject.to_s
+            add_error "use model association (for #{subject})" if @assignments[subject]
           end
         end
     end

data/lib/rails_best_practices/reviews/use_multipart_alternative_as_content_type_of_email_review.rb

@@ -19,7 +19,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:class, :defn]
+        [:class, :def]
       end
 
       def interesting_files
@@ -28,12 +28,12 @@ module RailsBestPractices
 
       # check class node to remember the ActionMailer class name.
       def start_class(node)
-        @klazz_name = node.class_name
+        @klazz_name = node.class_name.to_s
       end
 
-      # check defn node and find if the corresponding views exist or not?
-      def start_defn(node)
-        name = node.method_name
+      # check def node and find if the corresponding views exist or not?
+      def start_def(node)
+        name = node.method_name.to_s
         return unless deliver_method?(name)
         if rails2_canonical_mailer_views?(name) || rails3_canonical_mailer_views?(name)
           add_error("use multipart/alternative as content_type of email")

data/lib/rails_best_practices/reviews/use_observer_review.rb

@@ -12,7 +12,7 @@ module RailsBestPractices
     # Implementation:
     #
     # Review process:
-    #   check all call nodes to see if they are callback definitions, like after_create, before_destroy,
+    #   check all command nodes to see if they are callback definitions, like after_create, before_destroy,
     #   if so, remember the callback methods.
     #
     #   check all method define nodes to see
@@ -25,7 +25,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:defn, :call]
+        [:def, :command]
       end
 
       def interesting_files
@@ -37,15 +37,11 @@ module RailsBestPractices
         @callbacks = []
       end
 
-      # check a call node.
+      # check a command node.
       #
-      # if it is a callback definition, like
-      #
-      #     after_create :send_create_notification
-      #     before_destroy :send_destroy_notification
-      #
-      # then remember its callback methods (:send_create_notification).
-      def start_call(node)
+      # if it is a callback definition,
+      # then remember its callback methods.
+      def start_command(node)
         remember_callback(node)
       end
 
@@ -54,67 +50,53 @@ module RailsBestPractices
       # if it is callback method,
       # and there is a actionmailer deliver call in the method define node,
       # then it should be replaced by using observer.
-      def start_defn(node)
-        if callback_method?(node) and deliver_mailer?(node)
+      def start_def(node)
+        if callback_method?(node) && deliver_mailer?(node)
           add_error "use observer"
         end
       end
 
       private
-        # check a call node, if it is a callback definition, such as after_create, before_create, like
-        #
-        #     s(:call, nil, :after_create,
-        #       s(:arglist, s(:lit, :send_create_notification))
-        #     )
-        #
+        # check a command node, if it is a callback definition, such as after_create, before_create,
         # then save the callback methods in @callbacks
-        #
-        #     @callbacks => [:send_create_notification]
         def remember_callback(node)
           if node.message.to_s =~ /^after_|^before_/
-            node.arguments[1..-1].each do |argument|
+            node.arguments.all.each do |argument|
               # ignore callback like after_create Comment.new
-              @callbacks << argument.to_s if :lit == argument.node_type
+              @callbacks << argument.to_s if :symbol_literal == argument.sexp_type
             end
           end
         end
 
         # check a defn node to see if the method name exists in the @callbacks.
         def callback_method?(node)
-          @callbacks.find { |callback| equal?(callback, node.method_name) }
+          @callbacks.find { |callback| callback == node.method_name.to_s }
         end
 
-        # check a defn node to see if it contains a actionmailer deliver call.
+        # check a def node to see if it contains a actionmailer deliver call.
         #
         # for rails2
         #
         # if the message of call node is deliver_xxx,
-        # and the subject of the call node exists in @callbacks, like
-        #
-        #     s(:call, s(:const, :ProjectMailer), :deliver_notification,
-        #       s(:arglist, s(:self), s(:lvar, :member))
-        #     )
+        # and the subject of the call node exists in @callbacks,
         #
         # for rails3
         #
         # if the message of call node is deliver,
-        # and the subject of the call node is with subject node who exists in @callbacks, like
-        #
-        #     s(:call,
-        #       s(:call, s(:const, :ProjectMailer), :notification,
-        #         s(:arglist, s(:self), s(:lvar, :member))
-        #       ),
-        #       :deliver,
-        #       s(:arglist)
-        #     )
+        # and the subject of the call node is with subject node who exists in @callbacks,
         #
         # then the call node is actionmailer deliver call.
         def deliver_mailer?(node)
-          node.grep_nodes(:node_type => :call) do |child_node|
+          node.grep_nodes(:sexp_type => :call) do |child_node|
             # rails2 actionmailer deliver
             return true if child_node.message.to_s =~ /^deliver_/ && mailers.include?(child_node.subject.to_s)
             # rails3 actionmailer deliver
-            return true if :deliver == child_node.message && mailers.include?(child_node.subject.subject.to_s)
+            if "deliver" == child_node.message.to_s
+              if :method_add_arg == child_node.subject.sexp_type &&
+                mailers.include?(child_node.subject[1].subject.to_s)
+                return true
+              end
+            end
           end
           false
         end