rails_best_practices 1.19.3 → 1.19.4

data/lib/rails_best_practices/reviews/replace_complex_creation_with_factory_method_review.rb

@@ -37,7 +37,7 @@ module RailsBestPractices
         node.recursive_children do |child_node|
           case child_node.sexp_type
           when :assign
-            if :"." == child_node.receiver[2]
+            if child_node.receiver[2] == :"."
               remember_variable_use_count(child_node)
             end
           when :call
@@ -52,15 +52,15 @@ module RailsBestPractices
         # check the call node to see if it is with message "save" or "save!",
         # and the count attribute assignment on the receiver of the call node is greater than @assign_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.to_s
-            variable = node.receiver.to_s
-            if variable_use_count[variable].to_i > @assigns_count
-              hint = "#{variable} attribute_assignment_count > #{@assigns_count}"
-              add_error "replace complex creation with factory method (#{hint})"
-            end
+      def check_variable_save(node)
+        if ['save', 'save!'].include? node.message.to_s
+          variable = node.receiver.to_s
+          if variable_use_count[variable].to_i > @assigns_count
+            hint = "#{variable} attribute_assignment_count > #{@assigns_count}"
+            add_error "replace complex creation with factory method (#{hint})"
           end
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/restrict_auto_generated_routes_review.rb

@@ -38,23 +38,23 @@ module RailsBestPractices
 
       # check if the generated routes have the corresponding actions in controller for rails routes.
       add_callback :start_command, :start_command_call do |node|
-        if 'resources' == node.message.to_s
+        if node.message.to_s == 'resources'
           if (mod = module_option(node))
             @namespaces << mod
           end
           check_resources(node)
           @resource_controllers << node.arguments.all.first.to_s
-        elsif 'resource' == node.message.to_s
+        elsif node.message.to_s == 'resource'
           check_resource(node)
           @resource_controllers << node.arguments.all.first.to_s
         end
       end
 
       add_callback :end_command do |node|
-        if 'resources' == node.message.to_s
+        if node.message.to_s == 'resources'
           @resource_controllers.pop
           @namespaces.pop if module_option(node)
-        elsif 'resource' == node.message.to_s
+        elsif node.message.to_s == 'resource'
           @resource_controllers.pop
         end
       end
@@ -90,103 +90,104 @@ module RailsBestPractices
       end
 
       def check_method_add_block?(node)
-        :command == node[1].sexp_type || (:command_call == node[1].sexp_type && 'map' != node.receiver.to_s)
+        node[1].sexp_type == :command || (node[1].sexp_type == :command_call && node.receiver.to_s != 'map')
       end
 
       private
 
         # check resources call, if the routes generated by resources does not exist in the controller.
-        def check_resources(node)
-          _check(node, resources_methods)
-        end
+      def check_resources(node)
+        _check(node, resources_methods)
+      end
 
         # check resource call, if the routes generated by resources does not exist in the controller.
-        def check_resource(node)
-          _check(node, resource_methods)
-        end
+      def check_resource(node)
+        _check(node, resource_methods)
+      end
 
         # get the controller name.
-        def controller_name(node)
-          if option_with_hash(node)
-            option_node = node.arguments.all[1]
-            if hash_key_exist?(option_node, 'controller')
-              name = option_node.hash_value('controller').to_s
-            else
-              name = node.arguments.all.first.to_s.gsub('::', '').tableize
-            end
+      def controller_name(node)
+        if option_with_hash(node)
+          option_node = node.arguments.all[1]
+          if hash_key_exist?(option_node, 'controller')
+            name = option_node.hash_value('controller').to_s
           else
             name = node.arguments.all.first.to_s.gsub('::', '').tableize
           end
-          namespaced_class_name(name)
+        else
+          name = node.arguments.all.first.to_s.gsub('::', '').tableize
         end
+        namespaced_class_name(name)
+      end
 
         # get the class name with namespace.
-        def namespaced_class_name(name)
-          class_name = "#{name.split('/').map(&:camelize).join('::')}Controller"
-          if @namespaces.empty?
-            class_name
-          else
-            @namespaces.map { |namespace| "#{namespace.camelize}::" }.join('') + class_name
-          end
+      def namespaced_class_name(name)
+        class_name = "#{name.split('/').map(&:camelize).join('::')}Controller"
+        if @namespaces.empty?
+          class_name
+        else
+          @namespaces.map { |namespace| "#{namespace.camelize}::" }.join('') + class_name
         end
