rubocop 0.46.0 → 0.47.0

data/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -6,13 +6,18 @@ module RuboCop
       # Don't omit the accumulator when calling `next` in a `reduce` block.
       #
       # @example
+      #
       #   # bad
+      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next if i.odd?
       #     acc + i
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next acc if i.odd?
       #     acc + i

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -8,7 +8,15 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   puts (x + y)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   puts(x + y)
       class ParenthesesAsGroupedExpression < Cop
         MSG = '`(...)` interpreted as grouped expression.'.freeze
 

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -3,16 +3,30 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for quotes and commas in %w, e.g.
+      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
       #
-      #   `%w('foo', "bar")`
-      #
-      # it is more likely that the additional characters are unintended (for
+      # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting strings.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %w('foo', "bar")
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %w(foo bar)
       class PercentStringArray < Cop
         include PercentLiteral
 
+        QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
+        LEADING_QUOTE = /^['"]/
+        TRAILING_QUOTE = /['"]?,?$/
+
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
           'unwanted in the resulting strings.'.freeze
 
@@ -29,27 +43,27 @@ module RuboCop
         private
 
         def contains_quotes_or_commas?(node)
-          patterns = [/,$/, /^'.*'$/, /^".*"$/]
-
-          node.children.any? do |child|
-            literal = scrub_string(child.children.first.to_s)
+          node.values.any? do |value|
+            literal = scrub_string(value.children.first.to_s)
 
             # To avoid likely false positives (e.g. a single ' or ")
             next if literal.gsub(/[^\p{Alnum}]/, '').empty?
 
-            patterns.any? { |pat| literal =~ pat }
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
+            node.values.each do |value|
+              range = value.loc.expression
 
-              match = /['"]?,?$/.match(range.source)
+              match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              corrector.remove_leading(range, 1) if /^['"]/ =~ range.source
+              if range.source =~ LEADING_QUOTE
+                corrector.remove_leading(range, 1)
+              end
             end
           end
         end

data/lib/rubocop/cop/lint/percent_symbol_array.rb

@@ -3,13 +3,23 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for colons and commas in %i, e.g.
+      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
       #
-      #   `%i(:foo, :bar)`
-      #
-      # it is more likely that the additional characters are unintended (for
+      # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting symbols.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %i(:foo, :bar)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %i(foo bar)
       class PercentSymbolArray < Cop
         include PercentLiteral
 

data/lib/rubocop/cop/lint/rand_one.rb

@@ -8,14 +8,18 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
+      #
       #   rand 1
       #   Kernel.rand(-1)
       #   rand 1.0
       #   rand(-1.0)
       #
-      #   @good
-      #   0
+      # @example
+      #
+      #   # good
+      #
+      #   0 # just use 0 instead
       class RandOne < Cop
         MSG = '`%s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'.freeze

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -14,47 +14,48 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if day.is? :tuesday && month == :jan
       #     ...
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if day.is?(:tuesday) && month == :jan
       class RequireParentheses < Cop
-        include IfNode
-
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
               'precedence.'.freeze
 
         def on_send(node)
           _receiver, method_name, *args = *node
 
-          return if parentheses?(node)
-          return if args.empty?
+          return if parentheses?(node) || args.empty?
 
-          if ternary?(args.first)
+          if args.first.if_type? && args.first.ternary?
             check_ternary(args.first, node)
-          elsif predicate?(method_name)
-            # We're only checking predicate methods. There would be false
-            # positives otherwise.
-            check_send(args.last, node)
+          elsif method_name.to_s.end_with?('?')
+            check_predicate(args.last, node)
           end
         end
 
         private
 
-        def check_ternary(arg, node)
-          condition, = *arg
-          return unless offense?(condition)
+        def check_ternary(ternary, node)
+          return unless offense?(ternary.condition)
+
+          range = range_between(node.source_range.begin_pos,
+                                ternary.condition.source_range.end_pos)
 
-          expr = node.source_range
-          range = range_between(expr.begin_pos, condition.source_range.end_pos)
           add_offense(range, range)
         end
 
-        def check_send(arg, node)
-          add_offense(node, :expression) if offense?(arg)
-        end
+        def check_predicate(predicate, node)
+          return unless offense?(predicate)
 
-        def predicate?(method_name)
-          method_name.to_s.end_with?('?')
+          add_offense(node, :expression)
         end
 
         def offense?(node)

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -4,6 +4,26 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for *rescue* blocks targeting the Exception class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue ArgumentError
+      #     handle_exception
+      #   end
       class RescueException < Cop
         MSG = 'Avoid rescuing the `Exception` class. ' \
               'Perhaps you meant to rescue `StandardError`?'.freeze

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # The safe navigation operator returns nil if the receiver is
+      # nil.  If you chain an ordinary method call after a safe
+      # navigation operator, it raises NoMethodError.  We should use a
+      # safe navigation operator after a safe navigation operator.
+      # This cop checks for the problem outlined above.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x&.foo.bar
+      #   x&.foo + bar
+      #   x&.foo[bar]
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x&.foo&.bar
+      #   x&.foo || bar
+      class SafeNavigationChain < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Do not chain ordinary method call' \
+              ' after safe navigation operator.'.freeze
+
+        ADDITIONAL_NIL_METHODS = %i(present? blank?).freeze
+
+        def_node_matcher :bad_method?, <<-PATTERN
+          (send (csend ...) $_ ...)
+        PATTERN
+
+        minimum_target_ruby_version 2.3
+
+        def on_send(node)
+          bad_method?(node) do |method|
+            return if nil_methods.include?(method)
+
+            loc = node.loc.dot || :selector
+            add_offense(node, loc)
+          end
+        end
+
+        def autocorrect(node)
+          dot = node.loc.dot
+          return unless dot
+
+          lambda do |corrector|
+            corrector.insert_before(dot, '&')
+          end
+        end
+
+        private
+
+        def nil_methods
+          nil.methods + ADDITIONAL_NIL_METHODS
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -8,7 +8,9 @@ module RuboCop
       # exception is rescued.
       #
       # @example
+      #
       #   # bad
+      #
       #   begin
       #     something
       #   rescue Exception
@@ -17,7 +19,10 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   begin
       #     something
       #   rescue StandardError
@@ -111,7 +116,7 @@ module RuboCop
           end
         end
 
-        # @param [RuboCop::Node] rescue_group is a node of array_type
+        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
         def rescued_exceptions(rescue_group)
           klasses = *rescue_group
           klasses.map do |klass|

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -7,6 +7,30 @@ module RuboCop
       # for block arguments or block local variables.
       # This is a mimic of the warning
       # "shadowing outer local variable - foo" from `ruby -cw`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |foo| # shadowing outer `foo`
+      #       do_something(foo)
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |bar|
+      #       do_something(bar)
+      #     end
+      #   end
       class ShadowingOuterLocalVariable < Cop
         MSG = 'Shadowing outer local variable - `%s`.'.freeze
 

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -8,7 +8,15 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   "result is #{something.to_s}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{something}"
       class StringConversionInInterpolation < Cop
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'.freeze
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \

data/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb

@@ -5,6 +5,30 @@ module RuboCop
     module Lint
       # This cop checks for underscore-prefixed variables that are actually
       # used.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something(_num)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |num|
+      #     do_something(num)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
       class UnderscorePrefixedVariableName < Cop
         MSG = 'Do not use prefix `_` for a variable that is used.'.freeze
 

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -6,11 +6,16 @@ module RuboCop
       # This cop checks for using Fixnum or Bignum constant.
       #
       # @example
+      #
       #   # bad
+      #
       #   1.is_a?(Fixnum)
       #   1.is_a?(Bignum)
       #
+      # @example
+      #
       #   # good
+      #
       #   1.is_a?(Integer)
       class UnifiedInteger < Cop
         MSG = 'Use `Integer` instead of `%s`.'.freeze