rails_best_practices 1.9.1 → 1.10.0

data/lib/rails_best_practices/reviews/keep_finders_on_their_own_model_review.rb

@@ -50,7 +50,7 @@ module RailsBestPractices
         def other_finder?(node)
           FINDERS.include?(node[1].message.to_s) &&
             :call == node[1].subject.sexp_type &&
-            node.arguments.grep_nodes_count(:sexp_type => :bare_assoc_hash) > 0
+            node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
         end
     end
   end

data/lib/rails_best_practices/reviews/move_code_into_model_review.rb

@@ -32,7 +32,7 @@ module RailsBestPractices
       # if there are multiple call and assignment nodes who have the same subject,
       # and the subject is a variable, then the conditional statement nodes should be moved into model.
       def start_if(node)
-        node.conditional_statement.grep_nodes(:sexp_type => :call) { |child_node| remember_variable_use_count(child_node) }
+        node.conditional_statement.grep_nodes(sexp_type: :call) { |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})" if count > @use_count

data/lib/rails_best_practices/reviews/move_finder_to_named_scope_review.rb

@@ -41,7 +41,7 @@ module RailsBestPractices
         def finder?(node)
           FINDERS.include?(node[1].message.to_s) &&
             :call == node[1].sexp_type &&
-            node.arguments.grep_nodes_count(:sexp_type => :bare_assoc_hash) > 0
+            node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
         end
     end
   end

data/lib/rails_best_practices/reviews/move_model_logic_into_model_review.rb

@@ -34,7 +34,7 @@ module RailsBestPractices
       # and the subject is a variable,
       # then these method calls and attribute assignments should be moved into model.
       def start_def(node)
-        node.grep_nodes(:sexp_type => [:call, :assign]) do |child_node|
+        node.grep_nodes(sexp_type: [:call, :assign]) do |child_node|
           remember_variable_use_count(child_node)
         end
 

data/lib/rails_best_practices/reviews/needless_deep_nesting_review.rb

@@ -66,7 +66,7 @@ module RailsBestPractices
         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)
+            hash_node = node[1].arguments.grep_node(sexp_type: :bare_assoc_hash)
             shallow = (hash_node && "true" == hash_node.hash_value("shallow").to_s) unless shallow
             @counter += 1
             node.block.statements.each do |stmt_node|

data/lib/rails_best_practices/reviews/overuse_route_customizations_review.rb

@@ -95,7 +95,7 @@ module RailsBestPractices
         # 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.
         def member_and_collection_count_for_rails3(node)
-          "resources" == node[1].message.to_s ? node.grep_nodes_count(:sexp_type => :command, :message => VERBS) : 0
+          "resources" == node[1].message.to_s ? node.grep_nodes_count(sexp_type: :command, message: VERBS) : 0
         end
     end
   end

data/lib/rails_best_practices/reviews/protect_mass_assignment_review.rb

@@ -25,7 +25,8 @@ module RailsBestPractices
       # and if not use devise or authlogic,
       # then it should add attr_accessible or attr_protected to protect mass assignment.
       def start_class(node)
-        if !whitelist_attributes_config? && !rails_builtin?(node) && !devise?(node) && !authlogic?(node)
+        if !whitelist_attributes_config? && !rails_builtin?(node) && !devise?(node) &&
+            !authlogic?(node) && is_active_record?(node)
           add_error "protect mass assignment"
         end
       end
@@ -36,17 +37,25 @@ module RailsBestPractices
         end
 
         def rails_builtin?(node)
-          node.grep_node(:sexp_type => [:vcall, :var_ref], :to_s => "attr_accessible").present? ||
-          node.grep_node(:sexp_type => :command, :message => %w(attr_accessible attr_protected)).present?
+          node.grep_node(sexp_type: [:vcall, :var_ref], to_s: "attr_accessible").present? ||
+          node.grep_node(sexp_type: :command, message: %w(attr_accessible attr_protected)).present?
         end
 
         def devise?(node)
-          node.grep_node(:sexp_type => :command, :message => "devise").present?
+          node.grep_node(sexp_type: :command, message: "devise").present?
         end
 
         def authlogic?(node)
-         node.grep_node(:sexp_type => [:vcall, :var_ref], :to_s => "acts_as_authentic").present? ||
-         node.grep_node(:sexp_type => :fcall, :message => "acts_as_authentic").present?
+         node.grep_node(sexp_type: [:vcall, :var_ref], to_s: "acts_as_authentic").present? ||
+         node.grep_node(sexp_type: :fcall, message: "acts_as_authentic").present?
+        end
+
+        def is_active_record?(node)
+          node.grep_node(sexp_type: [:const_path_ref, :@const], to_s: "ActiveRecord::Base").present?
+        end
+
+        def is_active_record?(node)
+          node.grep_node(:sexp_type => [:const_path_ref, :@const], :to_s => "ActiveRecord::Base").present?
         end
     end
   end

