rubocop 0.48.1 → 1.16.0

data/lib/rubocop/cop/style/{unneeded_percent_q.rb → redundant_percent_q.rb}

@@ -4,20 +4,36 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
-      class UnneededPercentQ < Cop
-        MSG = 'Use `%s` only for strings that contain both single quotes and ' \
-              'double quotes%s.'.freeze
-        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'.freeze
-        SINGLE_QUOTE = "'".freeze
-        QUOTE = '"'.freeze
-        EMPTY = ''.freeze
-        PERCENT_Q = '%q'.freeze
-        PERCENT_CAPITAL_Q = '%Q'.freeze
-        STRING_INTERPOLATION_REGEXP = /#\{.+}/
-        ESCAPED_NON_BACKSLASH = /\\[^\\]/
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
+      class RedundantPercentQ < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+        SINGLE_QUOTE = "'"
+        QUOTE = '"'
+        EMPTY = ''
+        PERCENT_Q = '%q'
+        PERCENT_CAPITAL_Q = '%Q'
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
 
         def on_dstr(node)
+          return unless string_literal?(node)
+
           check(node)
         end
 
@@ -26,6 +42,7 @@ module RuboCop
           # will call `on_dstr` for the entire string and `on_str` for the
           # non interpolated portion of the string
           return unless string_literal?(node)
+
           check(node)
         end
 
@@ -35,7 +52,12 @@ module RuboCop
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node, :expression)
+          add_offense(node) do |corrector|
+            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
         end
 
         def interpolated_quotes?(node)
@@ -55,16 +77,7 @@ module RuboCop
                   else
                     EMPTY
                   end
-          format(MSG, src[0, 2], extra)
-        end
-
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
+          format(MSG, q_type: src[0, 2], extra: extra)
         end
 
         def string_literal?(node)
@@ -79,15 +92,15 @@ 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 }
+          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,104 @@
+# 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/
+      #
+      #   # bad
+      #   r = %r{/[b]}
+      #
+      #   # good
+      #   r = %r{/b}
+      #
+      #   # good
+      #   r = /[ab]/
+      class RedundantRegexpCharacterClass < Base
+        extend AutoCorrector
+
+        REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
+        MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
+        '`%<char_class>s` can be replaced with `%<element>s`.'
+
+        def on_regexp(node)
+          each_redundant_character_class(node) do |loc|
+            add_offense(
+              loc, message: format(
+                MSG_REDUNDANT_CHARACTER_CLASS,
+                char_class: loc.source,
+                element: without_character_class(loc)
+              )
+            ) do |corrector|
+              corrector.replace(loc, without_character_class(loc))
+            end
+          end
+        end
+
+        private
+
+        def each_redundant_character_class(node)
+          each_single_element_character_class(node) do |char_class|
+            next unless redundant_single_element_character_class?(node, char_class)
+
+            yield char_class.loc.body
+          end
+        end
+
+        def each_single_element_character_class(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.expressions.size != 1
+            next if expr.negative?
+            next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+
+            yield expr
+          end
+        end
+
+        def redundant_single_element_character_class?(node, char_class)
+          class_elem = char_class.expressions.first.text
+
+          non_redundant =
+            whitespace_in_free_space_mode?(node, class_elem) ||
+            backslash_b?(class_elem) ||
+            requires_escape_outside_char_class?(class_elem)
+
+          !non_redundant
+        end
+
+        def without_character_class(loc)
+          loc.source[1..-2]
+        end
+
+        def whitespace_in_free_space_mode?(node, elem)
+          return false unless node.extended?
+
+          /\s/.match?(elem)
+        end
+
+        def backslash_b?(elem)
+          # \b's behaviour is different inside and outside of a character class, matching word
+          # boundaries outside but backspace (0x08) when inside.
+          elem == '\b'
+        end
+
+        def requires_escape_outside_char_class?(elem)
+          REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
+
+        ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".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)
+
+            location = escape_range_at_index(node, index)
+
+            add_offense(location, message: MSG_REDUNDANT_ESCAPE) do |corrector|
+              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. 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. /\i/ != /i/
+          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[-1], node.loc.end.source[0]]
+
+          delimiters.include?(char)
+        end
+
+        if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
+          def each_escape(node)
+            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+              yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+              if expr.type == :set
+                char_class_depth + (event == :enter ? 1 : -1)
+              else
+                char_class_depth
+              end
+            end
+          end
+        # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
+        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        else
+          def each_escape(node)
+            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+              yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
+
+              if expr.type == :set
+                char_class_depth + (event == :enter ? 1 : -1)
+              else
+                char_class_depth
+              end
+            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_return.rb

@@ -6,11 +6,15 @@ module RuboCop
       # This cop checks for redundant `return` expressions.
       #
       # @example
+      #   # These bad cases should be extended to handle methods whose body is
+      #   # if/else or a case expression with a default branch.
       #
+      #   # bad
       #   def test
       #     return something
       #   end
       #
+      #   # bad
       #   def test
       #     one
       #     two
@@ -18,102 +22,148 @@ module RuboCop
       #     return something
       #   end
       #
-      # It should be extended to handle methods whose body is if/else
-      # or a case expression with a default branch.
-      class RedundantReturn < Cop
-        include OnMethodDef
+      #   # good
+      #   def test
+      #     return something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #     elsif y
+      #     else
+      #     end
+      #   end
+      #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
+      class RedundantReturn < Base
+        include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Redundant `return` detected.'.freeze
+        MSG = 'Redundant `return` detected.'
+        MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+
+        def on_def(node)
+          check_branch(node.body)
+        end
+        alias on_defs on_def
 
         private
 
-        def autocorrect(node)
-          lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
-            end
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node, 'nil')
+        end
 
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
-            end
-            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
-            corrector.remove(return_kw)
+        def correct_with_arguments(return_node, corrector)
+          if return_node.children.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
           end
-        end
 
-        def add_brackets(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '[')
-          corrector.insert_after(kids.last, ']')
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword, side: :right)
+          corrector.remove(keyword)
         end
 
-        def add_braces(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '{')
-          corrector.insert_after(kids.last, '}')
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
+        def add_brackets(corrector, node)
+          corrector.insert_before(node.children.first, '[')
+          corrector.insert_after(node.children.last, ']')
         end
 
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          check_branch(body)
+        def add_braces(corrector, node)
+          corrector.insert_before(node.children.first, '{')
+          corrector.insert_after(node.children.last, '}')
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
+          return unless node
+
           case node.type
           when :return then check_return_node(node)
-          when :case then check_case_node(node)
-          when :if then check_if_node(node)
-          when :begin then check_begin_node(node)
+          when :case   then check_case_node(node)
+          when :if     then check_if_node(node)
+          when :rescue then check_rescue_node(node)
+          when :resbody then check_resbody_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
+          return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1
 
-          add_offense(node, :keyword)
+          add_offense(node.loc.keyword, message: message(node)) do |corrector|
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
+            end
+          end
         end
 
         def check_case_node(node)
-          _cond, *when_nodes, else_node = *node
-          when_nodes.each { |when_node| check_when_node(when_node) }
-          check_branch(else_node) if else_node
-        end
-
-        def check_when_node(node)
-          return unless node
-          _cond, body = *node
-          check_branch(body) if body
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
         end
 
         def check_if_node(node)
           return if node.modifier_form? || node.ternary?
 
-          _cond, if_node, else_node = *node.node_parts
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.branches.each { |branch| check_branch(branch) }
+          check_branch(node.body) unless node.else?
+        end
+
+        def check_resbody_node(node)
+          check_branch(node.body)
+        end
 
-          check_branch(if_node) if if_node
-          check_branch(else_node) if else_node
+        def check_ensure_node(node)
+          rescue_node = node.node_parts[0]
+          check_branch(rescue_node)
         end
 
         def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
+          last_expr = node.children.last
+          check_branch(last_expr)
+        end
 
-          return unless last_expr && last_expr.return_type?
+        def allow_multiple_return_values?
+          cop_config['AllowMultipleReturnValues'] || false
+        end
 
-          check_return_node(last_expr)
+        def message(node)
+          if !allow_multiple_return_values? && node.children.size > 1
+            "#{MSG} #{MULTI_RETURN_MSG}"
+          else
+            MSG
+          end
         end
       end
     end