rails_best_practices 1.19.3 → 1.21.0

data/lib/rails_best_practices/reviews/review.rb

@@ -13,7 +13,7 @@ module RailsBestPractices
       # 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 && 'self' != variable_node.to_s && @last_variable_node != variable_node
+        if variable_node && variable_node.to_s != 'self' && @last_variable_node != variable_node
           @last_variable_node = variable_node
           variable_use_count[variable_node.to_s] ||= 0
           variable_use_count[variable_node.to_s] += 1
@@ -36,6 +36,7 @@ module RailsBestPractices
           node = node.receiver
         end
         return if %i[fcall hash].include?(node.receiver.sexp_type)
+
         node.receiver
       end
 

data/lib/rails_best_practices/reviews/simplify_render_in_controllers_review.rb

@@ -21,10 +21,9 @@ module RailsBestPractices
       # if its message is render and the arguments contain a key action, template or file,
       # then it should be replaced by simplified syntax.
       add_callback :start_command do |node|
-        if 'render' == node.message.to_s
+        if node.message.to_s == 'render'
           keys = node.arguments.all.first.hash_keys
-          if keys && keys.size == 1 &&
-             (keys.include?('action') || keys.include?('template') || keys.include?('file'))
+          if keys && keys.size == 1 && (keys.include?('action') || keys.include?('template') || keys.include?('file'))
             add_error 'simplify render in controllers'
           end
         end

data/lib/rails_best_practices/reviews/simplify_render_in_views_review.rb

@@ -22,10 +22,10 @@ module RailsBestPractices
       # if its message is render and the arguments contain a key partial,
       # then it should be replaced by simplified syntax.
       add_callback :start_command do |node|
-        if 'render' == node.message.to_s
-          hash_node =  node.arguments.all.first
-          if hash_node && :bare_assoc_hash == hash_node.sexp_type &&
-              include_partial?(hash_node) && valid_hash?(hash_node)
+        if node.message.to_s == 'render'
+          hash_node = node.arguments.all.first
+          if hash_node && hash_node.sexp_type == :bare_assoc_hash && include_partial?(hash_node) &&
+               valid_hash?(hash_node)
             add_error 'simplify render in views'
           end
         end
@@ -33,15 +33,15 @@ module RailsBestPractices
 
       protected
 
-        def include_partial?(hash_node)
-          hash_node.hash_keys.include?('partial') && !hash_node.hash_value('partial').to_s.include?('/')
-        end
+      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
+      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

@@ -12,6 +12,7 @@ module RailsBestPractices
     # Review process:
     #   check all first code line_number in method definitions (actions),
     #   if they are duplicated, then they should be moved to before_filter.
+
     class UseBeforeFilterReview < Review
       interesting_nodes :class
       interesting_files CONTROLLER_FILES
@@ -34,10 +35,12 @@ module RailsBestPractices
           var_ref_or_vcall_included = %i[var_ref vcall].include?(statement_node.sexp_type)
           private_or_protected_included = %w[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
+
+          remember_first_sentence(statement_node) if statement_node.sexp_type == :def
         end
         @first_sentences.each do |_first_sentence, def_nodes|
           next unless 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_number).join(',')
@@ -46,16 +49,17 @@ module RailsBestPractices
 
       private
 
-        # check method define node, and remember the first sentence.
-        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] << node
-          end
+      # check method define node, and remember the first sentence.
+      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] << node
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_model_association_review.rb

@@ -43,24 +43,24 @@ module RailsBestPractices
 
       private
 
-        # check an attribute assignment node, if its message is xxx_id,
-        # then remember the receiver of the attribute assignment in @assignments.
-        def attribute_assignment(node)
-          if node.left_value.message.to_s =~ /_id$/
-            receiver = node.left_value.receiver.to_s
-            @assignments[receiver] = true
-          end
+      # check an attribute assignment node, if its message is xxx_id,
+      # then remember the receiver of the attribute assignment in @assignments.
+      def attribute_assignment(node)
+        if node.left_value.message.is_a?(Sexp) && node.left_value.message.to_s =~ /_id$/
+          receiver = node.left_value.receiver.to_s
+          @assignments[receiver] = true
         end
+      end
 
-        # check a call node with message "save" or "save!",
-        # if the receiver 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.to_s
-            receiver = node.receiver.to_s
-            add_error "use model association (for #{receiver})" if @assignments[receiver]
-          end
+      # check a call node with message "save" or "save!",
+      # if the receiver 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.to_s
+          receiver = node.receiver.to_s
+          add_error "use model association (for #{receiver})" if @assignments[receiver]
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_multipart_alternative_as_content_type_of_email_review.rb

@@ -11,6 +11,7 @@ module RailsBestPractices
     # Review process:
     #   check class node to remember the class name,
     #   and check the method definition nodes to see if the corresponding mailer views exist or not.
+
     class UseMultipartAlternativeAsContentTypeOfEmailReview < Review
       interesting_nodes :class, :def
       interesting_files MAILER_FILES
@@ -31,30 +32,31 @@ module RailsBestPractices
 
       private
 
-        # check if rails's syntax mailer views are canonical.
-        #
-        # @param [String] name method name in action_mailer
-        def rails_canonical_mailer_views?(name); end
-
-        # check if rails3's syntax mailer views are canonical.
-        #
-        # @param [String] name method name in action_mailer
-        def rails3_canonical_mailer_views?(name)
-          return true if mailer_files(name).empty?
-          return true if mailer_files(name).none? { |filename| filename.index 'html' }
-          mailer_files(name).any? { |filename| filename.index 'html' } &&
-            mailer_files(name).any? { |filename| filename.index 'text' }
-        end
+      # check if rails's syntax mailer views are canonical.
+      #
+      # @param [String] name method name in action_mailer
+      def rails_canonical_mailer_views?(name); end
 
-        # all mail view files for a method name.
-        def mailer_files(name)
-          Dir.entries(mailer_directory) { |filename| filename.index name.to_s }
-        end
+      # check if rails3's syntax mailer views are canonical.
+      #
+      # @param [String] name method name in action_mailer
+      def rails3_canonical_mailer_views?(name)
+        return true if mailer_files(name).empty?
+        return true if mailer_files(name).none? { |filename| filename.index 'html' }
 
-        # the view directory of mailer.
-        def mailer_directory
-          File.join(Core::Runner.base_path, "app/views/#{@klazz_name.to_s.underscore}")
-        end
+        mailer_files(name).any? { |filename| filename.index 'html' } &&
+          mailer_files(name).any? { |filename| filename.index 'text' }
+      end
+
+      # all mail view files for a method name.
+      def mailer_files(name)
+        Dir.entries(mailer_directory) { |filename| filename.index name.to_s }
+      end
+
+      # the view directory of mailer.
+      def mailer_directory
+        File.join(Core::Runner.base_path, "app/views/#{@klazz_name.to_s.underscore}")
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_observer_review.rb

@@ -49,42 +49,42 @@ module RailsBestPractices
 
       private
 
-        # check a command node, if it is a callback definition, such as after_create, before_create,
-        # then save the callback methods in @callbacks
-        def remember_callback(node)
-          if node.message.to_s =~ /^after_|^before_/
-            node.arguments.all.each do |argument|
-              # ignore callback like after_create Comment.new
-              @callbacks << argument.to_s if :symbol_literal == argument.sexp_type
-            end
+      # check a command node, if it is a callback definition, such as after_create, before_create,
+      # then save the callback methods in @callbacks
+      def remember_callback(node)
+        if node.message.to_s =~ /^after_|^before_/
+          node.arguments.all.each do |argument|
+            # ignore callback like after_create Comment.new
+            @callbacks << argument.to_s if argument.sexp_type == :symbol_literal
           end
         end
+      end
 
-        # check a defn node to see if the method name exists in the @callbacks.
-        def callback_method?(node)
-          @callbacks.find { |callback| callback == node.method_name.to_s }
-        end
+      # check a defn node to see if the method name exists in the @callbacks.
+      def callback_method?(node)
+        @callbacks.find { |callback| callback == node.method_name.to_s }
+      end
 
-        # check a def node to see if it contains a actionmailer deliver call.
-        #
-        # if the message of call node is deliver,
-        # and the receiver of the call node is with receiver node who exists in @callbacks,
-        # then the call node is actionmailer deliver call.
-        def deliver_mailer?(node)
-          node.grep_nodes(sexp_type: :call) do |child_node|
-            if 'deliver' == child_node.message.to_s
-              if :method_add_arg == child_node.receiver.sexp_type &&
-                mailers.include?(child_node.receiver[1].receiver.to_s)
-                return true
-              end
+      # check a def node to see if it contains a actionmailer deliver call.
+      #
+      # if the message of call node is deliver,
+      # and the receiver of the call node is with receiver node who exists in @callbacks,
+      # then the call node is actionmailer deliver call.
+      def deliver_mailer?(node)
+        node.grep_nodes(sexp_type: :call) do |child_node|
+          if child_node.message.to_s == 'deliver'
+            if child_node.receiver.sexp_type == :method_add_arg &&
+                 mailers.include?(child_node.receiver[1].receiver.to_s)
+              return true
             end
           end
-          false
         end
+        false
+      end
 
-        def mailers
-          @mailers ||= Prepares.mailers
-        end
+      def mailers
+        @mailers ||= Prepares.mailers
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_parentheses_in_method_def_review.rb

@@ -21,13 +21,13 @@ module RailsBestPractices
 
       protected
 
-        def no_parentheses_around_parameters?(def_node)
-          :parent != def_node[2][0]
-        end
+      def no_parentheses_around_parameters?(def_node)
+        def_node[2][0] != :parent
+      end
 
-        def has_parameters?(def_node)
-          :params == def_node[2][0] && !def_node[2][1..-1].compact.empty?
-        end
+      def has_parameters?(def_node)
+        def_node[2][0] == :params && !def_node[2][1..-1].compact.empty?
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_query_attribute_review.rb

@@ -34,13 +34,15 @@ module RailsBestPractices
       #
       # then the call node can use query attribute instead.
       add_callback :start_if, :start_unless, :start_elsif, :start_ifop, :start_if_mod, :start_unless_mod do |node|
-        all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
-          [node.conditional_statement]
-        else
-          node.conditional_statement.all_conditions
-        end
+        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|
           next unless query_attribute_node = query_attribute_node(condition_node)
+
           receiver_node = query_attribute_node.receiver
           add_error "use query attribute (#{receiver_node.receiver}.#{receiver_node.message}?)",
                     node.file,
@@ -50,67 +52,68 @@ module RailsBestPractices
 
       private
 
-        # 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.file = conditional_statement_code.file
-            return node
-          when :not
-            node = query_attribute_node(conditional_statement_node[1])
-            node.file = conditional_statement_node.file
-          when :call
-            return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
-          when :binary
-            return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
-          end
-          nil
+      # 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.file = conditional_statement_code.file
+          return node
+        when :not
+          node = query_attribute_node(conditional_statement_node[1])
+          node.file = conditional_statement_node.file
+        when :call
+          return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
+        when :binary
+          return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
         end
+        nil
+      end
 
-        # check if the node may use query attribute instead.
-        #
-        # if the node contains two method calls, e.g. @user.login.nil?
-        #
-        # for the first call, the receiver should be one of the class names and
-        # the message should be one of the attribute name.
-        #
-        # for the second call, the message should be one of nil?, blank? or present? or
-        # it is compared with an empty string.
-        #
-        # the node that may use query attribute.
-        def possible_query_attribute?(node)
-          return false unless :call == node.receiver.sexp_type
-          variable_node = variable(node)
-          message_node = node.grep_node(receiver: variable_node.to_s).message
+      # check if the node may use query attribute instead.
+      #
+      # if the node contains two method calls, e.g. @user.login.nil?
+      #
+      # for the first call, the receiver should be one of the class names and
+      # the message should be one of the attribute name.
+      #
+      # for the second call, the message should be one of nil?, blank? or present? or
+      # it is compared with an empty string.
+      #
+      # the node that may use query attribute.
+      def possible_query_attribute?(node)
+        return false unless node.receiver.sexp_type == :call
 
-          is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
-            (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
-        end
+        variable_node = variable(node)
+        message_node = node.grep_node(receiver: variable_node.to_s).message
 
-        # check if the receiver is one of the models.
-        def is_model?(variable_node)
-          return false if variable_node.const?
-          class_name = variable_node.to_s.sub(/^@/, '').classify
-          models.include?(class_name)
-        end
+        is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
+          (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
+      end
 
-        # check if the receiver and message is one of the model's attribute.
-        # the receiver should match one of the class model name, and the message should match one of attribute name.
-        def model_attribute?(variable_node, message)
-          class_name = variable_node.to_s.sub(/^@/, '').classify
-          attribute_type = model_attributes.get_attribute_type(class_name, message)
-          attribute_type && !%w[integer float].include?(attribute_type)
-        end
+      # check if the receiver is one of the models.
+      def is_model?(variable_node)
+        return false if variable_node.const?
 
-        # 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
-        end
+        class_name = variable_node.to_s.sub(/^@/, '').classify
+        models.include?(class_name)
+      end
+
+      # check if the receiver and message is one of the model's attribute.
+      # the receiver should match one of the class model name, and the message should match one of attribute name.
+      def model_attribute?(variable_node, message)
+        class_name = variable_node.to_s.sub(/^@/, '').classify
+        attribute_type = model_attributes.get_attribute_type(class_name, message)
+        attribute_type && !%w[integer float].include?(attribute_type)
+      end
+
+      # check if the node is with node type :binary, node message :== and node argument is empty string.
+      def compare_with_empty_string?(node)
+        node.sexp_type == :binary && ['==', '!='].include?(node.message.to_s) &&
+          s(:string_literal, s(:string_content)) == node.argument
+      end
     end
   end
 end