rubocop 0.51.0 → 0.87.0

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

@@ -5,34 +5,88 @@ module RuboCop
     module Style
       # This cop enforces using // or %r around regular expressions.
       #
-      # @example
-      #   # Good if EnforcedStyle is slashes or mixed, bad if percent_r.
+      # @example EnforcedStyle: slashes (default)
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      # @example EnforcedStyle: percent_r
+      #   # bad
       #   snake_case = /^[\dA-Z_]+$/
       #
-      #   # Good if EnforcedStyle is percent_r, bad if slashes or mixed.
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   snake_case = %r{^[\dA-Z_]+$}
       #
-      #   # Good if EnforcedStyle is slashes, bad if percent_r or mixed.
+      #   # bad
       #   regex = /
       #     foo
       #     (bar)
       #     (baz)
       #   /x
       #
-      #   # Good if EnforcedStyle is percent_r or mixed, bad if slashes.
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
       #   regex = %r{
       #     foo
       #     (bar)
       #     (baz)
       #   }x
       #
-      #   # Bad unless AllowInnerSlashes is true.
+      # @example AllowInnerSlashes: false (default)
+      #   # If `false`, the cop will always recommend using `%r` if one or more
+      #   # slashes are found in the regexp string.
+      #
+      #   # bad
+      #   x =~ /home\//
+      #
+      #   # good
+      #   x =~ %r{home/}
+      #
+      # @example AllowInnerSlashes: true
+      #   # good
       #   x =~ /home\//
       class RegexpLiteral < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG_USE_SLASHES = 'Use `//` around regular expression.'.freeze
-        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'.freeze
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
         def on_regexp(node)
           if slash_literal?(node)
@@ -42,6 +96,13 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            correct_delimiters(node, corrector)
+            correct_inner_slashes(node, corrector)
+          end
+        end
+
         private
 
         def check_slash_literal(node)
@@ -89,8 +150,9 @@ module RuboCop
           cop_config['AllowInnerSlashes']
         end
 
-        def node_body(node)
-          node.each_child_node(:str).map(&:source).join
+        def node_body(node, include_begin_nodes: false)
+          types = include_begin_nodes ? %i[str begin] : %i[str]
+          node.each_child_node(*types).map(&:source).join
         end
 
         def slash_literal?(node)
