rubocop 0.82.0 → 0.86.0

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?
 
@@ -160,7 +156,7 @@ module RuboCop
           source_buffer = node.source_range.source_buffer
           line_range = source_buffer.line_range(node.loc.end.line)
 
-          line_range.source =~ /^\s*\)\s*,/
+          /^\s*\)\s*,/.match?(line_range.source)
         end
 
         def disallowed_literal?(begin_node, node)

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)
@@ -97,13 +97,13 @@ module RuboCop
 
           return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
+          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
         end
 
         def acceptable_capital_q?(node)
           src = node.source
           src.include?(QUOTE) &&
-            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (STRING_INTERPOLATION_REGEXP.match?(src) ||
             (node.str_type? && double_quotes_required?(src)))
         end
       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)
+          pattern_source(node).scan(PATTERN) do
+            yield match_range(node.loc.begin.end, Regexp.last_match)
+          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,121 @@
+# 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/
+      #
+      #   # 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 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) || delimiter?(node, char)
+
+          if within_character_class
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          else
+            ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          end
+        end
+
+        def delimiter?(node, char)
+          delimiters = [
+            node.loc.begin.source.chars.last,
+            node.loc.end.source.chars.first
+          ]
+
+          delimiters.include?(char)
+        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
+      end
+    end
+  end
+end

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

@@ -44,6 +44,11 @@ module RuboCop
       class RedundantSelf < Cop
         MSG = 'Redundant `self` detected.'
         KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %i[alias and begin break case class def defined? do
+                      else elsif end ensure false for if in module
+                      next nil not or redo rescue retry return self
+                      super then true undef unless until when while
+                      yield __FILE__ __LINE__ __ENCODING__].freeze
 
         def self.autocorrect_incompatible_with
           [ColonMethodCall]
@@ -131,7 +136,7 @@ module RuboCop
 
         def regular_method_call?(node)
           !(node.operator_method? ||
-            keyword?(node.method_name) ||
+            KEYWORDS.include?(node.method_name) ||
             node.camel_case_method? ||
             node.setter_method? ||
             node.implicit_call?)
@@ -142,14 +147,6 @@ module RuboCop
           @local_variables_scopes[node] << name
         end
 
-        def keyword?(method_name)
-          %i[alias and begin break case class def defined? do
-             else elsif end ensure false for if in module
-             next nil not or redo rescue retry return self
-             super then true undef unless until when while
-             yield __FILE__ __LINE__ __ENCODING__].include?(method_name)
-        end
-
         def allow_self(node)
           return unless node.send_type? && node.self_receiver?
 

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

@@ -167,9 +167,7 @@ module RuboCop
           checked_variable, matching_receiver, method =
             extract_common_parts(receiver, variable)
 
-          if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
-            matching_receiver = nil
-          end
+          matching_receiver = nil if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
 
           [checked_variable, matching_receiver, receiver, method]
         end
@@ -221,9 +219,7 @@ module RuboCop
           return true if unsafe_method?(method)
 
           method.each_ancestor(:send).any? do |ancestor|
-            unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
-              break true
-            end
+            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
 
             break true if unsafe_method?(ancestor)
             break true if nil_methods.include?(ancestor.method_name)

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

@@ -92,7 +92,7 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node)
+        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
 

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

@@ -39,7 +39,7 @@ module RuboCop
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node)
+        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if cop_config['AllowAsExpressionSeparator']
 
           exprs = node.children

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that arrays are sliced with endless ranges instead of
+      # `ary[start..-1]` on Ruby 2.6+.
+      #
+      # @example
+      #   # bad
+      #   items[1..-1]
+      #
+      #   # good
+      #   items[1..]
+      class SlicingWithRange < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer ary[n..] over ary[n..-1].'
+
+        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+
+        def on_send(node)
+          return unless node.method?(:[]) && node.arguments.count == 1
+          return unless range_till_minus_one?(node.arguments.first)
+
+          add_offense(node.arguments.first)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -181,13 +181,9 @@ module RuboCop
           parent_type = node.parent&.type
           preferred_name = preferred_names(global_var).first
 
-          unless %i[dstr xstr regexp].include?(parent_type)
-            return preferred_name.to_s
-          end
+          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
 
-          if style == :use_english_names
-            return english_name_replacement(preferred_name, node)
-          end
+          return english_name_replacement(preferred_name, node) if style == :use_english_names
 
           "##{preferred_name}"
         end

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

@@ -20,6 +20,8 @@ module RuboCop
       #     end
       #   end
       class StructInheritance < Cop
+        include RangeHelp
+
         MSG = "Don't extend an instance initialized by `Struct.new`. " \
               'Use a block to customize the struct.'
 
@@ -29,10 +31,29 @@ module RuboCop
           add_offense(node, location: node.parent_class.source_range)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.keyword))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
         def_node_matcher :struct_constructor?, <<~PATTERN
           {(send (const nil? :Struct) :new ...)
            (block (send (const nil? :Struct) :new ...) ...)}
         PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+          else
+            corrector.insert_after(parent.loc.expression, ' do')
+          end
+        end
       end
     end
   end

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

@@ -65,7 +65,7 @@ module RuboCop
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
-            content =~ / /
+            / /.match?(content)
           end
         end
 
@@ -104,12 +104,12 @@ module RuboCop
           )
 
           # method name
-          string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+          /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
-            string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+            /\A@@?[a-zA-Z_]\w*\z/.match?(string) ||
             # global variable
-            string =~ /\A\$[1-9]\d*\z/ ||
-            string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+            /\A\$[1-9]\d*\z/.match?(string) ||
+            /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
             special_gvars.include?(string) ||
             redefinable_operators.include?(string)
         end