rubocop 0.84.0 → 0.85.1

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of `each_key` and `each_value` Hash methods.
       #
-      # Note: If you have an array of two-element arrays, you can put
+      # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #

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

@@ -13,11 +13,11 @@ module RuboCop
       # The supported styles are:
       #
       # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
-      #   all symbols for keys
+      # all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
-      #   syntax hashes
+      # syntax hashes
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -178,7 +178,9 @@ module RuboCop
           )
 
           hash_node = pair_node.parent
-          corrector.wrap(hash_node, '{', '}') if hash_node.parent&.return_type? && !hash_node.braces?
+          return unless hash_node.parent&.return_type? && !hash_node.braces?
+
+          corrector.wrap(hash_node, '{', '}')
         end
 
         def range_for_autocorrect_ruby19(pair_node)

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

@@ -23,7 +23,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
 
             add_offense(comment)
           end

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

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def keyword_end_str(node, node_buf)
-          if /[^\s\)]/.match?(node_buf.source_line(node.loc.end.line))
+          if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
             "\n" + (' ' * node.loc.column) + 'end'
           else
             'end'

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks for uses of if with a negated condition. Only ifs
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
       # @example EnforcedStyle: both (default)
       #   # enforces `unless` for `prefix` and `postfix` conditionals

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks for uses of unless with a negated condition. Only unless
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
       # @example EnforcedStyle: both (default)
       #   # enforces `if` for `prefix` and `postfix` conditionals

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
       # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
-      # is **usually** OK, but might change behavior.
+      # is *usually* OK, but might change behavior.
       #
       # @example
       #   # bad

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`.'
@@ -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_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)

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

@@ -106,7 +106,7 @@ module RuboCop
           # method name
           string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
             # instance / class variable
-            string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+            string =~ /\A@@?[a-zA-Z_]\w*\z/ ||
             # global variable
             string =~ /\A\$[1-9]\d*\z/ ||
             string =~ /\A\$[a-zA-Z_]\w*\z/ ||

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in argument lists.
       # The supported styles are:
       #
-      # - `consistent_comma`: Requires a comma after the last argument,
+      # * `consistent_comma`: Requires a comma after the last argument,
       # for all parenthesized method calls with arguments.
-      # - `comma`: Requires a comma after the last argument, but only for
+      # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
-      # - `no_comma`: Requires that there is no comma after the last
+      # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # - `consistent_comma`: Requires a comma after the
+      # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline array literals.
-      # - `comma`: Requires a comma after last item in an array,
+      # * `comma`: Requires a comma after last item in an array,
       # but only when each item is on its own line.
-      # - `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not requires a comma after the
       # last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -12,7 +12,7 @@ module RuboCop
       #   # bad
       #   add { |foo, bar,| foo + bar }
       #
-      #    # good
+      #   # good
       #   add { |foo, bar| foo + bar }
       #
       #   # good
@@ -22,24 +22,24 @@ module RuboCop
       #   add { foo }
       #
       #   # bad
-      #  add do |foo, bar,|
-      #    foo + bar
+      #   add do |foo, bar,|
+      #     foo + bar
       #   end
       #
-      #  # good
-      #  add do |foo, bar|
-      #    foo + bar
-      #  end
+      #   # good
+      #   add do |foo, bar|
+      #     foo + bar
+      #   end
       #
-      #  # good
+      #   # good
       #   add do |foo,|
-      #    foo
-      #  end
+      #     foo
+      #   end
       #
-      #  # good
-      #  add do
+      #   # good
+      #   add do
       #     foo + bar
-      #  end
+      #   end
       class TrailingCommaInBlockArgs < Cop
         MSG = 'Useless trailing comma present in block arguments.'
 

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # - `consistent_comma`: Requires a comma after the
+      # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline hash literals.
-      # - `comma`: Requires a comma after the last item in a hash,
+      # * `comma`: Requires a comma after the last item in a hash,
       # but only when each item is on its own line.
-      # - `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not requires a comma after the
       # last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma