rubocop 0.58.2 → 0.59.0

data/lib/rubocop/cop/performance/chain_array_allocation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of
+      # @example
+      #   # bad
+      #   array = ["a", "b", "c"]
+      #   array.compact.flatten.map { |x| x.downcase }
+      #
+      # Each of these methods (`compact`, `flatten`, `map`) will generate a
+      # new intermediate array that is promptly thrown away. Instead it is
+      # faster to mutate when we know it's safe.
+      #
+      # @example
+      #   # good.
+      #   array = ["a", "b", "c"]
+      #   array.compact!
+      #   array.flatten!
+      #   array.map! { |x| x.downcase }
+      #   array
+      class ChainArrayAllocation < Cop
+        include RangeHelp
+
+        # These methods return a new array but only sometimes. They must be
+        # called with an argument. For example:
+        #
+        #   [1,2].first    # => 1
+        #   [1,2].first(1) # => [1]
+        #
+        RETURN_NEW_ARRAY_WHEN_ARGS = ':first :last :pop :sample :shift '.freeze
+
+        # These methods return a new array only when called without a block.
+        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ':zip :product '.freeze
+
+        # These methods ALWAYS return a new array
+        # after they're called it's safe to mutate the the resulting array
+        ALWAYS_RETURNS_NEW_ARRAY = ':* :+ :- :collect :compact :drop '\
+                                   ':drop_while :flatten :map :reject ' \
+                                   ':reverse :rotate :select :shuffle :sort ' \
+                                   ':take :take_while :transpose :uniq ' \
+                                   ':values_at :| '.freeze
+
+        # These methods have a mutation alternative. For example :collect
+        # can be called as :collect!
+        HAS_MUTATION_ALTERNATIVE = ':collect :compact :flatten :map :reject '\
+                                   ':reverse :rotate :select :shuffle :sort '\
+                                   ':uniq '.freeze
+        MSG = 'Use `%<method>s...%<second_method>s!` instead of `%<method>s' \
+              '...%<second_method>s`.'.freeze
+
+        def_node_matcher :flat_map_candidate?, <<-PATTERN
+          {
+            (send (send _ ${#{RETURN_NEW_ARRAY_WHEN_ARGS}} {int lvar ivar cvar gvar}) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+            (send (block (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY} }) ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+            (send (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK}} ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+          }
+        PATTERN
+
+        def on_send(node)
+          flat_map_candidate?(node) do |fm, sm, _|
+            range = range_between(
+              node.loc.dot.begin_pos,
+              node.source_range.end_pos
+            )
+            add_offense(
+              node,
+              location: range,
+              message: format(MSG, method: fm, second_method: sm)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/compare_with_block.rb

@@ -48,6 +48,7 @@ module RuboCop
           compare?(node) do |send, var_a, var_b, body|
             replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
               return unless slow_compare?(method, args_a, args_b)
+
               range = compare_range(send, node)
 
               add_offense(
@@ -78,8 +79,10 @@ module RuboCop
 
         def slow_compare?(method, args_a, args_b)
           return false unless args_a == args_b
+
           if method == :[]
             return false unless args_a.size == 1
+
             key = args_a.first
             return false unless %i[sym str int].include?(key.type)
           else

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -101,6 +101,7 @@ module RuboCop
 
         def match_with_lvasgn?(node)
           return false unless node.match_with_lvasgn_type?
+
           regexp, _rhs = *node
           regexp.to_regexp.named_captures.empty?
         end

data/lib/rubocop/cop/performance/sample.rb

@@ -88,12 +88,14 @@ module RuboCop
 
         def sample_size_for_two_args(first, second)
           return :unknown unless first.int_type? && first.to_a.first.zero?
+
           second.int_type? ? second.to_a.first : :unknown
         end
 
         def range_size(range_node)
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
+
           low, high = vals.map { |val| val.children[0] }
           return :unknown unless low.zero? && high >= 0
 

data/lib/rubocop/cop/performance/size.rb

@@ -55,15 +55,21 @@ module RuboCop
         end
 
         def array?(node)
+          return true if node.array_type?
+          return false unless node.send_type?
+
           _, constant = *node.receiver
 
-          node.array_type? || constant == :Array || node.method_name == :to_a
+          constant == :Array || node.method_name == :to_a
         end
 
         def hash?(node)
+          return true if node.hash_type?
+          return false unless node.send_type?
+
           _, constant = *node.receiver
 
-          node.hash_type? || constant == :Hash || node.method_name == :to_h
+          constant == :Hash || node.method_name == :to_h
         end
       end
     end

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -87,6 +87,7 @@ module RuboCop
           unless first_param.str_type?
             return true if options
             return true unless first_source =~ DETERMINISTIC_REGEX
+
             # This must be done after checking DETERMINISTIC_REGEX
             # Otherwise things like \s will trip us up
             first_source = interpret_string_escapes(first_source)

data/lib/rubocop/cop/rails/active_support_aliases.rb

@@ -46,6 +46,7 @@ module RuboCop
 
         def autocorrect(node)
           return false if append(node)
+
           lambda do |corrector|
             method_name = node.loc.selector.source
             replacement = ALIASES[method_name.to_sym][:original]

data/lib/rubocop/cop/rails/bulk_change_table.rb

@@ -6,8 +6,8 @@ module RuboCop
       # This Cop checks whether alter queries are combinable.
       # If combinable queries are detected, it suggests to you
       # to use `change_table` with `bulk: true` instead.
-      # When use this method, make combinable alter queries
-      # a bulk alter query.
+      # This option causes the migration to generate a single
+      # ALTER TABLE statement combining multiple column alterations.
       #
       # The `bulk` option is only supported on the MySQL and
       # the PostgreSQL (5.2 later) adapter; thus it will
@@ -155,6 +155,7 @@ module RuboCop
           return unless node.command?(:change_table)
           return if include_bulk_options?(node)
           return unless node.block_node
+
           send_nodes = node.block_node.body.each_child_node(:send).to_a
 
           transformations = send_nodes.select do |send_node|
@@ -171,6 +172,7 @@ module RuboCop
           # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
           options = node.arguments[1]
           return false unless options
+
           options.hash_type? &&
             options.keys.any? { |key| key.sym_type? && key.value == :bulk }
         end
@@ -181,6 +183,7 @@ module RuboCop
 
         def database_from_yaml
           return nil unless database_yaml
+
           case database_yaml['adapter']
           when 'mysql2'
             MYSQL
@@ -191,10 +194,13 @@ module RuboCop
 
         def database_yaml
           return nil unless File.exist?('config/database.yml')
+
           yaml = YAML.load_file('config/database.yml')
           return nil unless yaml.is_a? Hash
+
           config = yaml['development']
           return nil unless config.is_a?(Hash)
+
           config
         rescue Psych::SyntaxError
           nil
@@ -236,6 +242,7 @@ module RuboCop
           # arguments: [{(sym :table)(str "table")} ...]
           table_node = node.arguments[0]
           return unless table_node.is_a? RuboCop::AST::BasicLiteralNode
+
           message = format(MSG_FOR_ALTER_METHODS, table: table_node.value)
           add_offense(node, message: message)
         end

data/lib/rubocop/cop/rails/create_table_with_timestamps.rb

@@ -66,6 +66,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.command?(:create_table)
+
           parent = node.parent
 
           if create_table_with_block?(parent)

data/lib/rubocop/cop/rails/delegate.rb

@@ -94,8 +94,13 @@ module RuboCop
         def arguments_match?(arg_array, body)
           argument_array = body.arguments
 
-          arg_array == argument_array ||
-            arg_array.map(&:children) == argument_array.map(&:children)
+          return false if arg_array.size != argument_array.size
+
+          arg_array.zip(argument_array).all? do |arg, argument|
+            arg.arg_type? &&
+              argument.lvar_type? &&
+              arg.children == argument.children
+          end
         end
 
         def method_name_matches?(method_name, body)

data/lib/rubocop/cop/rails/dynamic_find_by.rb

@@ -74,6 +74,7 @@ module RuboCop
         def static_method_name(method_name)
           match = METHOD_PATTERN.match(method_name)
           return nil unless match
+
           match[2] ? 'find_by!' : 'find_by'
         end
       end

data/lib/rubocop/cop/rails/find_each.rb

@@ -15,11 +15,16 @@ module RuboCop
       class FindEach < Cop
         MSG = 'Use `find_each` instead of `each`.'.freeze
 
-        SCOPE_METHODS = %i[all where not].freeze
+        SCOPE_METHODS = %i[
+          all eager_load includes joins left_joins left_outer_joins not preload
+          references unscoped where
+        ].freeze
         IGNORED_METHODS = %i[order limit select].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:each)
+          return unless node.receiver &&
+                        node.receiver.send_type? &&
+                        node.method?(:each)
 
           return unless SCOPE_METHODS.include?(node.receiver.method_name)
           return if method_chain(node).any? { |m| ignored_by_find_each?(m) }

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # This cop is used to identify usages of http methods like `get`, `post`,
       # `put`, `patch` without the usage of keyword arguments in your tests and
-      # change them to use keyword args.  This cop only applies to Rails >= 5 .
+      # change them to use keyword args. This cop only applies to Rails >= 5.
       # If you are running Rails < 5 you should disable the
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
       # .rubocop.yml file to 4.0, etc.

data/lib/rubocop/cop/rails/http_status.rb

@@ -56,8 +56,10 @@ module RuboCop
           http_status(node) do |hash_node|
             status = status_code(hash_node)
             return unless status
+
             checker = checker_class.new(status)
             return unless checker.offensive?
+
             add_offense(checker.node, message: checker.message)
           end
         end

data/lib/rubocop/cop/rails/inverse_of.rb

@@ -178,6 +178,7 @@ module RuboCop
         def on_send(node)
           recv, arguments = association_recv_arguments(node)
           return unless arguments
+
           with_options = with_options_arguments(recv, node)
 
           options = arguments.concat(with_options).flat_map do |arg|
@@ -189,6 +190,7 @@ module RuboCop
                         options_requiring_inverse_of?(options)
 
           return if options_contain_inverse_of?(options)
+
           add_offense(node, message: message(options), location: :selector)
         end
 
@@ -203,6 +205,7 @@ module RuboCop
           end
 
           return required if target_rails_version >= 5.2
+
           required || options.any? { |opt| as_option?(opt) }
         end
 
@@ -226,6 +229,7 @@ module RuboCop
 
         def same_context_in_with_options?(arg, recv)
           return true if arg.nil? && recv.nil?
+
           arg && recv && arg.children[0] == recv.children[0]
         end
 

data/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb

@@ -92,6 +92,7 @@ module RuboCop
 
           parent = node.each_ancestor(:class, :module).first
           return unless parent
+
           block = parent.each_child_node(:begin).first
           return unless block
 

data/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb

@@ -82,6 +82,7 @@ module RuboCop
         def on_block(node)
           with_options?(node) do |arg, body|
             return unless all_block_nodes_in(body).count.zero?
+
             send_nodes = all_send_nodes_in(body)
 
             if send_nodes.all? { |n| same_value?(arg, n.receiver) }

data/lib/rubocop/cop/rails/reversible_migration.rb

@@ -249,6 +249,7 @@ module RuboCop
           method_name = node.method_name
           return if receiver != node.receiver &&
                     !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
+
           add_offense(
             node,
             message: format(MSG, action: "change_table(with #{method_name})")

data/lib/rubocop/cop/rails/save_bang.rb

@@ -7,12 +7,21 @@ module RuboCop
       # should be used instead of save because the model might have failed to
       # save and an exception is better than unhandled failure.
       #
-      # This will ignore calls that return a boolean for success if the result
-      # is assigned to a variable or used as the condition in an if/unless
-      # statement.  It will also ignore calls that return a model assigned to a
-      # variable that has a call to `persisted?`. Finally, it will ignore any
-      # call with more than 2 arguments as that is likely not an Active Record
-      # call or a Model.update(id, attributes) call.
+      # This will allow:
+      # - update or save calls, assigned to a variable,
+      #   or used as a condition in an if/unless/case statement.
+      # - create calls, assigned to a variable that then has a
+      #   call to `persisted?`.
+      # - calls if the result is explicitly returned from methods and blocks,
+      #   or provided as arguments.
+      # - calls whose signature doesn't look like an ActiveRecord
+      #   persistence method.
+      #
+      # By default it will also allow implicit returns from methods and blocks.
+      # that behavior can be turned off with `AllowImplicitReturn: false`.
+      #
+      # You can permit receivers that are giving false positives with
+      # `AllowedReceivers: []`
       #
       # @example
       #
@@ -35,6 +44,58 @@ module RuboCop
       #   unless user.persisted?
       #     # ...
       #   end
+      #
+      #   def save_user
+      #     return user.save
+      #   end
+      #
+      # @example AllowImplicitReturn: true (default)
+      #
+      #   # good
+      #   users.each { |u| u.save }
+      #
+      #   def save_user
+      #     user.save
+      #   end
+      #
+      # @example AllowImplicitReturn: false
+      #
+      #   # bad
+      #   users.each { |u| u.save }
+      #   def save_user
+      #     user.save
+      #   end
+      #
+      #   # good
+      #   users.each { |u| u.save! }
+      #
+      #   def save_user
+      #     user.save!
+      #   end
+      #
+      #   def save_user
+      #     return user.save
+      #   end
+      #
+      # @example AllowedReceivers: ['merchant.customers', 'Service::Mailer']
+      #
+      #   # bad
+      #   merchant.create
+      #   customers.builder.save
+      #   Mailer.create
+      #
+      #   module Service::Mailer
+      #     self.create
+      #   end
+      #
+      #   # good
+      #   merchant.customers.create
+      #   MerchantService.merchant.customers.destroy
+      #   Service::Mailer.update(message: 'Message')
+      #   ::Service::Mailer.update
+      #   Services::Service::Mailer.update(message: 'Message')
+      #   Service::Mailer::update
+      #
       class SaveBang < Cop
         include NegativeConditional
 
@@ -43,7 +104,7 @@ module RuboCop
         CREATE_MSG = (MSG +
                       ' Or check `persisted?` on model returned from ' \
                       '`%<current>s`.').freeze
-        CREATE_CONDITIONAL_MSG = '`%<method>s` returns a model which is ' \
+        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is ' \
                                  'always truthy.'.freeze
 
         CREATE_PERSIST_METHODS = %i[create
@@ -67,28 +128,23 @@ module RuboCop
 
         def check_assignment(assignment)
           node = right_assignment_node(assignment)
-          return unless node
-          return unless CREATE_PERSIST_METHODS.include?(node.method_name)
-          return unless expected_signature?(node)
+
+          return unless node && node.send_type?
+          return unless persist_method?(node, CREATE_PERSIST_METHODS)
           return if persisted_referenced?(assignment)
 
-          add_offense(node, location: :selector,
-                            message: format(CREATE_MSG,
-                                            prefer: "#{node.method_name}!",
-                                            current: node.method_name.to_s))
+          add_offense_for_node(node, CREATE_MSG)
         end
 
-        def on_send(node)
-          return unless PERSIST_METHODS.include?(node.method_name)
-          return unless expected_signature?(node)
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
+          return unless persist_method?(node)
           return if return_value_assigned?(node)
           return if check_used_in_conditional(node)
-          return if last_call_of_method?(node)
+          return if argument?(node)
+          return if implicit_return?(node)
+          return if explicit_return?(node)
 
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            prefer: "#{node.method_name}!",
-                                            current: node.method_name.to_s))
+          add_offense_for_node(node)
         end
 
         def autocorrect(node)
@@ -100,10 +156,19 @@ module RuboCop
 
         private
 
+        def add_offense_for_node(node, msg = MSG)
+          name = node.method_name
+          full_message = format(msg, prefer: "#{name}!", current: name.to_s)
+
+          add_offense(node, location: :selector, message: full_message)
+        end
+
         def right_assignment_node(assignment)
           node = assignment.node.child_nodes.first
+
           return node unless node && node.block_type?
-          node.child_nodes.first
+
+          node.send_node
         end
 
         def persisted_referenced?(assignment)
@@ -118,36 +183,122 @@ module RuboCop
           node.send_type? && node.method?(:persisted?)
         end
 
+        def assignable_node(node)
+          assignable = node.block_node || node
+          while node
+            node = hash_parent(node) || array_parent(node)
+            assignable = node if node
+          end
+          assignable
+        end
+
+        def hash_parent(node)
+          pair = node.parent
+          return unless pair && pair.pair_type?
+
+          hash = pair.parent
+          return unless hash && hash.hash_type?
+
+          hash
+        end
+
+        def array_parent(node)
+          array = node.parent
+          return unless array && array.array_type?
+
+          array
+        end
+
         def check_used_in_conditional(node)
           return false unless conditional?(node)
 
           unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense(node, location: :selector,
-                              message: format(CREATE_CONDITIONAL_MSG,
-                                              method: node.method_name.to_s))
+            add_offense_for_node(node, CREATE_CONDITIONAL_MSG)
           end
 
           true
         end
 
-        def conditional?(node)
-          node.parent && (
-            node.parent.if_type? || node.parent.case_type? ||
-            node.parent.or_type? || node.parent.and_type? ||
-            single_negative?(node.parent)
+        def conditional?(node) # rubocop:disable Metrics/CyclomaticComplexity
+          node = node.block_node || node
+
+          condition = node.parent
+          return false unless condition
+
+          condition.if_type? || condition.case_type? ||
+            condition.or_type? || condition.and_type? ||
+            single_negative?(condition)
+        end
+
+        def allowed_receiver?(node)
+          return false unless node.receiver
+          return false unless cop_config['AllowedReceivers']
+
+          cop_config['AllowedReceivers'].any? do |allowed_receiver|
+            receiver_chain_matches?(node, allowed_receiver)
+          end
+        end
+
+        def receiver_chain_matches?(node, allowed_receiver)
+          allowed_receiver.split('.').reverse.all? do |receiver_part|
+            node = node.receiver
+            return false unless node
+
+            if node.variable?
+              node.node_parts.first == receiver_part.to_sym
+            elsif node.send_type?
+              node.method_name == receiver_part.to_sym
+            elsif node.const_type?
+              const_matches?(node.const_name, receiver_part)
+            end
+          end
+        end
+
+        # Const == Const
+        # ::Const == ::Const
+        # ::Const == Const
+        # Const == ::Const
+        # NameSpace::Const == Const
+        # NameSpace::Const == NameSpace::Const
+        # NameSpace::Const != ::Const
+        # Const != NameSpace::Const
+        def const_matches?(const, allowed_const)
+          parts = allowed_const.split('::').reverse.zip(
+            const.split('::').reverse
           )
+          parts.all? do |(allowed_part, const_part)|
+            allowed_part == const_part.to_s
+          end
         end
 
-        def last_call_of_method?(node)
-          node.parent && node.parent.children.size == node.sibling_index + 1
+        def implicit_return?(node)
+          return false unless cop_config['AllowImplicitReturn']
+
+          node = assignable_node(node)
+          method = node.parent
+          return unless method && (method.def_type? || method.block_type?)
+
+          method.children.size == node.sibling_index + 1
+        end
+
+        def argument?(node)
+          assignable_node(node).argument?
+        end
+
+        def explicit_return?(node)
+          ret = assignable_node(node).parent
+          ret && (ret.return_type? || ret.next_type?)
         end
 
-        # Ignore simple assignment or if condition
         def return_value_assigned?(node)
-          return false unless node.parent
-          node.parent.lvasgn_type? ||
-            (node.parent.block_type? && node.parent.parent &&
-              node.parent.parent.lvasgn_type?)
+          assignment = assignable_node(node).parent
+          assignment && assignment.lvasgn_type?
+        end
+
+        def persist_method?(node, methods = PERSIST_METHODS)
+          methods.include?(node.method_name) &&
+            expected_signature?(node) &&
+            !allowed_receiver?(node)
         end
 
         # Check argument signature as no arguments or one hash