+      end
 
-        def _check(node, methods)
-          controller_name = controller_name(node)
-          return unless Prepares.controllers.include? controller_name
-          _methods = _methods(node, methods)
-          unless _methods.all? { |meth| Prepares.controller_methods.has_method?(controller_name, meth) }
-            prepared_method_names = Prepares.controller_methods.get_methods(controller_name).map(&:method_name)
-            only_methods = (_methods & prepared_method_names).map { |meth| ":#{meth}" }
-            routes_message = if only_methods.size > 3
-                               "except: [#{(methods.map { |meth| ':' + meth } - only_methods).join(', ')}]"
-                             else
-                               "only: [#{only_methods.join(', ')}]"
-                             end
-            add_error "restrict auto-generated routes #{friendly_route_name(node)} (#{routes_message})"
-          end
+      def _check(node, methods)
+        controller_name = controller_name(node)
+        return unless Prepares.controllers.include? controller_name
+
+        _methods = _methods(node, methods)
+        unless _methods.all? { |meth| Prepares.controller_methods.has_method?(controller_name, meth) }
+          prepared_method_names = Prepares.controller_methods.get_methods(controller_name).map(&:method_name)
+          only_methods = (_methods & prepared_method_names).map { |meth| ":#{meth}" }
+          routes_message = if only_methods.size > 3
+                             "except: [#{(methods.map { |meth| ':' + meth } - only_methods).join(', ')}]"
+                           else
+                             "only: [#{only_methods.join(', ')}]"
+                           end
+          add_error "restrict auto-generated routes #{friendly_route_name(node)} (#{routes_message})"
         end
+      end
 
-        def _methods(node, methods)
-          if option_with_hash(node)
-            option_node = node.arguments.all[1]
-            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')
-              if option_node.hash_value('except').to_s == 'all'
-                []
-              else
-                (methods - Array(option_node.hash_value('except').to_object))
-              end
+      def _methods(node, methods)
+        if option_with_hash(node)
+          option_node = node.arguments.all[1]
+          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')
+            if option_node.hash_value('except').to_s == 'all'
+              []
             else
-              methods
+              (methods - Array(option_node.hash_value('except').to_object))
             end
           else
             methods
           end
+        else
+          methods
         end
+      end
 
-        def module_option(node)
-          option_node = node.arguments[1].last
-          if option_node && option_node.sexp_type == :bare_assoc_hash && hash_key_exist?(option_node, 'module')
-            option_node.hash_value('module').to_s
-          end
+      def module_option(node)
+        option_node = node.arguments[1].last
+        if option_node && option_node.sexp_type == :bare_assoc_hash && hash_key_exist?(option_node, 'module')
+          option_node.hash_value('module').to_s
         end
+      end
 
-        def option_with_hash(node)
-          node.arguments.all.size > 1 && :bare_assoc_hash == node.arguments.all[1].sexp_type
-        end
+      def option_with_hash(node)
+        node.arguments.all.size > 1 && node.arguments.all[1].sexp_type == :bare_assoc_hash
+      end
 
-        def hash_key_exist?(node, key)
-          node.hash_keys && node.hash_keys.include?(key)
-        end
+      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
+      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/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,7 +21,7 @@ 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'))

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
+        if node.message.to_s == 'render'
           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 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

@@ -34,10 +34,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(',')
@@ -47,15 +49,16 @@ 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
+      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

@@ -45,22 +45,22 @@ module RailsBestPractices
 
         # 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
+      def attribute_assignment(node)
+        if 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
+      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

@@ -34,27 +34,28 @@ module RailsBestPractices
         # check if rails's syntax mailer views are canonical.
         #
         # @param [String] name method name in action_mailer
-        def rails_canonical_mailer_views?(name); end
+      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
+      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
 
         # all mail view files for a method name.
-        def mailer_files(name)
-          Dir.entries(mailer_directory) { |filename| filename.index name.to_s }
-        end
+      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
+      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

@@ -51,40 +51,40 @@ module RailsBestPractices
 
         # 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
+      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
+      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
+      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