rubocop 0.81.0 → 0.85.1

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

@@ -24,10 +24,10 @@ module RuboCop
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
             if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 "{Regexp.last_match(#{backref})}")
             else
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 "Regexp.last_match(#{backref})")
             end
           end

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

@@ -26,7 +26,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, 'proc') }
+          ->(corrector) { corrector.replace(node, 'proc') }
         end
       end
     end

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

@@ -58,7 +58,7 @@ module RuboCop
                           correction_compact_to_exploded(node)
                         end
 
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         private

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

@@ -66,13 +66,13 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             if integer_op_rand?(node)
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 corrected_integer_op_rand(node))
             elsif rand_op_integer?(node)
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 corrected_rand_op_integer(node))
             elsif rand_modified?(node)
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 corrected_rand_modified(node))
             end
           end

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

@@ -48,11 +48,11 @@ module RuboCop
             if node.ternary?
               correct_ternary(corrector, node)
             elsif node.modifier_form? || !node.else_branch
-              corrector.replace(node.source_range, node.if_branch.source)
+              corrector.replace(node, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
 
-              corrector.replace(node.source_range, corrected)
+              corrector.replace(node, corrected)
             end
           end
         end
@@ -116,8 +116,7 @@ module RuboCop
 
           return unless node.else_branch.range_type?
 
-          corrector.insert_before(node.else_branch.loc.expression, '(')
-          corrector.insert_after(node.else_branch.loc.expression, ')')
+          corrector.wrap(node.else_branch, '(', ')')
         end
       end
     end

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

@@ -27,7 +27,8 @@ module RuboCop
       class RedundantConditional < Cop
         include Alignment
 
-        COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
+        operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
+        COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
 
         MSG = 'This conditional expression can just be replaced ' \
               'by `%<msg>s`.'
@@ -40,7 +41,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement_condition(node))
+            corrector.replace(node, replacement_condition(node))
           end
         end
 
@@ -54,11 +55,11 @@ module RuboCop
         end
 
         def_node_matcher :redundant_condition?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
         RUBY
 
         def_node_matcher :redundant_condition_inverted?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) false true)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
         RUBY
 
         def offense?(node)

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

@@ -32,17 +32,17 @@ module RuboCop
           exploded?(node) do |command, message|
             return lambda do |corrector|
               if node.parenthesized?
