rails_best_practices 1.19.3 → 1.21.0

data/lib/rails_best_practices/reviews/remove_empty_helpers_review.rb

@@ -17,16 +17,16 @@ module RailsBestPractices
 
       # check the body of module node, if it is nil, then it should be removed.
       add_callback :start_module do |module_node|
-        if 'ApplicationHelper' != module_node.module_name.to_s && empty_body?(module_node)
+        if module_node.module_name.to_s != 'ApplicationHelper' && empty_body?(module_node)
           add_error 'remove empty helpers'
         end
       end
 
       protected
 
-        def empty_body?(module_node)
-          s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil) == module_node.body
-        end
+      def empty_body?(module_node)
+        s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil) == module_node.body
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/remove_unused_methods_in_controllers_review.rb

@@ -11,6 +11,7 @@ module RailsBestPractices
     #   if they are not defined in routes,
     #   and they are not called in controllers,
     #   then they are the unused methods in controllers.
+
     class RemoveUnusedMethodsInControllersReview < Review
       include Classable
       include Moduleable
@@ -71,7 +72,7 @@ module RailsBestPractices
           node.arguments.all.each { |argument| mark_publicize(argument.to_s) }
         when 'delegate'
           last_argument = node.arguments.all.last
-          if :bare_assoc_hash == last_argument.sexp_type && 'controller' == last_argument.hash_value('to').to_s
+          if last_argument.sexp_type == :bare_assoc_hash && last_argument.hash_value('to').to_s == 'controller'
             controller_name = current_module_name.sub('Helper', 'Controller')
             node.arguments.all[0..-2].each { |method| mark_publicize(method.to_s, controller_name) }
           end
@@ -82,7 +83,7 @@ module RailsBestPractices
 
       # mark assignment as used, like current_user = @user
       add_callback :start_assign do |node|
-        if :var_field == node.left_value.sexp_type
+        if node.left_value.sexp_type == :var_field
           call_method "#{node.left_value}=", current_class_name
         end
       end
@@ -90,7 +91,7 @@ module RailsBestPractices
       # get all unused methods at the end of review process.
       add_callback :after_check do
         @routes.each do |route|
-          if '*' == route.action_name
+          if route.action_name == '*'
             action_names = @controller_methods.get_methods(route.controller_name_with_namespaces).map(&:method_name)
             action_names.each { |action_name| call_method(action_name, route.controller_name_with_namespaces) }
           else
@@ -98,27 +99,29 @@ module RailsBestPractices
           end
         end
         @controller_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
-          @controller_methods
-        end
+      def methods
+        @controller_methods
+      end
 
-        def internal_except_methods
-          %w[rescue_action default_url_options].map { |method_name| "*\##{method_name}" } +
-            %w[Devise::OmniauthCallbacksController].map { |controller_name| "#{controller_name}#*" }
-        end
+      def internal_except_methods
+        %w[rescue_action default_url_options].map { |method_name| "*\##{method_name}" } +
+          %w[Devise::OmniauthCallbacksController].map { |controller_name| "#{controller_name}#*" }
+      end
 
-        def mark_publicize(method_name, class_name = current_class_name)
-          @controller_methods.mark_publicize(class_name, method_name)
-          @controller_methods.mark_parent_class_methods_publicize(class_name, method_name)
-        end
+      def mark_publicize(method_name, class_name = current_class_name)
+        @controller_methods.mark_publicize(class_name, method_name)
+        @controller_methods.mark_parent_class_methods_publicize(class_name, method_name)
+      end
     end
   end
 end

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