rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,28 +5,81 @@ 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
@@ -43,24 +95,54 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          return if contains_slash?(node)
+
+          replacement = if slash_literal?(node)
+                          ['%r', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w[/ /]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+
         private
 
         def check_slash_literal(node)
-          return if style == :slashes && !contains_disallowed_slash?(node)
-          return if style == :mixed &&
-                    node.single_line? &&
-                    !contains_disallowed_slash?(node)
+          return if allowed_slash_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_PERCENT_R)
+          add_offense(node, message: MSG_USE_PERCENT_R)
         end
 
         def check_percent_r_literal(node)
-          return if style == :slashes && contains_disallowed_slash?(node)
-          return if style == :percent_r
-          return if style == :mixed && node.multiline?
-          return if style == :mixed && contains_disallowed_slash?(node)
+          return if allowed_percent_r_literal?(node)
+
+          add_offense(node, message: MSG_USE_SLASHES)
+        end
+
+        def allowed_slash_literal?(node)
+          style == :slashes && !contains_disallowed_slash?(node) ||
+            allowed_mixed_slash?(node)
+        end
 
-          add_offense(node, :expression, MSG_USE_SLASHES)
+        def allowed_mixed_slash?(node)
+          style == :mixed && node.single_line? &&
+            !contains_disallowed_slash?(node)
+        end
+
+        def allowed_percent_r_literal?(node)
+          style == :slashes && contains_disallowed_slash?(node) ||
+            style == :percent_r ||
+            allowed_mixed_percent_r?(node)
+        end
+
+        def allowed_mixed_percent_r?(node)
+          style == :mixed && node.multiline? ||
+            contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)
@@ -76,8 +158,7 @@ module RuboCop
         end
 
         def node_body(node)
-          string_parts = node.children.select { |child| child.type == :str }
-          string_parts.map(&:source).join
+          node.each_child_node(:str).map(&:source).join
         end
 
         def slash_literal?(node)
@@ -88,21 +169,6 @@ module RuboCop
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%r'].split(//)
         end