data/lib/rails_best_practices/reviews/remove_unused_methods_in_models_review.rb

@@ -63,7 +63,8 @@ module RailsBestPractices
         end
       end
 
-      # mark key method and value method for options_from_collection_for_select and option_groups_from_collection_for_select.
+      # mark key method and value method for options_from_collection_for_select and
+      # option_groups_from_collection_for_select.
       def start_method_add_arg(node)
         arguments = node.arguments.all
         case node.message.to_s
@@ -99,7 +100,8 @@ module RailsBestPractices
             human_attribute_name
             assign_attributes
             to_xml to_json to_param
-            before_save before_create before_update before_destroy after_save after_create after_update after_destroy after_find after_initialize
+            before_save before_create before_update before_destroy after_save after_create
+            after_update after_destroy after_find after_initialize
             method_missing
           ).map { |method_name| "*\##{method_name}" }
         end

data/lib/rails_best_practices/reviews/replace_complex_creation_with_factory_method_review.rb

@@ -3,9 +3,11 @@ require 'rails_best_practices/reviews/review'
 
 module RailsBestPractices
   module Reviews
-    # Review a controller file to make sure that complex model creation should not exist in controller, should be replaced with factory method.
+    # Review a controller file to make sure that complex model creation should not exist in
+    # controller, should be replaced with factory method.
     #
-    # See the best practice details here http://rails-bestpractices.com/posts/6-replace-complex-creation-with-factory-method.
+    # See the best practice details here
+    # http://rails-bestpractices.com/posts/6-replace-complex-creation-with-factory-method.
     #
     # Implementation:
     #
@@ -28,7 +30,8 @@ module RailsBestPractices
         @assigns_count = options['attribute_assignment_count'] || 2
       end
 
-      # check method define node to see if there are multiple assignments, more than @assigns_count, on one variable before save.
+      # check method define node to see if there are multiple assignments, more than
+      # @assigns_count, on one variable before save.
       #
       # it wll check every attrasgn nodes in method define node,
       # if there are multiple assign nodes who have the same subject,
@@ -58,7 +61,8 @@ module RailsBestPractices
           if ["save", "save!"].include? node.message.to_s
             variable = node.subject.to_s
             if variable_use_count[variable].to_i > @assigns_count
-              add_error "replace complex creation with factory method (#{variable} attribute_assignment_count > #{@assigns_count})"
+              hint = "#{variable} attribute_assignment_count > #{@assigns_count}"
+              add_error "replace complex creation with factory method (#{hint})"
             end
           end
         end

data/lib/rails_best_practices/reviews/replace_instance_variable_with_local_variable_review.rb

@@ -5,7 +5,8 @@ module RailsBestPractices
   module Reviews
     # Review a partail view file to make sure there is no instance variable.
     #
-    # See the best practice details here http://rails-bestpractices.com/posts/27-replace-instance-variable-with-local-variable.
+    # See the best practice details here
+    # http://rails-bestpractices.com/posts/27-replace-instance-variable-with-local-variable.
     #
     # Implementation:
     #

data/lib/rails_best_practices/reviews/restrict_auto_generated_routes_review.rb

@@ -28,31 +28,57 @@ module RailsBestPractices
       def initialize
         super
         @namespaces = []
+        @resource_controllers = []
       end
 
       # check if the generated routes have the corresponding actions in controller for rails3 routes.
       def start_command(node)
         if "resources" == node.message.to_s
           check_resources(node)
+          @resource_controllers << node.arguments.all.first.to_s
         elsif "resource" == node.message.to_s
           check_resource(node)
+          @resource_controllers << node.arguments.all.first.to_s
+        end
+      end
+
+      def end_command(node)
+        if "resources" == node.message.to_s
+          @resource_controllers.pop
+        elsif "resource" == node.message.to_s
+          @resource_controllers.pop
         end
       end
 
       # remember the namespace.
       def start_method_add_block(node)
-        if "namespace" == node.message.to_s
+        case node.message.to_s
+        when "namespace"
+          return unless check_method_add_block?(node)
           @namespaces << node.arguments.all.first.to_s
+        when "resources", "resource"
+          return unless check_method_add_block?(node)
+          @resource_controllers << node.arguments.all.first.to_s
+        else
         end
       end
 
       # end of namespace call.
       def end_method_add_block(node)
-        if "namespace" == node.message.to_s
+        return unless check_method_add_block?(node)
+
+        case node.message.to_s
+        when "namespace"
           @namespaces.pop
+        when "resources", "resource"
+          @resource_controllers.pop
         end
       end
 
