rails_best_practices 1.20.0 → 1.20.1

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,8 +22,7 @@ module RailsBestPractices
       # check if the node is
       #     ActiveRecord::Base.send(:include, ActiveModel::ForbiddenAttributesProtection)
       def include_forbidden_attributes_protection?(node)
-        node.receiver.to_s == 'ActiveRecord::Base' &&
-          node.message.to_s == 'send' &&
+        node.receiver.to_s == 'ActiveRecord::Base' && node.message.to_s == 'send' &&
           node.arguments.all.map(&:to_s) == ['include', 'ActiveModel::ForbiddenAttributesProtection']
       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
 

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
@@ -39,11 +50,14 @@ module RailsBestPractices
       #       }
       #     }
       add_callback :start_def do |node|
-        if @klass &&
-           current_extend_class_name != 'ActionMailer::Base' &&
-           (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
 
@@ -62,7 +76,12 @@ module RailsBestPractices
       add_callback :start_defs do |node|
         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,7 +162,7 @@ module RailsBestPractices
 
       private
 
-        # remember associations, with class to association names.
+      # 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

data/lib/rails_best_practices/prepares/route_prepare.rb

@@ -38,10 +38,9 @@ module RailsBestPractices
               else
                 action_names = [second_argument.hash_value('to').to_s]
               end
-            elsif first_argument.sexp_type == :symbol_literal && second_argument.try(:sexp_type) && \
+            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)
+              action_names = node.arguments.all.select { |arg| arg.sexp_type == :symbol_literal }.map(&:to_s)
             else
               action_names = [first_argument.to_s]
             end
@@ -84,7 +83,10 @@ module RailsBestPractices
               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| value_node.sexp_type == :string_literal && 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)
@@ -101,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| value_node.sexp_type == :string_literal && 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)
@@ -145,11 +150,12 @@ 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 argument.sexp_type == :bare_assoc_hash && argument.hash_value('controller').present?

data/lib/rails_best_practices/reviews/add_model_virtual_attribute_review.rb

@@ -46,8 +46,8 @@ 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.
+      # 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
@@ -59,34 +59,36 @@ module RailsBestPractices
         end
       end
 
-        # 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.
+      # 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] })
+          add_error "add model virtual attribute (for #{receiver})" if params_dup?(
+            assignments(receiver).collect { |h| h[:arguments] }
+          )
         end
       end
 
-        # if the nodes are duplicated.
+      # if the nodes are duplicated.
       def params_dup?(nodes)
         return false if nodes.nil?
 
         !dups(nodes).empty?
       end
 
-        # get the assignments of receiver.
+      # get the assignments of receiver.
       def assignments(receiver)
         @assignments[receiver] ||= []
       end
 
-        # Get the duplicate entries from an Enumerable.
-        #
-        # @return [Enumerable] the duplicate entries.
+      # 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
+        nodes.each_with_object({}) { |v, h| h[v] = h[v].to_i + 1 }.reject { |_k, v| v == 1 }.keys
       end
     end
   end

data/lib/rails_best_practices/reviews/always_add_db_index_review.rb

@@ -75,18 +75,20 @@ module RailsBestPractices
         @foreign_keys.each do |table, foreign_key|
           table_node = @table_nodes[table]
           foreign_key.each do |column|
-            if not_indexed?(table, column)
-              add_error "always add db index (#{table} => [#{Array(column).join(', ')}])", table_node.file, table_node.line_number
-            end
+            next unless not_indexed?(table, column)
+
+            add_error "always add db index (#{table} => [#{Array(column).join(', ')}])",
+                      table_node.file,
+                      table_node.line_number
           end
         end
       end
 
       private
 
-        # remember the node as index columns, when used outside a table
-        # block, i.e.
-        #   add_index :table_name, :column_name
+      # remember the node as index columns, when used outside a table
+      # block, i.e.
+      #   add_index :table_name, :column_name
       def remember_index_columns_outside_table(node)
         table_name = node.arguments.all.first.to_s
         index_column = node.arguments.all[1].to_object
@@ -95,9 +97,9 @@ module RailsBestPractices
         @index_columns[table_name] << index_column
       end
 
-        # remember the node as index columns, when used inside a table
-        # block, i.e.
-        #    t.index [:column_name, ...]
+      # remember the node as index columns, when used inside a table
+      # block, i.e.
+      #    t.index [:column_name, ...]
       def remember_index_columns_inside_table(node)
         table_name = @table_name
         index_column = node.arguments.all.first.to_object