-
-        def autocorrect(node)
-          return if contains_slash?(node)
-
-          replacement = if slash_literal?(node)
-                          ['%r', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w(/ /)
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
-        end
       end
     end
   end

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

@@ -1,25 +1,29 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for uses of rescue in its modifier form.
+      #
+      # @example
+      #   # bad
+      #   some_method rescue handle_error
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue
+      #     handle_error
+      #   end
       class RescueModifier < Cop
-        include AutocorrectAlignment
+        include Alignment
+        include RescueNode
 
         MSG = 'Avoid using `rescue` in its modifier form.'.freeze
 
-        def investigate(processed_source)
-          @modifier_locations = processed_source
-                                .tokens
-                                .select { |t| t.type == :kRESCUE_MOD }
-                                .map(&:pos)
-        end
-
         def on_resbody(node)
-          return unless modifier?(node)
-          add_offense(node.parent, :expression)
+          return unless rescue_modifier?(node)
+          add_offense(node.parent)
         end
 
         def autocorrect(node)
@@ -38,12 +42,6 @@ module RuboCop
             corrector.replace(node.source_range, correction)
           end
         end
-
-        private
-
-        def modifier?(node)
-          @modifier_locations.include?(node.loc.keyword)
-        end
       end
     end
   end

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

@@ -0,0 +1,122 @@
+# 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
+
+        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
+          '`StandardError` by itself.'.freeze
+        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
+          'an error class.'.freeze
+
+        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+          (resbody nil? _ _)
+        PATTERN
+
+        def_node_matcher :rescue_standard_error?, <<-PATTERN
+          (resbody $(array (const nil? :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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistency between 'return nil' and 'return'.
+      #
+      # Supported styles are: return, return_nil.
+      #
+      # @example EnforcedStyle: return (default)
+      #   # bad
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      # @example EnforcedStyle: return_nil
+      #   # bad
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      class ReturnNil < Cop
+        include ConfigurableEnforcedStyle
+
+        RETURN_MSG = 'Use `return` instead of `return nil`.'.freeze
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
+
+        def_node_matcher :return_node?, '(return)'
+        def_node_matcher :return_nil_node?, '(return nil)'
+
+        def on_return(node)
+          # Check Lint/NonLocalExitFromIterator first before this cop
+          node.each_ancestor(:block, :def, :defs) do |n|
+            break if scoped_node?(n)
+
+            send_node, args_node, _body_node = *n
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(send_node)
+
+            next if args_node.children.empty?
+
+            return nil if chained_send?(send_node)
+          end
+
+          add_offense(node) unless correct_style?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrected = style == :return ? 'return' : 'return nil'
+            corrector.replace(node.source_range, corrected)
+          end
+        end
+
+        private
+
+        def message(_node)
+          style == :return ? RETURN_MSG : RETURN_NIL_MSG
+        end
+
+        def correct_style?(node)
+          style == :return && !return_nil_node?(node) ||
+            style == :return_nil && !return_node?(node)
+        end
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop transforms usages of a method call safeguarded by a non `nil`
+      # check for the variable whose method is being called to
+      # safe navigation (`&.`).
+      #
+      # Configuration option: ConvertCodeThatCanStartToReturnNil
+      # The default for this is `false`. When configured to `true`, this will
+      # check for code in the format `!foo.nil? && foo.bar`. As it is written,
+      # the return of this code is limited to `false` and whatever the return
+      # of the method is. If this is converted to safe navigation,
+      # `foo&.bar` can start returning `nil` as well as what the method
+      # returns.
+      #
+      # @example
+      #   # bad
+      #   foo.bar if foo
+      #   foo.bar(param1, param2) if foo
+      #   foo.bar { |e| e.something } if foo
+      #   foo.bar(param) { |e| e.something } if foo
+      #
+      #   foo.bar if !foo.nil?
+      #   foo.bar unless !foo
+      #   foo.bar unless foo.nil?
+      #
+      #   foo && foo.bar
+      #   foo && foo.bar(param1, param2)
+      #   foo && foo.bar { |e| e.something }
+      #   foo && foo.bar(param) { |e| e.something }
+      #
+      #   # good
+      #   foo&.bar
+      #   foo&.bar(param1, param2)
+      #   foo&.bar { |e| e.something }
+      #   foo&.bar(param) { |e| e.something }
+      #
+      #   foo.nil? || foo.bar
+      #   !foo || foo.bar
+      #
+      #   # Methods that `nil` will `respond_to?` should not be converted to
+      #   # use safe navigation
+      #   foo.to_i if foo
+      class SafeNavigation < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
+              'exists before calling the method.'.freeze
+        NIL_METHODS = nil.methods.freeze
+
+        minimum_target_ruby_version 2.3
+
+        # if format: (if checked_variable body nil)
+        # unless format: (if checked_variable nil body)
+        def_node_matcher :modifier_if_safe_navigation_candidate?, <<-PATTERN
+          {
+            (if {
+                  (send $_ {:nil? :!})
+                  $_
+                } nil? $_)
+
+            (if {
+                  (send (send $_ :nil?) :!)
+                  $_
+                } $_ nil?)
+          }
+        PATTERN
+
+        def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
+
+        def on_if(node)
+          return if allowed_if_condition?(node)
+          check_node(node)
+        end
+
+        def on_and(node)
+          check_node(node)
+        end
+
+        def check_node(node)
+          return if target_ruby_version < 2.3
+          checked_variable, receiver, method = extract_parts(node)
+          return unless receiver == checked_variable
+          return if unsafe_method?(method)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          _check, body, = node.node_parts
+          _checked_variable, matching_receiver, = extract_parts(node)
+          method_call, = matching_receiver.parent
+
+          lambda do |corrector|
+            corrector.remove(begin_range(node, body))
+            corrector.remove(end_range(node, body))
+            corrector.insert_before((method_call || body).loc.dot, '&')
+          end
+        end
+
+        private
+
+        def allowed_if_condition?(node)
+          node.else? || node.elsif? || node.ternary?
+        end
+
+        def extract_parts(node)
+          case node.type
+          when :if
+            extract_parts_from_if(node)
+          when :and
+            extract_parts_from_and(node)
+          end
+        end
+
+        def extract_parts_from_if(node)
+          checked_variable, receiver =
+            modifier_if_safe_navigation_candidate?(node)
+
+          extract_common_parts(receiver, checked_variable)
+        end
+
+        def extract_parts_from_and(node)
+          checked_variable, rhs = *node
+          if cop_config['ConvertCodeThatCanStartToReturnNil']
+            checked_variable =
+              not_nil_check?(checked_variable) || checked_variable
+          end
+
+          extract_common_parts(rhs, checked_variable)
+        end
+
+        def extract_common_parts(continuation, checked_variable)
+          matching_receiver =
+            find_matching_receiver_invocation(continuation, checked_variable)
+
+          method = matching_receiver.parent if matching_receiver
+
+          [checked_variable, matching_receiver, method]
+        end
+
+        def find_matching_receiver_invocation(node, checked_variable)
+          return nil unless node
+
+          receiver = if node.block_type?
+                       node.send_node.receiver
+                     else
+                       node.receiver
+                     end
+
+          if receiver == checked_variable
+            return nil if assignment_arithmetic_or_comparison?(node)
+
+            return receiver
+          end
+
+          find_matching_receiver_invocation(receiver, checked_variable)
+        end
+
+        def assignment_arithmetic_or_comparison?(node)
+          node.assignment? ||
+            node.parent.arithmetic_operation? ||
+            comparison_node?(node.parent)
+        end
+
+        def comparison_node?(parent)
+          parent.send_type? && parent.comparison_method?
+        end
+
+        def unsafe_method?(send_node)
+          NIL_METHODS.include?(send_node.method_name) ||
+            negated?(send_node) || !send_node.dot?
+        end
+
+        def negated?(send_node)
+          if send_node.parent && send_node.parent.send_type?
+            negated?(send_node.parent)
+          else
+            send_node.send_type? && send_node.method?(:!)
+          end
+        end
+
+        def begin_range(node, method_call)
+          range_between(node.loc.expression.begin_pos,
+                        method_call.loc.expression.begin_pos)
+        end
+
+        def end_range(node, method_call)
+          range_between(method_call.loc.expression.end_pos,
+                        node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end