rubocop 0.74.0 → 0.78.0

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

@@ -3,11 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help upgrade to after Ruby 3.0. It will add the
-      # comment `# frozen_string_literal: true` to the top of files to
-      # enable frozen string literals. Frozen string literals may be default
-      # after Ruby 3.0. The comment will be added below a shebang and encoding
-      # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      # This cop is designed to help you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the comment `# frozen_string_literal: true` to the top of
+      # files to enable frozen string literals. Frozen string literals may be
+      # default in future Ruby. The comment will be added below a shebang and
+      # encoding comment. The frozen string literal comment is only valid in
+      # Ruby 2.3+.
+      #
+      # Note that the cop will ignore files where the comment exists but is set
+      # to `false` instead of `true`.
       #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
@@ -25,6 +30,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
       # @example EnforcedStyle: never
       #   # The `never` will enforce that the frozen string literal comment does
       #   # not exist in a file.
@@ -121,42 +133,25 @@ module RuboCop
         end
 
         def insert_comment(corrector)
-          last_special_comment = last_special_comment(processed_source)
-          if last_special_comment.nil?
-            corrector.insert_before(correction_range, preceding_comment)
-          else
-            corrector.insert_after(correction_range, proceeding_comment)
-          end
-        end
+          comment = last_special_comment(processed_source)
 
-        def preceding_comment
-          if processed_source.tokens[0].space_before?
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
           else
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n\n"
+            corrector.insert_before(line_range(1), preceding_comment)
           end
         end
 
-        def proceeding_comment
-          last_special_comment = last_special_comment(processed_source)
-          following_line = processed_source.following_line(last_special_comment)
-
-          if following_line&.empty?
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}"
-          else
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}\n"
-          end
+        def line_range(line)
+          processed_source.buffer.line_range(line)
         end
 
-        def correction_range
-          last_special_comment = last_special_comment(processed_source)
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
 
-          if last_special_comment.nil?
-            range_with_surrounding_space(range: processed_source.tokens[0],
-                                         side: :left)
-          else
-            last_special_comment.pos
-          end
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
         end
       end
     end

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

@@ -49,8 +49,9 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type? && body.children.last.if_type?
-            check_ending_if(body.children.last)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
           end
         end
         alias on_defs on_def

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

@@ -168,10 +168,10 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, pair_node)
-          key = pair_node.key
+          key = pair_node.key.source_range
           op = pair_node.loc.operator
 
-          range = range_between(key.source_range.begin_pos, op.end_pos)
+          range = key.join(op)
           range = range_with_surrounding_space(range: range, side: :right)
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for if and unless statements that would fit on one line
-      # if written as a modifier if/unless. The maximum line length is
-      # configured in the `Metrics/LineLength` cop. The tab size is configured
-      # in the `IndentationWidth` of the `Layout/Tab` cop.
+      # Checks for `if` and `unless` statements that would fit on one line if
+      # written as modifier `if`/`unless`. The cop also checks for modifier
+      # `if`/`unless` lines that exceed the maximum line length.
+      #
+      # The maximum line length is configured in the `Layout/LineLength`
+      # cop. The tab size is configured in the `IndentationWidth` of the
+      # `Layout/Tab` cop.
       #
       # @example
       #   # bad
@@ -18,35 +21,101 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
+      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
+      #
+      #   if long_condition
+      #     do_something_in_a_method_with_a_long_name(arg)
+      #   end
       class IfUnlessModifier < Cop
         include StatementModifier
+        include LineLengthHelp
+        include IgnoredPattern
 
-        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line ' \
-              'body. Another good alternative is the usage of control flow ' \
-              '`&&`/`||`.'
+        MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
+                           'single-line body. Another good alternative is ' \
+                           'the usage of control flow `&&`/`||`.'
+        MSG_USE_NORMAL =
+          'Modifier form of `%<keyword>s` makes the line too long.'
 
         ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
                               gvasgn ivasgn masgn].freeze
 
         def on_if(node)
-          return unless eligible_node?(node)
-          return if named_capture_in_condition?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
+          msg = if eligible_node?(node)
+                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
+                elsif node.modifier_form? && too_long_single_line?(node)
+                  MSG_USE_NORMAL
+                end
+          return unless msg
+
+          add_offense(node,
+                      location: :keyword,
+                      message: format(msg, keyword: node.keyword))
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, to_modifier_form(node))
-          end
+          replacement = if node.modifier_form?
+                          to_normal_form(node)
+                        else
+                          to_modifier_form(node)
+                        end
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         private
 