@@ -102,18 +164,62 @@ module RuboCop
             ['PreferredDelimiters']['%r'].split(//)
         end
 
-        def autocorrect(node)
-          return if contains_slash?(node)
+        def correct_delimiters(node, corrector)
+          replacement = calculate_replacement(node)
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
 
-          replacement = if slash_literal?(node)
-                          ['%r', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[/ /]
-                        end
+        def correct_inner_slashes(node, corrector)
+          regexp_begin = node.loc.begin.end_pos
 
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
+          inner_slash_indices(node).each do |index|
+            start = regexp_begin + index
+
+            corrector.replace(
+              range_between(
+                start,
+                start + inner_slash_before_correction(node).length
+              ),
+              inner_slash_after_correction(node)
+            )
+          end
+        end
+
+        def inner_slash_indices(node)
+          text    = node_body(node, include_begin_nodes: true)
+          pattern = inner_slash_before_correction(node)
+          index   = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
+        def inner_slash_before_correction(node)
+          inner_slash_for(node.loc.begin.source)
+        end
+
+        def inner_slash_after_correction(node)
+          inner_slash_for(calculate_replacement(node).first)
+        end
+
+        def inner_slash_for(opening_delimiter)
+          if ['/', '%r/'].include?(opening_delimiter)
+            '\/'
+          else
+            '/'
+          end
+        end
+
+        def calculate_replacement(node)
+          if slash_literal?(node)
+            ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            %w[/ /]
           end
         end
       end

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

@@ -4,14 +4,50 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of rescue in its modifier form.
+      #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
+      # @example
+      #   # bad
+      #   some_method rescue handle_error
+      #
+      #   # bad
+      #   some_method rescue SomeException
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
       class RescueModifier < Cop
-        include AutocorrectAlignment
+        include Alignment
         include RescueNode
 
-        MSG = 'Avoid using `rescue` in its modifier form.'.freeze
+        MSG = 'Avoid using `rescue` in its modifier form.'
 
         def on_resbody(node)
           return unless rescue_modifier?(node)
+
           add_offense(node.parent)
         end
 
@@ -28,7 +64,7 @@ module RuboCop
             "\n#{offset(node)}end"
 
           lambda do |corrector|
-            corrector.replace(node.source_range, correction)
+            corrector.replace(node, correction)
           end
         end
       end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for rescuing `StandardError`. There are two supported
+      # styles `implicit` and `explicit`. This cop will not register an offense
+      # if any error other than `StandardError` is specified.
+      #
+      # @example EnforcedStyle: implicit
+      #   # `implicit` will enforce using `rescue` instead of
+      #   # `rescue StandardError`.
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue StandardError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue OtherError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError, SecurityError
+      #     bar
+      #   end
+      #
+      # @example EnforcedStyle: explicit (default)
+      #   # `explicit` will enforce using `rescue StandardError`
+      #   # instead of `rescue`.
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue OtherError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError, SecurityError
+      #     bar
+      #   end
+      class RescueStandardError < Cop
+        include RescueNode
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
+          '`StandardError` by itself.'
+        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
+          'an error class.'
+
+        def_node_matcher :rescue_without_error_class?, <<~PATTERN
+          (resbody nil? _ _)
+        PATTERN
+
+        def_node_matcher :rescue_standard_error?, <<~PATTERN
+          (resbody $(array (const {nil? cbase} :StandardError)) _ _)
+        PATTERN
+
+        def on_resbody(node)
+          return if rescue_modifier?(node)
+
+          case style
+          when :implicit
+            rescue_standard_error?(node) do |error|
+              add_offense(node,
+                          location: node.loc.keyword.join(error.loc.expression),
+                          message: MSG_IMPLICIT)
+            end
+          when :explicit
+            rescue_without_error_class?(node) do
+              add_offense(node, location: :keyword, message: MSG_EXPLICIT)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            case style
+            when :implicit
+              error = rescue_standard_error?(node)
+              range = range_between(node.loc.keyword.end_pos,
+                                    error.loc.expression.end_pos)
+              corrector.remove(range)
+            when :explicit
+              corrector.insert_after(node.loc.keyword, ' StandardError')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,7 @@ module RuboCop
       #
       # Supported styles are: return, return_nil.
       #
-      # @example
-      #
-      #   # EnforcedStyle: return (default)
-      #
+      # @example EnforcedStyle: return (default)
       #   # bad
       #   def foo(arg)
       #     return nil if arg
@@ -21,8 +18,7 @@ module RuboCop
       #     return if arg
       #   end
       #
-      #   # EnforcedStyle: return_nil
-      #
+      # @example EnforcedStyle: return_nil
       #   # bad
       #   def foo(arg)
       #     return if arg
@@ -35,8 +31,8 @@ module RuboCop
       class ReturnNil < Cop
         include ConfigurableEnforcedStyle
 
-        RETURN_MSG = 'Use `return` instead of `return nil`.'.freeze
-        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
+        RETURN_MSG = 'Use `return` instead of `return nil`.'
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
 
         def_node_matcher :return_node?, '(return)'
         def_node_matcher :return_nil_node?, '(return nil)'
@@ -61,15 +57,15 @@ module RuboCop
           add_offense(node) unless correct_style?(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrected = style == :return ? 'return' : 'return nil'
-            corrector.replace(node.source_range, corrected)
+            corrector.replace(node, corrected)
           end
         end
 
+        private
+
         def message(_node)
           style == :return ? RETURN_MSG : RETURN_NIL_MSG
         end
@@ -84,7 +80,7 @@ module RuboCop
         end
 
         def_node_matcher :chained_send?, '(send !nil? ...)'
-        def_node_matcher :define_method?, <<-PATTERN
+        def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN
       end