rubocop 0.75.1 → 0.76.0

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

@@ -147,16 +147,16 @@ module RuboCop
         end
 
         def remove_braces_with_whitespace(corrector, node, space)
+          loc = node.loc
+
           if node.multiline?
             remove_braces_with_range(corrector,
-                                     left_whole_line_range(node.loc.begin),
-                                     right_whole_line_range(node.loc.end))
+                                     left_whole_line_range(loc.begin),
+                                     right_whole_line_range(loc.end))
           else
-            right_brace_and_space = right_brace_and_space(node.loc.end, space)
-            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
             remove_braces_with_range(corrector,
-                                     left_brace_and_space,
-                                     right_brace_and_space)
+                                     left_brace_and_space(loc.begin, space),
+                                     right_brace_and_space(loc.end, space))
           end
         end
 

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

@@ -49,10 +49,10 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            length = concat_length(first_word, colon, space)
             add_offense(
               comment,
-              location: annotation_range(comment, margin, length),
+              location: annotation_range(comment, margin,
+                                         first_word, colon, space),
               message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
             )
           end
@@ -62,8 +62,7 @@ module RuboCop
           margin, first_word, colon, space, note = split_comment(comment)
           return if note.nil?
 
-          length = concat_length(first_word, colon, space)
-          range = annotation_range(comment, margin, length)
+          range = annotation_range(comment, margin, first_word, colon, space)
 
           ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
@@ -79,8 +78,9 @@ module RuboCop
           !comment_line?(comment.loc.expression.source_line)
         end
 
-        def annotation_range(comment, margin, length)
+        def annotation_range(comment, margin, first_word, colon, space)
           start = comment.loc.expression.begin_pos + margin.length
+          length = concat_length(first_word, colon, space)
           range_between(start, start + length)
         end
 

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

@@ -33,13 +33,7 @@ module RuboCop
         end
 
         def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
+          verify_autocorrect_notice!
 
           lambda do |corrector|
             range = token.nil? ? range_between(0, 0) : token.pos
@@ -57,6 +51,16 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice =~ regex
+
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                         "match Notice /#{notice}/"
+        end
+
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 # rubocop:disable Style/DoubleCopDisableDirective
 
 module RuboCop
@@ -26,7 +26,7 @@ module RuboCop
       #
       class DoubleCopDisableDirective < Cop
         # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
         MSG = 'More than one disable comment on one line.'
 
         def investigate(processed_source)

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

@@ -84,8 +84,8 @@ module RuboCop
 
             next unless conditions.size > 1
 
-            range = range_between(conditions.first.loc.expression.begin_pos,
-                                  conditions.last.loc.expression.end_pos)
+            range = range_between(conditions.first.source_range.begin_pos,
+                                  conditions.last.source_range.end_pos)
 
             corrector.replace(range, conditions.map(&:source).join(' || '))
           end

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

@@ -84,8 +84,8 @@ module RuboCop
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].loc.expression.begin_pos - 1,
-                          args[-1].loc.expression.end_pos)
+            range_between(args[0].source_range.begin_pos - 1,
+                          args[-1].source_range.end_pos)
           else
             node.source_range
           end

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

@@ -73,11 +73,11 @@ module RuboCop
         end
 
         def corrected(node)
-          has_parentheses = parentheses?(node.arguments)
-
-          arguments   = node.arguments? ? node.arguments.source : ''
-          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
-          scope       = node.receiver ? "#{node.receiver.source}." : ''
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
 
           signature = [scope, node.method_name, extra_space, arguments].join
 

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

@@ -94,10 +94,12 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          args = if %i[array hash].include?(node.first_argument.type)
-                   node.first_argument.children.map(&:source).join(', ')
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
                  else
-                   node.first_argument.source
+                   percent_rhs.source
                  end
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
@@ -106,14 +108,15 @@ module RuboCop
         end
 
         def autocorrect_to_percent(corrector, node)
-          format = node.first_argument.source
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
 
-          args = if node.arguments.size == 2
-                   arg = node.arguments.last
+          args = if param_args.one?
+                   arg = param_args.last
 
                    arg.hash_type? ? "{ #{arg.source} }" : arg.source
                  else
-                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                   "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node.loc.expression, "#{format} % #{args}")

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

@@ -104,6 +104,8 @@ module RuboCop
           format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
           format_string.format_sequences.each do |seq|
+            next if seq.percent?
+
             detected_style = seq.style
             token = contents.begin.adjust(
               begin_pos: seq.begin_pos,

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

@@ -11,6 +11,9 @@ module RuboCop
       # 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
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
@@ -27,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.

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

@@ -70,8 +70,15 @@ module RuboCop
           return false unless max_line_length
 
           range = node.source_range
-          range.first_line == range.last_line &&
-            range.last_column > max_line_length
+          return false unless range.first_line == range.last_line
+          return false unless line_length_enabled_at_line?(range.first_line)
+
+          range.last_column > max_line_length
+        end
+
+        def line_length_enabled_at_line?(line)
+          processed_source.comment_config
+                          .cop_enabled_at_line?('Metrics/LineLength', line)
         end
 
         def named_capture_in_condition?(node)

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

@@ -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

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/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_def_parentheses.rb

@@ -113,22 +113,30 @@ module RuboCop
           lambda do |corrector|
             if node.args_type?
               # offense is registered on args node when parentheses are unwanted
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
+              correct_arguments(node, corrector)
             else
-              args_expr = node.arguments.source_range
-              args_with_space = range_with_surrounding_space(range: args_expr,
-                                                             side: :left)
-              just_space = range_between(args_with_space.begin_pos,
-                                         args_expr.begin_pos)
-              corrector.replace(just_space, '(')
-              corrector.insert_after(args_expr, ')')
+              correct_definition(node, corrector)
             end
           end
         end
 
         private
 
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def correct_definition(def_node, corrector)
+          arguments_range = def_node.arguments.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range,
+                                                         side: :left)
+          leading_space = range_between(args_with_space.begin_pos,
+                                        arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&

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

@@ -44,7 +44,7 @@ module RuboCop
           lambda do |corrector|
             corrector.remove(
               range_with_surrounding_space(
-                range: node.loc.begin, side: :left
+                range: node.loc.begin, side: :left, newlines: false
               )
             )
           end

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

@@ -49,11 +49,13 @@ module RuboCop
                                 node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(node.parent, node))
+            corrector.replace(range, new_expression(node))
           end
         end
 
-        def new_expression(outer_node, inner_node)
+        def new_expression(inner_node)
+          outer_node = inner_node.parent
+
           operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
           rh_operand = right_hand_operand(inner_node, outer_node.keyword)