+      def check_method_add_block?(node)
+        :command == node[1].sexp_type || (:command_call == node[1].sexp_type && "map" != node.subject.to_s)
+      end
+
       # check if the generated routes have the corresponding actions in controller for rails2 routes.
       alias_method :start_command_call, :start_command
 
@@ -63,8 +89,9 @@ 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(&:method_name)).map { |meth| ":#{meth}" }.join(", ")
-            add_error "restrict auto-generated routes (:only => [#{only_methods}])"
+            prepared_method_names = Prepares.controller_methods.get_methods(controller_name).map(&:method_name)
+            only_methods = (resources_methods & prepared_method_names).map { |meth| ":#{meth}" }.join(", ")
+            add_error "restrict auto-generated routes #{friendly_route_name(node)} (only: [#{only_methods}])"
           end
         end
 
@@ -74,8 +101,9 @@ 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(&:method_name)).map { |meth| ":#{meth}" }.join(", ")
-            add_error "restrict auto-generated routes (:only => [#{only_methods}])"
+            prepared_method_names = Prepares.controller_methods.get_methods(controller_name).map(&:method_name)
+            only_methods = (resource_methods & prepared_method_names).map { |meth| ":#{meth}" }.join(", ")
+            add_error "restrict auto-generated routes #{friendly_route_name(node)} (only: [#{only_methods}])"
           end
         end
 
@@ -113,7 +141,11 @@ module RailsBestPractices
             if hash_key_exist?(option_node, "only")
               option_node.hash_value("only").to_s == "none" ? [] : Array(option_node.hash_value("only").to_object)
             elsif hash_key_exist?(option_node, "except")
-              option_node.hash_value("except").to_s == "all" ? [] : (methods - Array(option_node.hash_value("except").to_object))
+              if option_node.hash_value("except").to_s == "all"
+                []
+              else 
+                (methods - Array(option_node.hash_value("except").to_object))
+              end
             else
               methods
             end
@@ -131,7 +163,11 @@ module RailsBestPractices
             if hash_key_exist?(option_node, "only")
               option_node.hash_value("only").to_s == "none" ? [] : Array(option_node.hash_value("only").to_object)
             elsif hash_key_exist?(option_node, "except")
-              option_node.hash_value("except").to_s == "all" ? [] : (methods - Array(option_node.hash_value("except").to_object))
+              if option_node.hash_value("except").to_s == "all"
+                []
+              else 
+                (methods - Array(option_node.hash_value("except").to_object))
+              end
             else
               methods
             end
@@ -147,6 +183,14 @@ module RailsBestPractices
         def hash_key_exist?(node, key)
           node.hash_keys && node.hash_keys.include?(key)
         end
+
+        def friendly_route_name(node)
+          if @resource_controllers.last == node.arguments.to_s
+            [@namespaces.join("/"), @resource_controllers.join("/")].delete_if(&:blank?).join("/")
+          else
+            [@namespaces.join("/"), @resource_controllers.join("/"), node.arguments.to_s].delete_if(&:blank?).join("/")
+          end
+        end
     end
   end
 end

data/lib/rails_best_practices/reviews/simplify_render_in_views_review.rb

@@ -16,6 +16,8 @@ module RailsBestPractices
       interesting_nodes :command
       interesting_files VIEW_FILES
 
+      VALID_KEYS = %w(object collection locals)
+
       def url
         "http://rails-bestpractices.com/posts/61-simplify-render-in-views"
       end
@@ -27,12 +29,22 @@ module RailsBestPractices
         if "render" == node.message.to_s
           hash_node =  node.arguments.all.first
           if hash_node && :bare_assoc_hash == hash_node.sexp_type &&
-            hash_node.hash_keys.include?("partial") &&
-            !hash_node.hash_value("partial").to_s.include?('/')
+              include_partial?(hash_node) && valid_hash?(hash_node)
             add_error 'simplify render in views'
           end
         end
       end
+
+      protected
+        def include_partial?(hash_node)
+          hash_node.hash_keys.include?("partial") && !hash_node.hash_value("partial").to_s.include?('/')
+        end
+
+        def valid_hash?(hash_node)
+          keys = hash_node.hash_keys
+          keys.delete("partial")
+          (keys - VALID_KEYS).empty?
+        end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_before_filter_review.rb

@@ -3,7 +3,8 @@ require 'rails_best_practices/reviews/review'
 
 module RailsBestPractices
   module Reviews
-    # Review a controller file to make sure to use before_filter to remove duplicated first code line in different action.
+    # Review a controller file to make sure to use before_filter to remove duplicated first code
+    # line in different action.
     #
     # See the best practice detailed here http://rails-bestpractices.com/posts/22-use-before_filter.
     #
@@ -34,12 +35,16 @@ module RailsBestPractices
         @first_sentences = {}
 
         node.body.statements.each do |statement_node|
