rubocop 1.19.0 → 1.23.0

data/lib/rubocop/cop/style/empty_method.rb

@@ -9,7 +9,7 @@ module RuboCop
       # to go on its own line (expanded style).
       #
       # NOTE: A method definition is not considered empty if it contains
-      #       comments.
+      # comments.
       #
       # @example EnforcedStyle: compact (default)
       #   # bad
@@ -62,7 +62,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) || expanded_style? && expanded?(node)
+          (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
         def corrected(node)

data/lib/rubocop/cop/style/encoding.rb

@@ -13,38 +13,49 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        MSG = 'Unnecessary utf-8 encoding comment.'
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
         SHEBANG = '#!'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          line_number = encoding_line_number(processed_source)
-          return unless (@message = offense(processed_source, line_number))
+          comments.each do |line_number, comment|
+            next unless offense?(comment)
 
-          range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, message: @message) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: range, side: :right))
+            register_offense(line_number, comment)
           end
         end
 
         private
 
-        def offense(processed_source, line_number)
-          line = processed_source[line_number]
+        def comments
+          processed_source.lines.each.with_index.with_object({}) do |(line, line_number), comments|
+            next if line.start_with?(SHEBANG)
 
-          MSG_UNNECESSARY if encoding_omitable?(line)
+            comment = MagicComment.parse(line)
+            return comments unless comment.valid?
+
+            comments[line_number + 1] = comment
+          end
         end
 
-        def encoding_omitable?(line)
-          ENCODING_PATTERN.match?(line)
+        def offense?(comment)
+          comment.encoding_specified? && comment.encoding.casecmp('utf-8').zero?
         end
 