@@ -106,31 +108,33 @@ module RailsBestPractices
         @index_columns[table_name] << index_column
       end
 
-        # remember table nodes
+      # remember table nodes
       def remember_table_nodes(node)
         @table_name = node.arguments.all.first.to_s
         @table_nodes[@table_name] = node
       end
 
-        # remember foreign key columns
+      # remember foreign key columns
       def remember_foreign_key_columns(node)
         table_name = @table_name
         foreign_key_column = node.arguments.all.first.to_s
         @foreign_keys[table_name] ||= []
         if foreign_key_column =~ /(.*?)_id$/
-          if @foreign_keys[table_name].delete("#{$1}_type")
-            @foreign_keys[table_name] << ["#{$1}_id", "#{$1}_type"]
-          else
-            @foreign_keys[table_name] << foreign_key_column
-          end
+          @foreign_keys[table_name] <<
+            if @foreign_keys[table_name].delete("#{Regexp.last_match(1)}_type")
+              ["#{Regexp.last_match(1)}_id", "#{Regexp.last_match(1)}_type"]
+            else
+              foreign_key_column
+            end
           foreign_id_column = foreign_key_column
         elsif foreign_key_column =~ /(.*?)_type$/
-          if @foreign_keys[table_name].delete("#{$1}_id")
-            @foreign_keys[table_name] << ["#{$1}_id", "#{$1}_type"]
-          else
-            @foreign_keys[table_name] << foreign_key_column
-          end
-          foreign_id_column = "#{$1}_id"
+          @foreign_keys[table_name] <<
+            if @foreign_keys[table_name].delete("#{Regexp.last_match(1)}_id")
+              ["#{Regexp.last_match(1)}_id", "#{Regexp.last_match(1)}_type"]
+            else
+              foreign_key_column
+            end
+          foreign_id_column = "#{Regexp.last_match(1)}_id"
         end
 
         if foreign_id_column
@@ -142,7 +146,7 @@ module RailsBestPractices
         end
       end
 
-        # remove the non foreign keys without corresponding tables.
+      # remove the non foreign keys without corresponding tables.
       def remove_table_not_exist_foreign_keys
         @foreign_keys.each do |table, foreign_keys|
           foreign_keys.delete_if do |key|
@@ -154,21 +158,22 @@ module RailsBestPractices
         end
       end
 
-        # remove the non foreign keys with only _type column.
+      # remove the non foreign keys with only _type column.
       def remove_only_type_foreign_keys
         @foreign_keys.each do |_table, foreign_keys|
           foreign_keys.delete_if { |key| key.is_a?(String) && key =~ /_type$/ }
         end
       end
 
-        # combine polymorphic foreign keys, e.g.
-        #     [tagger_id], [tagger_type] => [tagger_id, tagger_type]
+      # combine polymorphic foreign keys, e.g.
+      #     [tagger_id], [tagger_type] => [tagger_id, tagger_type]
       def combine_polymorphic_foreign_keys
         @index_columns.each do |_table, foreign_keys|
           foreign_id_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_id/ }
           foreign_type_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_type/ }
           foreign_id_keys.each do |id_key|
-            next unless type_key = foreign_type_keys.detect { |type_key| type_key.first == id_key.first.sub(/_id/, '') + '_type' }
+            next unless type_key =
+              foreign_type_keys.detect { |type_key| type_key.first == id_key.first.sub(/_id/, '') + '_type' }
 
             foreign_keys.delete(id_key)
             foreign_keys.delete(type_key)
@@ -177,13 +182,13 @@ module RailsBestPractices
         end
       end
 
-        # check if the table's column is indexed.
+      # check if the table's column is indexed.
       def not_indexed?(table, column)
         index_columns = @index_columns[table]
         !index_columns || index_columns.none? { |e| greater_than_or_equal(Array(e), Array(column)) }
       end
 
-        # check if more_array is greater than less_array or equal to less_array.
+      # check if more_array is greater than less_array or equal to less_array.
       def greater_than_or_equal(more_array, less_array)
         more_size = more_array.size
         less_size = less_array.size

data/lib/rails_best_practices/reviews/check_destroy_return_value_review.rb

