rails_best_practices 1.19.2 → 1.20.1

data/lib/rails_best_practices/prepares.rb

@@ -4,7 +4,7 @@ require_rel 'prepares'
 
 module RailsBestPractices
   module Prepares
-    class <<self
+    class << self
       def klasses
         models + mailers + controllers
       end

data/lib/rails_best_practices/prepares/controller_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember controllers and controller methods
+
     class ControllerPrepare < Core::Check
       include Core::Check::Classable
       include Core::Check::InheritedResourcesable
@@ -24,43 +25,42 @@ module RailsBestPractices
       # also check if the controller is inherit from InheritedResources::Base.
       add_callback :start_class do |_node|
         @controllers << @klass
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @current_controller_name = @klass.to_s
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # remember the action names at the end of class node if the controller is a InheritedResources.
       add_callback :end_class do |node|
-        if @inherited_resources && 'ApplicationController' != current_class_name
+        if @inherited_resources && @current_controller_name != 'ApplicationController'
           @actions.each do |action|
-            @methods.add_method(current_class_name, action, 'file' => node.file, 'line_number' => node.line_number)
+            @methods.add_method(
+              @current_controller_name,
+              action,
+              'file' => node.file, 'line_number' => node.line_number
+            )
           end
         end
       end
 
       # check if there is a DSL call inherit_resources.
       add_callback :start_var_ref do |_node|
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # check if there is a DSL call inherit_resources.
       add_callback :start_vcall do |_node|
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # restrict actions for inherited_resources
       add_callback :start_command do |node|
-        if 'include' == node.message.to_s
+        if node.message.to_s == 'include'
           @helpers.add_module_descendant(node.arguments.all.first.to_s, current_class_name)
-        elsif @inherited_resources && 'actions' ==  node.message.to_s
-          if 'all' == node.arguments.all.first.to_s
+        elsif @inherited_resources && node.message.to_s == 'actions'
+          if node.arguments.all.first.to_s == 'all'
             @actions = DEFAULT_ACTIONS
             option_argument = node.arguments.all[1]
-            if option_argument && :bare_assoc_hash == option_argument.sexp_type && option_argument.hash_value('except')
+            if option_argument && option_argument.sexp_type == :bare_assoc_hash && option_argument.hash_value('except')
               @actions -= option_argument.hash_value('except').to_object
             end
           else
@@ -83,14 +83,21 @@ module RailsBestPractices
       #     }
       add_callback :start_def do |node|
         method_name = node.method_name.to_s
-        @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+        @methods.add_method(
+          current_class_name,
+          method_name,
+          { 'file' => node.file, 'line_number' => node.line_number },
+          current_access_control
+        )
       end
 
       # ask Reviews::RemoveUnusedMoethodsInHelperReview to check the controllers who include helpers.
       add_callback :after_check do
         descendants = @helpers.map(&:descendants).flatten
         if descendants.present?
-          Reviews::RemoveUnusedMethodsInHelpersReview.interesting_files *descendants.map { |descendant| /#{descendant.underscore}/ }
+          Reviews::RemoveUnusedMethodsInHelpersReview.interesting_files *descendants.map { |descendant|
+                                                                          /#{descendant.underscore}/
+                                                                        }
         end
       end
     end

data/lib/rails_best_practices/prepares/gemfile_prepare.rb

@@ -10,10 +10,10 @@ module RailsBestPractices
         @gems = Prepares.gems
       end
 
-      def check(filename, content)
+      def check(_filename, content)
         content.split("\n").each do |line|
           if line =~ /([^ ]+) \((\d.*)\)/
-            @gems << Core::Gem.new($1, $2)
+            @gems << Core::Gem.new(Regexp.last_match(1), Regexp.last_match(2))
           end
         end
       end

data/lib/rails_best_practices/prepares/helper_prepare.rb

@@ -32,7 +32,12 @@ module RailsBestPractices
       add_callback :start_def do |node|
         if node.file =~ HELPER_FILES
           method_name = node.method_name.to_s
-          @methods.add_method(current_module_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_module_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
     end

data/lib/rails_best_practices/prepares/initializer_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Check all initializers
+
     class InitializerPrepare < Core::Check
       interesting_nodes :method_add_arg, :class
       interesting_files INITIALIZER_FILES
@@ -21,9 +22,8 @@ module RailsBestPractices
       # check if the node is
       #     ActiveRecord::Base.send(:include, ActiveModel::ForbiddenAttributesProtection)
       def include_forbidden_attributes_protection?(node)
-        'ActiveRecord::Base' == node.receiver.to_s &&
-          'send' == node.message.to_s &&
-          ['include', 'ActiveModel::ForbiddenAttributesProtection'] == node.arguments.all.map(&:to_s)
+        node.receiver.to_s == 'ActiveRecord::Base' && node.message.to_s == 'send' &&
+          node.arguments.all.map(&:to_s) == ['include', 'ActiveModel::ForbiddenAttributesProtection']
       end
     end
   end

data/lib/rails_best_practices/prepares/mailer_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember the mailer names.
+
     class MailerPrepare < Core::Check
       include Core::Check::Classable
 
@@ -18,7 +19,7 @@ module RailsBestPractices
       # if it is a subclass of ActionMailer::Base,
       # then remember its class name.
       add_callback :start_class do |_node|
-        if 'ActionMailer::Base' == current_extend_class_name
+        if current_extend_class_name == 'ActionMailer::Base'
           @mailers << @klass
         end
       end

data/lib/rails_best_practices/prepares/model_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember models and model associations.
+
     class ModelPrepare < Core::Check
       include Core::Check::Classable
       include Core::Check::Accessable
@@ -10,7 +11,17 @@ module RailsBestPractices
       interesting_nodes :class, :def, :defs, :command, :alias
       interesting_files MODEL_FILES
 
-      ASSOCIATION_METHODS = %w[belongs_to has_one has_many has_and_belongs_to_many embeds_many embeds_one embedded_in many one].freeze
+      ASSOCIATION_METHODS = %w[
+        belongs_to
+        has_one
+        has_many
+        has_and_belongs_to_many
+        embeds_many
+        embeds_one
+        embedded_in
+        many
+        one
+      ].freeze
 
       def initialize
         @models = Prepares.models
@@ -21,7 +32,7 @@ module RailsBestPractices
 
       # remember the class name.
       add_callback :start_class do |_node|
-        if 'ActionMailer::Base' != current_extend_class_name
+        if current_extend_class_name != 'ActionMailer::Base'
           @models << @klass
         end
       end
@@ -39,11 +50,14 @@ module RailsBestPractices
       #       }
       #     }
       add_callback :start_def do |node|
-        if @klass &&
-            'ActionMailer::Base' != current_extend_class_name &&
-            (classable_modules.empty? || klasses.any?)
+        if @klass && current_extend_class_name != 'ActionMailer::Base' && (classable_modules.empty? || klasses.any?)
           method_name = node.method_name.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
 
@@ -60,9 +74,14 @@ module RailsBestPractices
       #       }
       #     }
       add_callback :start_defs do |node|
-        if @klass && 'ActionMailer::Base' != current_extend_class_name
+        if @klass && current_extend_class_name != 'ActionMailer::Base'
           method_name = node.method_name.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
 
@@ -81,15 +100,31 @@ module RailsBestPractices
         case node.message.to_s
         when 'named_scope', 'scope', 'alias_method'
           method_name = node.arguments.all.first.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         when 'alias_method_chain'
           method, feature = *node.arguments.all.map(&:to_s)
-          @methods.add_method(current_class_name, "#{method}_with_#{feature}", { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
-          @methods.add_method(current_class_name, method.to_s, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            "#{method}_with_#{feature}",
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
+          @methods.add_method(
+            current_class_name,
+            method.to_s,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         when 'field'
           arguments = node.arguments.all
           attribute_name = arguments.first.to_s
-          attribute_type = arguments.last.hash_value('type').present? ? arguments.last.hash_value('type').to_s : 'String'
+          attribute_type =
+            arguments.last.hash_value('type').present? ? arguments.last.hash_value('type').to_s : 'String'
           @model_attributes.add_attribute(current_class_name, attribute_name, attribute_type)
         when 'key'
           attribute_name, attribute_type = node.arguments.all.map(&:to_s)
@@ -102,7 +137,12 @@ module RailsBestPractices
       # check alias node to remembr the alias methods.
       add_callback :start_alias do |node|
         method_name = node.new_method.to_s
-        @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+        @methods.add_method(
+          current_class_name,
+          method_name,
+          { 'file' => node.file, 'line_number' => node.line_number },
+          current_access_control
+        )
       end
 
       # after prepare process, fix incorrect associations' class_name.
@@ -122,17 +162,17 @@ module RailsBestPractices
 
       private
 
-        # remember associations, with class to association names.
-        def remember_association(node)
-          association_meta = node.message.to_s
-          association_name = node.arguments.all.first.to_s
-          arguments_node = node.arguments.all.last
-          if arguments_node.hash_value('class_name').present?
-            association_class = arguments_node.hash_value('class_name').to_s
-          end
-          association_class ||= association_name.classify
-          @model_associations.add_association(current_class_name, association_name, association_meta, association_class)
+      # remember associations, with class to association names.
+      def remember_association(node)
+        association_meta = node.message.to_s
+        association_name = node.arguments.all.first.to_s
+        arguments_node = node.arguments.all.last
+        if arguments_node.hash_value('class_name').present?
+          association_class = arguments_node.hash_value('class_name').to_s
         end
+        association_class ||= association_name.classify
+        @model_associations.add_association(current_class_name, association_name, association_meta, association_class)
+      end
     end
   end
 end

data/lib/rails_best_practices/prepares/route_prepare.rb

@@ -27,21 +27,20 @@ module RailsBestPractices
           first_argument = node.arguments.all.first
           second_argument = node.arguments.all[1]
           if @controller_names.last
-            if :bare_assoc_hash == first_argument.sexp_type
+            if first_argument.sexp_type == :bare_assoc_hash
               action_names = [first_argument.hash_values.first.to_s]
-            elsif :array == first_argument.sexp_type
+            elsif first_argument.sexp_type == :array
               action_names = first_argument.array_values.map(&:to_s)
-            elsif :bare_assoc_hash == second_argument.try(:sexp_type) && second_argument.hash_value('to').present?
-              if :string_literal == second_argument.hash_value('to').sexp_type
+            elsif second_argument.try(:sexp_type) == :bare_assoc_hash && second_argument.hash_value('to').present?
+              if second_argument.hash_value('to').sexp_type == :string_literal
                 controller_name, action_name = second_argument.hash_value('to').to_s.split('#')
                 action_names = [action_name]
               else
                 action_names = [second_argument.hash_value('to').to_s]
               end
-            elsif :symbol_literal == first_argument.sexp_type && second_argument.try(:sexp_type) && \
-              :symbol_literal == second_argument.sexp_type
-              action_names = node.arguments.all.select \
-                { |arg| :symbol_literal == arg.sexp_type }.map(&:to_s)
+            elsif first_argument.sexp_type == :symbol_literal && second_argument.try(:sexp_type) &&
+                  second_argument.sexp_type == :symbol_literal
+              action_names = node.arguments.all.select { |arg| arg.sexp_type == :symbol_literal }.map(&:to_s)
             else
               action_names = [first_argument.to_s]
             end
@@ -49,18 +48,18 @@ module RailsBestPractices
               @routes.add_route(current_namespaces, current_controller_name, action_name)
             end
           else
-            if :bare_assoc_hash == first_argument.sexp_type
+            if first_argument.sexp_type == :bare_assoc_hash
               route_node = first_argument.hash_values.first
               # do not parse redirect block
-              if :method_add_arg != route_node.sexp_type
+              if route_node.sexp_type != :method_add_arg
                 controller_name, action_name = route_node.to_s.split('#')
                 @routes.add_route(current_namespaces, controller_name.underscore, action_name)
               end
-            elsif :array == first_argument.sexp_type
+            elsif first_argument.sexp_type == :array
               first_argument.array_values.map(&:to_s).each do |action_node|
                 @routes.add_route(current_namespaces, controller_name, action_node.to_s)
               end
-            elsif :bare_assoc_hash == second_argument.try(:sexp_type)
+            elsif second_argument.try(:sexp_type) == :bare_assoc_hash
               if second_argument.hash_value('to').present?
                 controller_name, action_name = second_argument.hash_value('to').to_s.split('#')
               else
@@ -78,12 +77,16 @@ module RailsBestPractices
           case options.sexp_type
           when :bare_assoc_hash
             if options.hash_value('controller').present?
-              return if :regexp_literal == options.hash_value('controller').sexp_type
+              return if options.hash_value('controller').sexp_type == :regexp_literal
+
               controller_name = options.hash_value('controller').to_s
               action_name = options.hash_value('action').present? ? options.hash_value('action').to_s : '*'
               @routes.add_route(current_namespaces, controller_name, action_name)
             else
-              route_node = options.hash_values.find { |value_node| :string_literal == value_node.sexp_type && value_node.to_s.include?('#') }
+              route_node =
+                options.hash_values.find do |value_node|
+                  value_node.sexp_type == :string_literal && value_node.to_s.include?('#')
+                end
               if route_node.present?
                 controller_name, action_name = route_node.to_s.split('#')
                 @routes.add_route(current_namespaces, controller_name.underscore, action_name)
@@ -100,7 +103,10 @@ module RailsBestPractices
           options = node.arguments.all.last
           case options.sexp_type
           when :bare_assoc_hash
-            route_node = options.hash_values.find { |value_node| :string_literal == value_node.sexp_type && value_node.to_s.include?('#') }
+            route_node =
+              options.hash_values.find do |value_node|
+                value_node.sexp_type == :string_literal && value_node.to_s.include?('#')
+              end
             if route_node.present?
               controller_name, action_name = route_node.to_s.split('#')
               @routes.add_route(current_namespaces, controller_name.underscore, action_name)
@@ -144,14 +150,15 @@ module RailsBestPractices
           if node.arguments.all.last.hash_value('module').present?
             @namespaces << node.arguments.all.last.hash_value('module').to_s
           end
-          if node.arguments.all.last.hash_value('controller').present?
-            @controller_name = [:scope, node.arguments.all.last.hash_value('controller').to_s]
-          else
-            @controller_name = @controller_name.try(:first) == :scope ? @controller_name : nil
-          end
+          @controller_name =
+            if node.arguments.all.last.hash_value('controller').present?
+              [:scope, node.arguments.all.last.hash_value('controller').to_s]
+            else
+              @controller_name.try(:first) == :scope ? @controller_name : nil
+            end
         when 'with_options'
           argument = node.arguments.all.last
-          if :bare_assoc_hash == argument.sexp_type && argument.hash_value('controller').present?
+          if argument.sexp_type == :bare_assoc_hash && argument.hash_value('controller').present?
             @controller_name = [:with_option, argument.hash_value('controller').to_s]
           end
         else

data/lib/rails_best_practices/prepares/schema_prepare.rb

@@ -15,7 +15,7 @@ module RailsBestPractices
       end
 
       add_callback :start_command do |node|
-        if 'create_table' == node.message.to_s
+        if node.message.to_s == 'create_table'
           @last_klazz = node.arguments.all.first.to_s.classify
         end
       end

data/lib/rails_best_practices/reviews/add_model_virtual_attribute_review.rb

@@ -46,46 +46,50 @@ module RailsBestPractices
 
       private
 
-        # check an attribute assignment node, if there is a array reference node in the right value of assignment node,
-        # then remember this attribute assignment.
-        def assign(node)
-          left_value = node.left_value
-          right_value = node.right_value
-          return unless :field == left_value.sexp_type && :call == right_value.sexp_type
-          aref_node = right_value.grep_node(sexp_type: :aref)
-          if aref_node
-            assignments(left_value.receiver.to_s) << { message: left_value.message.to_s, arguments: aref_node.to_s }
-          end
-        end
+      # check an attribute assignment node, if there is a array reference node in the right value of assignment node,
+      # then remember this attribute assignment.
+      def assign(node)
+        left_value = node.left_value
+        right_value = node.right_value
+        return unless left_value.sexp_type == :field && right_value.sexp_type == :call
 
-        # check a call node with message "save" or "save!",
-        # if there exists an attribute assignment for the receiver of this call node,
-        # and if the arguments of this attribute assignments has duplicated entries (different message and same arguments),
-        # then this node needs to add a virtual attribute.
-        def call_assignment(node)
-          if ['save', 'save!'].include? node.message.to_s
-            receiver = node.receiver.to_s
-            add_error "add model virtual attribute (for #{receiver})" if params_dup?(assignments(receiver).collect { |h| h[:arguments] })
-          end
+        aref_node = right_value.grep_node(sexp_type: :aref)
+        if aref_node
+          assignments(left_value.receiver.to_s) << { message: left_value.message.to_s, arguments: aref_node.to_s }
         end
+      end
 
-        # if the nodes are duplicated.
-        def params_dup?(nodes)
-          return false if nodes.nil?
-          !dups(nodes).empty?
+      # check a call node with message "save" or "save!",
+      # if there exists an attribute assignment for the receiver of this call node,
+      # and if the arguments of this attribute assignments has duplicated entries (different message and same arguments),
+      # then this node needs to add a virtual attribute.
+      def call_assignment(node)
+        if ['save', 'save!'].include? node.message.to_s
+          receiver = node.receiver.to_s
+          add_error "add model virtual attribute (for #{receiver})" if params_dup?(
+            assignments(receiver).collect { |h| h[:arguments] }
+          )
         end
+      end
 
-        # get the assignments of receiver.
-        def assignments(receiver)
-          @assignments[receiver] ||= []
-        end
+      # if the nodes are duplicated.
+      def params_dup?(nodes)
+        return false if nodes.nil?
 
-        # Get the duplicate entries from an Enumerable.
-        #
-        # @return [Enumerable] the duplicate entries.
-        def dups(nodes)
-          nodes.inject({}) { |h, v| h[v] = h[v].to_i + 1; h }.reject { |_k, v| v == 1 }.keys
-        end
+        !dups(nodes).empty?
+      end
+
+      # get the assignments of receiver.
+      def assignments(receiver)
+        @assignments[receiver] ||= []
+      end
+
+      # Get the duplicate entries from an Enumerable.
+      #
+      # @return [Enumerable] the duplicate entries.
+      def dups(nodes)
+        nodes.each_with_object({}) { |v, h| h[v] = h[v].to_i + 1 }.reject { |_k, v| v == 1 }.keys
+      end
     end
   end
 end