-        def encoding_line_number(processed_source)
-          line_number = 0
-          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
-          line_number
+        def register_offense(line_number, comment)
+          range = processed_source.buffer.line_range(line_number)
+
+          add_offense(range) do |corrector|
+            text = comment.without(:encoding)
+
+            if text.blank?
+              corrector.remove(range_with_surrounding_space(range: range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
         end
       end
     end

data/lib/rubocop/cop/style/explicit_block_argument.rb

@@ -67,17 +67,27 @@ module RuboCop
             # so this can cause crashes in haml_lint
             return unless def_node
 
+            block_name = extract_block_name(def_node)
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
-              add_block_argument(send_node, corrector)
-              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+              add_block_argument(send_node, corrector, block_name)
+              add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
             end
           end
         end
 
         private
 
+        def extract_block_name(def_node)
+          if def_node.block_argument?
+            def_node.arguments.last.name
+          else
+            'block'
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -91,15 +101,15 @@ module RuboCop
           end
         end
 
-        def add_block_argument(node, corrector)
+        def add_block_argument(node, corrector, block_name)
           if node.arguments?
-            insert_argument(node, corrector)
+            insert_argument(node, corrector, block_name)
           elsif empty_arguments?(node)
-            corrector.replace(node.arguments, '(&block)')
+            corrector.replace(node.arguments, "(&#{block_name})")
           elsif call_like?(node)
-            correct_call_node(node, corrector)
+            correct_call_node(node, corrector, block_name)
           else
-            corrector.insert_after(node.loc.name, '(&block)')
+            corrector.insert_after(node.loc.name, "(&#{block_name})")
           end
         end
 
@@ -112,16 +122,16 @@ module RuboCop
           node.call_type? || node.zsuper_type? || node.super_type?
         end
 
-        def insert_argument(node, corrector)
+        def insert_argument(node, corrector, block_name)
           last_arg = node.arguments.last
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-          replacement = ' &block'
+          replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
         end
 
-        def correct_call_node(node, corrector)
-          corrector.insert_after(node, '(&block)')
+        def correct_call_node(node, corrector, block_name)
+          corrector.insert_after(node, "(&#{block_name})")
           return unless node.parenthesized?
 
           args_begin = Util.args_begin(node)

data/lib/rubocop/cop/style/float_division.rb

@@ -7,8 +7,16 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
-      # This cop is marked as unsafe, because if operand variable is a string object
-      # then `.to_f` will be removed and an error will occur.
+      # @safety
+      #   This cop is unsafe, because if the operand variable is a string object
+      #   then `.to_f` will be removed and an error will occur.
+      #
+      #   [source,ruby]
+      #   ----
+      #   a = '1.2'
+      #   b = '3.4'
+      #   a.to_f / b.to_f # Both `to_f` calls are required here
+      #   ----
       #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad

data/lib/rubocop/cop/style/format_string_token.rb

@@ -102,7 +102,8 @@ module RuboCop
         end
 
         def use_ignored_method?(node)
-          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+          send_parent = node.each_ancestor(:send).first
+          send_parent && ignored_method?(send_parent.method_name)
         end
 
         def unannotated_format?(node, detected_style)

data/lib/rubocop/cop/style/frozen_string_literal_comment.rb

@@ -10,12 +10,17 @@ module RuboCop
       # default in future Ruby. The comment will be added below a shebang and
       # encoding comment.
       #
-      # Note that the cop will ignore files where the comment exists but is set
+      # Note that the cop will accept files where the comment exists but is set
       # to `false` instead of `true`.
       #
       # To require a blank line after this comment, please see
       # `Layout/EmptyLineAfterMagicComment` cop.
       #
+      # @safety
+      #  This cop's autocorrection is unsafe since any strings mutations will
+      #  change from being accepted to raising `FrozenError`, as all strings
+      #  will become frozen by default, and will need to be manually refactored.
+      #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
@@ -141,7 +146,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.find_token do |token|
-            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+            token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end
 

data/lib/rubocop/cop/style/global_std_stream.rb

@@ -8,6 +8,10 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # @safety
+      #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
+      #   objects, for example.
+      #
       # @example
       #   # bad
       #   STDOUT.puts('hello')

data/lib/rubocop/cop/style/hash_as_last_array_item.rb

@@ -29,6 +29,7 @@ module RuboCop
       #   # good
       #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
+        include RangeHelp
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -74,6 +75,7 @@ module RuboCop
           return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -82,6 +84,15 @@ module RuboCop
         def braces_style?
           style == :braces
         end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            range: node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
       end
     end
   end

data/lib/rubocop/cop/style/hash_each_methods.rb

@@ -9,6 +9,11 @@ module RuboCop
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash`. The `AllowedReceivers` configuration can mitigate,
+      #   but not fully resolve, this safety issue.
+      #
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }

data/lib/rubocop/cop/style/hash_except.rb

@@ -49,7 +49,7 @@ module RuboCop
           return unless bad_method?(block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
-          return unless safe_to_register_offense?(block, except_key)
+          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
           preferred_method = "except(#{except_key.source})"
@@ -81,10 +81,11 @@ module RuboCop
         end
 
         def except_key(node)
-          key_argument = node.argument_list.first
+          key_argument = node.argument_list.first.source
           lhs, _method_name, rhs = *node.body
+          return if [lhs, rhs].map(&:source).none?(key_argument)
 
-          [lhs, rhs].find { |operand| operand.source != key_argument.source }
+          [lhs, rhs].find { |operand| operand.source != key_argument }
         end
 
         def offense_range(node)

data/lib/rubocop/cop/style/hash_transform_keys.rb

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.5 or newer
-      # (`transform_keys` was added in Ruby 2.5.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/hash_transform_values.rb

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.4 or newer
-      # (`transform_values` was added in Ruby 2.4.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/identical_conditional_branches.rb

@@ -7,26 +7,28 @@ module RuboCop
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
-      # This cop is marked unsafe auto-correction as the order of method invocations
-      # must be guaranteed in the following case:
-      #
-      # [source,ruby]
-      # ----
-      # if method_that_modifies_global_state # 1
-      #   method_that_relies_on_global_state # 2
-      #   foo                                # 3
-      # else
-      #   method_that_relies_on_global_state # 2
-      #   bar                                # 3
-      # end
-      # ----
-      #
-      # In such a case, auto-correction may change the invocation order.
-      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
       #
+      # @safety
+      #   Auto-correction is unsafe because changing the order of method invocations
+      #   may change the behaviour of the code. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   if method_that_modifies_global_state # 1
+      #     method_that_relies_on_global_state # 2
+      #     foo                                # 3
+      #   else
+      #     method_that_relies_on_global_state # 2
+      #     bar                                # 3
+      #   end
+      #   ----
+      #
+      #   In this example, `method_that_relies_on_global_state` will be moved before
+      #   `method_that_modifies_global_state`, which changes the behaviour of the program.
+      #
       # @example
       #   # bad
       #   if condition

data/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb

@@ -6,8 +6,10 @@ module RuboCop
       # This cop checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
-      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
-      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @safety
+      #   Auto-correction is unsafe because there is no guarantee that all predicate methods
+      #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
       #
       # @example
       #   # bad
@@ -23,6 +25,17 @@ module RuboCop
       #   # good
       #   foo == bar
       #
+      # @example
+      #   # bad
+      #   if foo.do_something?
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good (but potentially an unsafe correction)
+      #   foo.do_something?
+      #
       # @example AllowedMethods: ['nonzero?']
       #   # good
       #   num.nonzero? ? true : false
@@ -109,12 +122,13 @@ module RuboCop
         end
 
         def opposite_condition?(node)
-          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+          (!node.unless? && node.if_branch.false_type?) ||
+            (node.unless? && node.if_branch.true_type?)
         end
 
         def require_parentheses?(condition)
           condition.and_type? || condition.or_type? ||
-            condition.send_type? && condition.comparison_method?
+            (condition.send_type? && condition.comparison_method?)
         end
       end
     end

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -5,9 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
-      # This cop is marked as unsafe as the rule does not necessarily
-      # apply if the body might raise a `StopIteration` exception; contrary to
-      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      # @safety
+      #   This cop is unsafe as the rule should not necessarily apply if the loop
+      #   body might raise a `StopIteration` exception; contrary to other infinite
+      #   loops, `Kernel#loop` silently rescues that and returns `nil`.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/inverse_methods.rb

@@ -5,11 +5,18 @@ module RuboCop
     module Style
       # This cop check for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
+      #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
-      # in `InverseMethods`
+      # in `InverseMethods`.
+      #
       # Methods that are inverted by inverting the return
       # of the block that is passed to the method should be defined in
-      # `InverseBlocks`
+      # `InverseBlocks`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/lambda_call.rb

@@ -52,7 +52,7 @@ module RuboCop
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
+          (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
         def message(_node)

data/lib/rubocop/cop/style/line_end_concatenation.rb

@@ -6,6 +6,19 @@ module RuboCop
       # This cop checks for string literal concatenation at
       # the end of a line.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the
+      #   receiver is a string, in which case replacing `<<` with `\`
+      #   would result in a syntax error.
+      #
+      #   For example, this would be a false positive:
+      #   [source,ruby]
+      #   ----
+      #   array << 'foo' <<
+      #            'bar' <<
+      #            'baz'
+      #   ----
+      #
       # @example
       #
       #   # bad
@@ -46,7 +59,7 @@ module RuboCop
 
           return unless eligible_token_set?(predecessor, operator, successor)
 
-          return if operator.line == successor.line
+          return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
 

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -93,8 +93,8 @@ module RuboCop
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
             parent &&
               (logical_operator?(parent) ||
-              parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) }))
           end
 
           def call_in_optional_arguments?(node)