-          break if [:var_ref, :vcall].include?(statement_node.sexp_type) && ["protected", "private"].include?(statement_node.to_s)
+          var_ref_or_vcall_included = [:var_ref, :vcall].include?(statement_node.sexp_type)
+          private_or_protected_included = ["protected", "private"].include?(statement_node.to_s)
+          break if var_ref_or_vcall_included && private_or_protected_included
           remember_first_sentence(statement_node) if :def == statement_node.sexp_type
         end
         @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(',')
+            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

data/lib/rails_best_practices/reviews/use_multipart_alternative_as_content_type_of_email_review.rb

@@ -6,7 +6,8 @@ module RailsBestPractices
   module Reviews
     # Make sure to use multipart/alternative as content_type of email.
     #
-    # See the best practice details here http://rails-bestpractices.com/posts/41-use-multipart-alternative-as-content_type-of-email.
+    # See the best practice details here
+    # http://rails-bestpractices.com/posts/41-use-multipart-alternative-as-content_type-of-email.
     #
     # Implementation:
     #

data/lib/rails_best_practices/reviews/use_observer_review.rb

@@ -82,7 +82,7 @@ module RailsBestPractices
         #
         # then the call node is actionmailer deliver call.
         def deliver_mailer?(node)
-          node.grep_nodes(:sexp_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

data/lib/rails_best_practices/reviews/use_parentheses_in_method_def_review.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'rails_best_practices/reviews/review'
+
+module RailsBestPractices
+  module Reviews
+    # Check if method definition has parentheses around parameters.
+    #
+    # Review process:
+    #   check def node in all files,
+    #   if params node with values, but not wrapped by paren node,
+    #   then it should use parentheses around parameters.
+    class UseParenthesesInMethodDefReview < Review
+      interesting_nodes :def
+      interesting_files ALL_FILES
+
+      # check def node to see if parameters are wrapped by parentheses.
+      def start_def(node)
+        if no_parentheses_around_parameters?(node) && has_parameters?(node)
+          add_error("use parentheses around parameters in method definitions")
+        end
+      end
+
+      protected
+        def no_parentheses_around_parameters?(def_node)
+          :parent != def_node[2][0]
+        end
+
+        def has_parameters?(def_node)
+          :params == def_node[2][0] && !def_node[2][1..-1].compact.empty?
+        end
+    end
+  end
+end

data/lib/rails_best_practices/reviews/use_query_attribute_review.rb

@@ -38,11 +38,17 @@ module RailsBestPractices
       #
       # then the call node can use query attribute instead.
       def start_if(node)
-        all_conditions = node.conditional_statement == node.conditional_statement.all_conditions ? [node.conditional_statement] : node.conditional_statement.all_conditions
+        all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
+          [node.conditional_statement]
+        else
+          node.conditional_statement.all_conditions
+        end
         all_conditions.each do |condition_node|
           if query_attribute_node = query_attribute_node(condition_node)
             subject_node = query_attribute_node.subject
-            add_error "use query attribute (#{subject_node.subject}.#{subject_node.message}?)", node.file, query_attribute_node.line
+            add_error "use query attribute (#{subject_node.subject}.#{subject_node.message}?)",
+              node.file,
+              query_attribute_node.line
           end
         end
       end
@@ -51,11 +57,13 @@ module RailsBestPractices
       alias_method :start_elsif, :start_if
 
       private
-        # recursively check conditional statement nodes to see if there is a call node that may be possible query attribute.
+        # recursively check conditional statement nodes to see if there is a call node that may be
+        # possible query attribute.
         def query_attribute_node(conditional_statement_node)
           case conditional_statement_node.sexp_type
           when :and, :or
-            node = query_attribute_node(conditional_statement_node[1]) || query_attribute_node(conditional_statement_node[2])
+            node = query_attribute_node(conditional_statement_node[1]) ||
+              query_attribute_node(conditional_statement_node[2])
             node.file = conditional_statement_code.file
             return node
           when :not
@@ -83,7 +91,7 @@ module RailsBestPractices
         def possible_query_attribute?(node)
           return false unless :call == node.subject.sexp_type
           variable_node = variable(node)
-          message_node = node.grep_node(:subject => variable_node.to_s).message
+          message_node = node.grep_node(subject: variable_node.to_s).message
 
           is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
             (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
@@ -106,7 +114,9 @@ module RailsBestPractices
 
         # check if the node is with node type :binary, node message :== and node argument is empty string.
         def compare_with_empty_string?(node)
-          :binary == node.sexp_type && ["==", "!="].include?(node.message.to_s) && s(:string_literal, s(:string_content)) == node.argument
+          :binary == node.sexp_type &&
+            ["==", "!="].include?(node.message.to_s) &&
+            s(:string_literal, s(:string_content)) == node.argument
         end
     end
   end