@@ -10,7 +10,17 @@ module RailsBestPractices
     #   Check all "save" calls to check the return value is used by a node we have visited.
     class CheckDestroyReturnValueReview < Review
       include Classable
-      interesting_nodes :call, :command_call, :method_add_arg, :if, :ifop, :elsif, :unless, :if_mod, :unless_mod, :assign, :binary
+      interesting_nodes :call,
+                        :command_call,
+                        :method_add_arg,
+                        :if,
+                        :ifop,
+                        :elsif,
+                        :unless,
+                        :if_mod,
+                        :unless_mod,
+                        :assign,
+                        :binary
       interesting_files ALL_FILES
 
       add_callback :start_if, :start_ifop, :start_elsif, :start_unless, :start_if_mod, :start_unless_mod do |node|
@@ -21,14 +31,13 @@ module RailsBestPractices
         @used_return_value_of = node.right_value
       end
 
+      # Consider anything used in an expression like "A or B" as used
       add_callback :start_binary do |node|
-        # Consider anything used in an expression like "A or B" as used
         if %w[&& || and or].include?(node[2].to_s)
           all_conditions = node.all_conditions
           # if our current binary is a subset of the @used_return_value_of
           # then don't overwrite it
-          already_included = @used_return_value_of &&
-                             (all_conditions - @used_return_value_of).empty?
+          already_included = @used_return_value_of && (all_conditions - @used_return_value_of).empty?
 
           @used_return_value_of = node.all_conditions unless already_included
         end
@@ -37,7 +46,7 @@ module RailsBestPractices
       def return_value_is_used?(node)
         return false unless @used_return_value_of
 
-        node == @used_return_value_of or @used_return_value_of.include?(node)
+        (node == @used_return_value_of) || @used_return_value_of.include?(node)
       end
 
       def model_classnames

data/lib/rails_best_practices/reviews/check_save_return_value_review.rb

@@ -14,7 +14,17 @@ module RailsBestPractices
     #   Check all "save" calls to check the return value is used by a node we have visited.
     class CheckSaveReturnValueReview < Review
       include Classable
-      interesting_nodes :call, :command_call, :method_add_arg, :if, :ifop, :elsif, :unless, :if_mod, :unless_mod, :assign, :binary
+      interesting_nodes :call,
+                        :command_call,
+                        :method_add_arg,
+                        :if,
+                        :ifop,
+                        :elsif,
+                        :unless,
+                        :if_mod,
+                        :unless_mod,
+                        :assign,
+                        :binary
       interesting_files ALL_FILES
       url 'https://rails-bestpractices.com/posts/2012/11/02/check-the-return-value-of-save-otherwise-use-save/'
 
@@ -26,14 +36,13 @@ module RailsBestPractices
         @used_return_value_of = node.right_value
       end
 
+      # Consider anything used in an expression like "A or B" as used
       add_callback :start_binary do |node|
-        # Consider anything used in an expression like "A or B" as used
         if %w[&& || and or].include?(node[2].to_s)
           all_conditions = node.all_conditions
           # if our current binary is a subset of the @used_return_value_of
           # then don't overwrite it
-          already_included = @used_return_value_of &&
-                             (all_conditions - @used_return_value_of).empty?
+          already_included = @used_return_value_of && (all_conditions - @used_return_value_of).empty?
 
           @used_return_value_of = node.all_conditions unless already_included
         end
@@ -42,7 +51,7 @@ module RailsBestPractices
       def return_value_is_used?(node)
         return false unless @used_return_value_of
 
-        node == @used_return_value_of or @used_return_value_of.include?(node)
+        (node == @used_return_value_of) || @used_return_value_of.include?(node)
       end
 
       def model_classnames
@@ -58,9 +67,11 @@ module RailsBestPractices
             end
           elsif message == 'create'
             # We're only interested in 'create' calls on model classes:
-            possible_receiver_classes = [node.receiver.to_s] + classable_modules.map do |mod|
-                                                                 "#{mod}::#{node.receiver}"
-                                                               end
+            possible_receiver_classes =
+              [node.receiver.to_s] +
+                classable_modules.map do |mod|
+                  "#{mod}::#{node.receiver}"
+                end
             unless (possible_receiver_classes & model_classnames).empty?
               add_error "use 'create!' instead of 'create' as the latter may not always save"
             end