rails_best_practices 1.19.2 → 1.20.1

data/lib/rails_best_practices/reviews/remove_unused_methods_in_helpers_review.rb

@@ -20,27 +20,29 @@ module RailsBestPractices
       def initialize(options = {})
         super
         @helper_methods = Prepares.helper_methods
-        self.class.interesting_files Prepares.helpers.map(&:descendants)
+        self.class.interesting_files *Prepares.helpers.map(&:descendants)
       end
 
       # get all unused methods at the end of review process
       add_callback :after_check do
         @helper_methods.get_all_unused_methods.each do |method|
-          unless excepted?(method)
-            add_error "remove unused methods (#{method.class_name}##{method.method_name})", method.file, method.line_number
-          end
+          next if excepted?(method)
+
+          add_error "remove unused methods (#{method.class_name}##{method.method_name})",
+                    method.file,
+                    method.line_number
         end
       end
 
       protected
 
-        def methods
-          @helper_methods
-        end
+      def methods
+        @helper_methods
+      end
 
-        def internal_except_methods
-          ['*#url_for']
-        end
+      def internal_except_methods
+        ['*#url_for']
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/remove_unused_methods_in_models_review.rb

@@ -80,30 +80,50 @@ module RailsBestPractices
       # get all unused methods at the end of review process.
       add_callback :after_check do
         @model_methods.get_all_unused_methods.each do |method|
-          if !excepted?(method) && method.method_name !~ /=$/
-            add_error "remove unused methods (#{method.class_name}##{method.method_name})", method.file, method.line_number
-          end
+          next unless !excepted?(method) && method.method_name !~ /=$/
+
+          add_error "remove unused methods (#{method.class_name}##{method.method_name})",
+                    method.file,
+                    method.line_number
         end
       end
 
       protected
 
-        def methods
-          @model_methods
-        end
+      def methods
+        @model_methods
+      end
 
-        def internal_except_methods
-          %w[
-            initialize
-            validate validate_each validate_on_create validate_on_update
-            human_attribute_name assign_attributes attributes attribute
-            to_xml to_json as_json to_param
-            before_save before_create before_update before_destroy after_save after_create
-            after_update after_destroy after_find after_initialize
-            method_missing
-            table_name module_prefix
-          ].map { |method_name| "*\##{method_name}" }
-        end
+      def internal_except_methods
+        %w[
+          initialize
+          validate
+          validate_each
+          validate_on_create
+          validate_on_update
+          human_attribute_name
+          assign_attributes
+          attributes
+          attribute
+          to_xml
+          to_json
+          as_json
+          to_param
+          before_save
+          before_create
+          before_update
+          before_destroy
+          after_save
+          after_create
+          after_update
+          after_destroy
+          after_find
+          after_initialize
+          method_missing
+          table_name
+          module_prefix
+        ].map { |method_name| "*\##{method_name}" }
+      end
     end
   end
 end

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].to_s == '.'
               remember_variable_use_count(child_node)
             end
           when :call
@@ -49,18 +49,18 @@ module RailsBestPractices
 
       private
 
-        # 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
+      # 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
         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,106 @@ 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
+      # check resources call, if the routes generated by resources does not exist in the controller.
+      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
+      # check resource call, if the routes generated by resources does not exist in the controller.
+      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]
+      # get the controller name.
+      def controller_name(node)
+        if option_with_hash(node)
+          option_node = node.arguments.all[1]
+          name =
             if hash_key_exist?(option_node, 'controller')
-              name = option_node.hash_value('controller').to_s
+              option_node.hash_value('controller').to_s
             else
-              name = node.arguments.all.first.to_s.gsub('::', '').tableize
+              node.arguments.all.first.to_s.gsub('::', '').tableize
             end
-          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
+      # 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
+      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&.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,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,29 +35,31 @@ 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|
-          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_number).join(',')
-          end
+          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(',')
         end
       end
 
       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