+        def ignored_patterns
+          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        end
+
+        def too_long_single_line?(node)
+          return false unless max_line_length
+
+          range = node.source_range
+          return false unless range.first_line == range.last_line
+          return false unless line_length_enabled_at_line?(range.first_line)
+
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_ignored_pattern?(line)
+
+          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_ignore_cop_directives?(range, line)
+          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return false if uri_range && allowed_uri_position?(line, uri_range)
+          end
+
+          true
+        end
+
+        def line_length_enabled_at_line?(line)
+          processed_source.comment_config
+                          .cop_enabled_at_line?('Layout/LineLength', line)
+        end
+
         def named_capture_in_condition?(node)
           node.condition.match_with_lvasgn_type?
         end
@@ -79,6 +148,15 @@ module RuboCop
           parenthesize?(node) ? "(#{expression})" : expression
         end
 
+        def to_normal_form(node)
+          indentation = ' ' * node.source_range.column
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
+        end
+
         def first_line_comment(node)
           comment =
             processed_source.find_comment { |c| c.loc.line == node.loc.line }

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

@@ -58,7 +58,7 @@ module RuboCop
           # `loop do` without further modification. The reason is that a
           # variable that's introduced inside a while/until loop is in scope
           # outside of that loop too, but a variable that's assigned for the
-          # first time inside a block can not be accessed after the block. In
+          # first time inside a block cannot be accessed after the block. In
           # those more complicated cases we don't report an offense.
           return if @variables.any? do |var|
             assigned_inside_loop?(var, range) &&
@@ -97,12 +97,13 @@ module RuboCop
         end
 
         def modifier_replacement(node)
+          body = node.body
           if node.single_line?
-            'loop { ' + node.body.source + ' }'
+            'loop { ' + body.source + ' }'
           else
-            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+            indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', node.body.source.gsub(/^/, configured_indent),
+            ['loop do', body.source.gsub(/^/, configured_indent),
              'end'].join("\n#{indentation}")
           end
         end
@@ -119,7 +120,7 @@ module RuboCop
         end
 
         def configured_indent
-          ' ' * config.for_cop('IndentationWidth')['Width']
+          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
         end
       end
     end

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

@@ -94,20 +94,25 @@ module RuboCop
         end
 
         def autocorrect(node)
+          if node.block_type?
+            correct_inverse_block(node)
+          elsif node.send_type?
+            correct_inverse_method(node)
+          end
+        end
+
+        def correct_inverse_method(node)
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
+          return unless method_call && method
 
-          if method_call && method
-            lambda do |corrector|
-              corrector.remove(not_to_receiver(node, method_call))
-              corrector.replace(method_call.loc.selector,
-                                inverse_methods[method].to_s)
+          lambda do |corrector|
+            corrector.remove(not_to_receiver(node, method_call))
+            corrector.replace(method_call.loc.selector,
+                              inverse_methods[method].to_s)
 
-              if EQUALITY_METHODS.include?(method)
-                corrector.remove(end_parentheses(node, method_call))
-              end
+            if EQUALITY_METHODS.include?(method)
+              corrector.remove(end_parentheses(node, method_call))
             end
-          else
-            correct_inverse_block(node)
           end
         end
 
@@ -122,18 +127,19 @@ module RuboCop
         end
 
         def correct_inverse_selector(block, corrector)
-          selector = block.loc.selector.source
+          selector_loc = block.loc.selector
+          selector = selector_loc.source
 
           if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
             selector[0] = '='
-            corrector.replace(block.loc.selector, selector)
+            corrector.replace(selector_loc, selector)
           else
             if block.loc.dot
               range = dot_range(block.loc)
               corrector.remove(range)
             end
 
-            corrector.remove(block.loc.selector)
+            corrector.remove(selector_loc)
           end
         end
 

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

@@ -28,7 +28,7 @@ module RuboCop
           contents = node.source[1...-1]
           return false if contents.empty?
 
-          return false if whitelist.include?(contents.downcase)
+          return false if allowed_addresses.include?(contents.downcase)
 
           # To try to avoid doing two regex checks on every string,
           # shortcut out if the string does not look like an IP address
@@ -47,9 +47,9 @@ module RuboCop
 
         private
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:downcase)
+        def allowed_addresses
+          allowed_addresses = cop_config['AllowedAddresses']
+          Array(allowed_addresses).map(&:downcase)
         end
 
         def could_be_ip?(str)

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

@@ -26,13 +26,14 @@ module RuboCop
               'those strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
-        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i[tSTRING_BEG tSTRING_END].freeze
+        COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
+        COMPLEX_STRING_END_TOKEN = :tSTRING_END
         HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
                                             tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
         def self.autocorrect_incompatible_with
-          [Style::UnneededInterpolation]
+          [Style::RedundantInterpolation]
         end
 
         def investigate(processed_source)
@@ -59,9 +60,7 @@ module RuboCop
         def check_token_set(index)
           predecessor, operator, successor = processed_source.tokens[index, 3]
 