@@ -122,14 +122,14 @@ module RuboCop
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
               node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
             end
           end
 
@@ -171,8 +171,8 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            node.numeric_type? && node.sign? ||
-              node.parent&.send_type? && node.parent&.unary_operation?
+            (node.numeric_type? && node.sign?) ||
+              (node.parent&.send_type? && node.parent&.unary_operation?)
           end
 
           def assigned_before?(node, target)

data/lib/rubocop/cop/style/module_function.rb

@@ -6,7 +6,14 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self, forbidden.
+      # Supported styles are: module_function, extend_self, forbidden. `forbidden`
+      # style prohibits the usage of both styles.
+      #
+      # NOTE: the cop won't be activated when the module contains any private methods.
+      #
+      # @safety
+      #   Autocorrection is unsafe (and is disabled by default) because `extend self`
+      #   and `module_function` do not behave exactly the same.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -21,9 +28,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # In case there are private methods, the cop won't be activated.
-      # Otherwise, it forces to change the flow of the default code.
-      #
       # @example EnforcedStyle: module_function (default)
       #   # good
       #   module Test
@@ -46,8 +50,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # The option `forbidden` prohibits the usage of both styles.
-      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   module Test
@@ -68,9 +70,6 @@ module RuboCop
       #     private
       #     # ...
       #   end
-      #
-      # These offenses are not safe to auto-correct since there are different
-      # implications to each approach.
       class ModuleFunction < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

data/lib/rubocop/cop/style/multiline_in_pattern_then.rb

@@ -54,7 +54,7 @@ module RuboCop
           return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
           return false unless in_pattern_node.body
 
-          in_pattern_node.loc.line == in_pattern_node.body.loc.line
+          same_line?(in_pattern_node, in_pattern_node.body)
         end
       end
     end

data/lib/rubocop/cop/style/multiline_when_then.rb

@@ -54,7 +54,7 @@ module RuboCop
           end
           return false unless when_node.body
 
-          when_node.loc.line == when_node.body.loc.line
+          same_line?(when_node, when_node.body)
         end
 
         def accept_node_type?(node)