-                corrector.replace(node.source_range,
+                corrector.replace(node,
                                   "#{command}(#{message.source})")
               else
-                corrector.replace(node.source_range,
+                corrector.replace(node,
                                   "#{command} #{message.source}")
               end
             end
           end
           compact?(node) do |new_call, message|
             lambda do |corrector|
-              corrector.replace(new_call.source_range, message.source)
+              corrector.replace(new_call, message.source)
             end
           end
         end

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

@@ -72,13 +72,13 @@ module RuboCop
 
         def autocorrect_variable_interpolation(embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         def autocorrect_single_variable_interpolation(embedded_node, node)
           variable_loc = embedded_node.children.first.loc
           replacement = "#{variable_loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         def autocorrect_other(embedded_node, node)

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

@@ -93,12 +93,8 @@ module RuboCop
 
         def check(begin_node)
           node = begin_node.children.first
-          if keyword_with_redundant_parentheses?(node)
-            return offense(begin_node, 'a keyword')
-          end
-          if disallowed_literal?(begin_node, node)
-            return offense(begin_node, 'a literal')
-          end
+          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
+          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
 

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

@@ -27,7 +27,7 @@ module RuboCop
         EMPTY = ''
         PERCENT_Q = '%q'
         PERCENT_CAPITAL_Q = '%Q'
-        STRING_INTERPOLATION_REGEXP = /#\{.+}/.freeze
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
         ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
 
         def on_dstr(node)
@@ -47,7 +47,7 @@ module RuboCop
 
         def autocorrect(node)
           delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+            /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
           lambda do |corrector|
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)
@@ -95,7 +95,7 @@ module RuboCop
         def acceptable_q?(node)
           src = node.source
 
-          return true if src =~ STRING_INTERPOLATION_REGEXP
+          return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
           src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
         end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unnecessary single-element Regexp character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[x]/
+      #
+      #   # good
+      #   r = /x/
+      #
+      #   # bad
+      #   r = /[\s]/
+      #
+      #   # good
+      #   r = /\s/
+      #
+      #   # good
+      #   r = /[ab]/
+      class RedundantRegexpCharacterClass < Cop
+        include MatchRange
+        include RegexpLiteralHelp
+
+        MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
+        '`%<char_class>s` can be replaced with `%<element>s`.'
+
+        PATTERN = /
+          (
+            (?<!\\)           # No \-prefix (i.e. not escaped)
+            \[                # Literal [
+            (?!\#\{)          # Not (the start of) an interpolation
+            (?:               # Either...
+             \\. |            # Any escaped character
+             [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
+             \\[upP]\{[^}]+\} # or a unicode code-point or property
+            )
+            \]                # Literal ]
+          )
+        /x.freeze
+
+        def on_regexp(node)
+          each_redundant_character_class(node) do |loc|
+            next if whitespace_in_free_space_mode?(node, loc)
+
+            add_offense(
+              node,
+              location: loc,
+              message: format(
+                MSG_REDUNDANT_CHARACTER_CLASS,
+                char_class: loc.source,
+                element: without_character_class(loc)
+              )
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_redundant_character_class(node) do |loc|
+              corrector.replace(loc, without_character_class(loc))
+            end
+          end
+        end
+
+        def each_redundant_character_class(node)
+          each_match_range(node.loc.expression, PATTERN) do |loc|
+            yield loc
+          end
+        end
+
+        private
+
+        def without_character_class(loc)
+          loc.source[1..-2]
+        end
+
+        def whitespace_in_free_space_mode?(node, loc)
+          return false unless freespace_mode_regexp?(node)
+
+          /\[\s\]/.match?(loc.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant escapes inside Regexp literals.
+      #
+      # @example
+      #   # bad
+      #   %r{foo\/bar}
+      #
+      #   # good
+      #   %r{foo/bar}
+      #
+      #   # good
+      #   /foo\/bar/
+      #
+      #   # good
+      #   %r/foo\/bar/
+      #
+      #   # bad
+      #   /a\-b/
+      #
+      #   # good
+      #   /a-b/
+      #
+      #   # bad
+      #   /[\+\-]\d/
+      #
+      #   # good
+      #   /[+\-]\d/
+      class RedundantRegexpEscape < Cop
+        include RangeHelp
+        include RegexpLiteralHelp
+
+        MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
+
+        ALLOWED_ALWAYS_ESCAPES = ' []^\\#'.chars.freeze
+        ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
+        ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+
+        def on_regexp(node)
+          each_escape(node) do |char, index, within_character_class|
+            next if allowed_escape?(node, char, within_character_class)
+
+            add_offense(
+              node,
+              location: escape_range_at_index(node, index),
+              message: MSG_REDUNDANT_ESCAPE
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_escape(node) do |char, index, within_character_class|
+              next if allowed_escape?(node, char, within_character_class)
+
+              corrector.remove_leading(escape_range_at_index(node, index), 1)
+            end
+          end
+        end
+
+        private
+
+        def slash_literal?(node)
+          ['/', '%r/'].include?(node.loc.begin.source)
+        end
+
+        def allowed_escape?(node, char, within_character_class)
+          # Strictly speaking a few single-letter metachars are currently
+          # unnecessary to "escape", e.g. g, i, E, F, but enumerating them is
+          # rather difficult, and their behaviour could change over time with
+          # different versions of Ruby so that e.g. /\g/ != /g/
+          return true if /[[:alnum:]]/.match?(char)
+          return true if ALLOWED_ALWAYS_ESCAPES.include?(char)
+
+          if char == '/'
+            slash_literal?(node)
+          elsif within_character_class
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          else
+            ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          end
+        end
+
+        def each_escape(node)
+          pattern_source(node).each_char.with_index.reduce(
+            [nil, false]
+          ) do |(previous, within_character_class), (current, index)|
+            if previous == '\\'
+              yield [current, index - 1, within_character_class]
+
+              [nil, within_character_class]
+            elsif previous == '[' && current != ':'
+              [current, true]
+            elsif previous != ':' && current == ']'
+              [current, false]
+            else
+              [current, within_character_class]
+            end
+          end
+        end
+
+        def escape_range_at_index(node, index)
+          regexp_begin = node.loc.begin.end_pos
+
+          start = regexp_begin + index
+
+          range_between(start, start + 2)
+        end
+
+        def pattern_source(node)
+          freespace_mode = freespace_mode_regexp?(node)
+
+          node.children.reject(&:regopt_type?).map do |child|
+            source = child.source
+
+            if freespace_mode
+              # Remove comments to avoid misleading results
+              source.sub(/(?<!\\)#.*/, '')
+            else
+              source
+            end
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -71,7 +71,7 @@ module RuboCop
         private
 
         def correct_without_arguments(return_node, corrector)
-          corrector.replace(return_node.source_range, 'nil')
+          corrector.replace(return_node, 'nil')
         end
 
         def correct_with_arguments(return_node, corrector)
@@ -91,15 +91,13 @@ module RuboCop
         end
 
         def add_brackets(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '[')
-          corrector.insert_after(kids.last, ']')
+          corrector.insert_before(node.children.first, '[')
+          corrector.insert_after(node.children.last, ']')
         end
 
         def add_braces(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '{')
-          corrector.insert_after(kids.last, '}')
+          corrector.insert_before(node.children.first, '{')
+          corrector.insert_after(node.children.last, '}')
         end
 
         # rubocop:disable Metrics/CyclomaticComplexity

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

@@ -110,7 +110,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
+            corrector.remove(node.receiver)
             corrector.remove(node.loc.dot)
           end
         end