-          return unless eligible_successor?(successor) &&
-                        eligible_operator?(operator) &&
-                        eligible_predecessor?(predecessor)
+          return unless eligible_token_set?(predecessor, operator, successor)
 
           return if operator.line == successor.line
 
@@ -72,6 +71,12 @@ module RuboCop
           add_offense(operator.pos, location: operator.pos)
         end
 
+        def eligible_token_set?(predecessor, operator, successor)
+          eligible_successor?(successor) &&
+            eligible_operator?(operator) &&
+            eligible_predecessor?(predecessor)
+        end
+
         def eligible_successor?(successor)
           successor && standard_string_literal?(successor)
         end
@@ -91,13 +96,12 @@ module RuboCop
 
         def token_after_last_string(successor, base_index)
           index = base_index + 3
-          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
-          if successor.type == begin_token
+          if successor.type == COMPLEX_STRING_BEGIN_TOKEN
             ends_to_find = 1
             while ends_to_find.positive?
               case processed_source.tokens[index].type
-              when begin_token then ends_to_find += 1
-              when end_token then ends_to_find -= 1
+              when COMPLEX_STRING_BEGIN_TOKEN then ends_to_find += 1
+              when COMPLEX_STRING_END_TOKEN then ends_to_find -= 1
               end
               index += 1
             end
@@ -109,7 +113,7 @@ module RuboCop
           case token.type
           when SIMPLE_STRING_TOKEN_TYPE
             true
-          when *COMPLEX_STRING_EDGE_TOKEN_TYPES
+          when COMPLEX_STRING_BEGIN_TOKEN, COMPLEX_STRING_END_TOKEN
             QUOTE_DELIMITERS.include?(token.text)
           else
             false

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # In the default style (require_parentheses), macro methods are ignored.
       # Additional methods can be added to the `IgnoredMethods`
-      # or `IgnoredMethodPatterns` list. These options are
+      # or `IgnoredPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
       # the `IncludedMacros` list.
@@ -17,7 +17,7 @@ module RuboCop
       # Precedence of options is all follows:
       #
       # 1. `IgnoredMethods`
-      # 2. `IgnoredMethodPatterns`
+      # 2. `IgnoredPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
@@ -61,23 +61,9 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # okay with `^assert` listed in `IgnoredMethodPatterns`
+      #   # okay with `^assert` listed in `IgnoredPatterns`
       #   assert_equal 'test', x
       #
-      #   # IgnoreMacros: true (default)
-      #
-      #   # good
-      #   class Foo
-      #     bar :baz
-      #   end
-      #
-      #   # IgnoreMacros: false
-      #
-      #   # bad
-      #   class Foo
-      #     bar :baz
-      #   end
-      #
       # @example EnforcedStyle: omit_parentheses
       #
       #   # bad
@@ -92,7 +78,21 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
-      #   # AllowParenthesesInMultilineCall: false (default)
+      # @example IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
       #
       #   # bad
       #   foo.enforce(
@@ -103,7 +103,7 @@ module RuboCop
       #   foo.enforce \
       #     strict: true
       #
-      #   # AllowParenthesesInMultilineCall: true
+      # @example AllowParenthesesInMultilineCall: true
       #
       #   # good
       #   foo.enforce(
@@ -114,7 +114,7 @@ module RuboCop
       #   foo.enforce \
       #     strict: true
       #
-      #   # AllowParenthesesInChaining: false (default)
+      # @example AllowParenthesesInChaining: false (default)
       #
       #   # bad
       #   foo().bar(1)
@@ -122,7 +122,7 @@ module RuboCop
       #   # good
       #   foo().bar 1
       #
-      #   # AllowParenthesesInChaining: true
+      # @example AllowParenthesesInChaining: true
       #
       #   # good
       #   foo().bar(1)
@@ -130,7 +130,7 @@ module RuboCop
       #   # good
       #   foo().bar 1
       #
-      #   # AllowParenthesesInCamelCaseMethod: false (default)
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
       #
       #   # bad
       #   Array(1)
@@ -138,7 +138,7 @@ module RuboCop
       #   # good
       #   Array 1
       #
-      #   # AllowParenthesesInCamelCaseMethod: true
+      # @example AllowParenthesesInCamelCaseMethod: true
       #
       #   # good
       #   Array(1)
@@ -148,7 +148,7 @@ module RuboCop
       class MethodCallWithArgsParentheses < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
-        include IgnoredMethodPatterns
+        include IgnoredPattern
 
         TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
 
@@ -186,7 +186,7 @@ module RuboCop
 
         def add_offense_for_require_parentheses(node)
           return if ignored_method?(node.method_name)
-          return if ignored_method_pattern?(node.method_name)
+          return if matches_ignored_pattern?(node.method_name)
           return if eligible_for_parentheses_omission?(node)
           return unless node.arguments? && !node.parenthesized?