rubocop 0.71.0 → 0.75.1

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

@@ -20,7 +20,7 @@ module RuboCop
 
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
 
-        def_node_matcher :redundant_sort_by, <<-PATTERN
+        def_node_matcher :redundant_sort_by, <<~PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 

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

@@ -5,16 +5,40 @@ module RuboCop
     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 Alignment
         include RescueNode

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

@@ -80,11 +80,11 @@ module RuboCop
         MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
           'an error class.'
 
-        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+        def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
-        def_node_matcher :rescue_standard_error?, <<-PATTERN
+        def_node_matcher :rescue_standard_error?, <<~PATTERN
           (resbody $(array (const nil? :StandardError)) _ _)
         PATTERN
 

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

@@ -80,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

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

@@ -69,7 +69,7 @@ module RuboCop
 
         # if format: (if checked_variable body nil)
         # unless format: (if checked_variable nil body)
-        def_node_matcher :modifier_if_safe_navigation_candidate, <<-PATTERN
+        def_node_matcher :modifier_if_safe_navigation_candidate, <<~PATTERN
           {
             (if {
                   (send $_ {:nil? :!})
@@ -120,6 +120,7 @@ module RuboCop
             corrector.remove(begin_range(node, body))
             corrector.remove(end_range(node, body))
             corrector.insert_before(method_call.loc.dot, '&')
+            handle_comments(corrector, node, method_call)
 
             add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
           end
@@ -127,6 +128,22 @@ module RuboCop
 
         private
 
+        def handle_comments(corrector, node, method_call)
+          return if processed_source.comments.empty?
+
+          corrector.insert_before(method_call.loc.expression,
+                                  "#{comments(node).join("\n")}\n")
+        end
+
+        def comments(node)
+          comments = processed_source.comments.select do |comment|
+            comment.loc.first_line >= node.loc.first_line &&
+              comment.loc.last_line <= node.loc.last_line
+          end
+
+          comments.map(&:text)
+        end
+
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
@@ -224,7 +241,7 @@ module RuboCop
         end
 
         def method_called?(send_node)
-          send_node.parent&.send_type?
+          send_node&.parent&.send_type?
         end
 
         def begin_range(node, method_call)

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

@@ -30,7 +30,7 @@ module RuboCop
       class Sample < Cop
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
 
-        def_node_matcher :sample_candidate?, <<-PATTERN
+        def_node_matcher :sample_candidate?, <<~PATTERN
           (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
         PATTERN
 

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
+      # This cop has `AllowAsExpressionSeparator` configuration option.
+      # It allows `;` to separate several expressions on the same line.
+      #
       # @example
       #   # bad
       #   foo = 1; bar = 2;
@@ -15,6 +18,14 @@ module RuboCop
       #   foo = 1
       #   bar = 2
       #   baz = 3
+      #
+      # @example AllowAsExpressionSeparator: false (default)
+      #   # bad
+      #   foo = 1; bar = 2
+      #
+      # @example AllowAsExpressionSeparator: true
+      #   # good
+      #   foo = 1; bar = 2
       class Semicolon < Cop
         include RangeHelp
 

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

@@ -13,10 +13,17 @@ module RuboCop
       #   def @table.columns; super; end
       #
       #   # good
-      #   def no_op; end
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
       #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
       class SingleLineMethods < Cop
         include Alignment
 

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

@@ -20,7 +20,7 @@ module RuboCop
         MSG =
           'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
 
-        def_node_matcher :stderr_puts?, <<-PATTERN
+        def_node_matcher :stderr_puts?, <<~PATTERN
           (send
             {(gvar #stderr_gvar?) (const nil? :STDERR)}
             :puts $_

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

@@ -15,11 +15,11 @@ module RuboCop
       class StringHashKeys < Cop
         MSG = 'Prefer symbols instead of strings as hash keys.'
 
-        def_node_matcher :string_hash_key?, <<-PATTERN
+        def_node_matcher :string_hash_key?, <<~PATTERN
           (pair (str _) _)
         PATTERN
 
-        def_node_matcher :receive_environments_method?, <<-PATTERN
+        def_node_matcher :receive_environments_method?, <<~PATTERN
           {
             ^^(send (const {nil? cbase} :IO) :popen ...)
             ^^(send (const {nil? cbase} :Open3)

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

@@ -18,7 +18,7 @@ module RuboCop
 
         MSG = 'Use `strip` instead of `%<methods>s`.'
 
-        def_node_matcher :lstrip_rstrip, <<-PATTERN
+        def_node_matcher :lstrip_rstrip, <<~PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
            (send $(send _ $:lstrip) $:rstrip)}
         PATTERN

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

@@ -29,9 +29,9 @@ module RuboCop
           add_offense(node, location: node.parent_class.source_range)
         end
 
-        def_node_matcher :struct_constructor?, <<-PATTERN
-           {(send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)}
+        def_node_matcher :struct_constructor?, <<~PATTERN
+          {(send (const nil? :Struct) :new ...)
+           (block (send (const nil? :Struct) :new ...) ...)}
         PATTERN
       end
     end

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

@@ -20,7 +20,7 @@ module RuboCop
         SUPER_TYPES = %i[super zsuper].freeze
 
         def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
-        def_node_matcher :symbol_proc?, <<-PATTERN
+        def_node_matcher :symbol_proc?, <<~PATTERN
           (block
             ${(send ...) (super ...) zsuper}
             $(args (arg _var))

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

@@ -8,6 +8,11 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
       # @example EnforcedStyle: require_no_parentheses (default)
       #   # bad
       #   foo = (bar?) ? a : b
@@ -40,6 +45,15 @@ module RuboCop
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
       class TernaryParentheses < Cop
         include SafeAssignment
         include ConfigurableEnforcedStyle
@@ -53,11 +67,16 @@ module RuboCop
           ' complex conditions.'
 
         def on_if(node)
+          return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           add_offense(node, location: node.source_range)
         end
 
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        end
+
         def autocorrect(node)
           condition = node.condition
 
@@ -108,7 +127,7 @@ module RuboCop
         end
 
         def non_complex_send?(node)
-          return false unless node.send_type?
+          return false unless node.call_type?
 
           !node.operator_method? || node.method?(:[])
         end
@@ -149,7 +168,8 @@ module RuboCop
 
         def unsafe_autocorrect?(condition)
           condition.children.any? do |child|
-            unparenthesized_method_call?(child)
+            unparenthesized_method_call?(child) ||
+              below_ternary_precedence?(child)
           end
         end
 
@@ -157,7 +177,16 @@ module RuboCop
           method_name(child) =~ /^[a-z]/i && !child.parenthesized?
         end
 
-        def_node_matcher :method_name, <<-PATTERN
+        def below_ternary_precedence?(child)
+          # Handle English "or", e.g. 'foo or bar ? a : b'
+          (child.or_type? && child.semantic_operator?) ||
+            # Handle English "and", e.g. 'foo and bar ? a : b'
+            (child.and_type? && child.semantic_operator?) ||
+            # Handle English "not", e.g. 'not foo ? a : b'
+            (child.send_type? && child.prefix_not?)
+        end
+
+        def_node_matcher :method_name, <<~PATTERN
           {($:defined? (send nil? _) ...)
            (send {_ nil?} $_ _ ...)}
         PATTERN

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node.to_a.last, location: end_token(node).pos)
+          add_offense(node, location: end_token(node).pos)
         end
 
         def autocorrect(node)
@@ -61,7 +61,7 @@ module RuboCop
         end
 
         def end_token(node)
-          @end_token ||= tokens(node).reverse.find(&:end?)
+          tokens(node).reverse.find(&:end?)
         end
 
         def body_and_end_on_same_line?(node)
@@ -69,10 +69,8 @@ module RuboCop
         end
 
         def token_before_end(node)
-          @token_before_end ||= begin
-            i = tokens(node).index(end_token(node))
-            tokens(node)[i - 1]
-          end
+          i = tokens(node).index(end_token(node))
+          tokens(node)[i - 1]
         end
 
         def break_line_before_end(node, corrector)

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

@@ -118,7 +118,7 @@ module RuboCop
             !allowed_method?(node) && !allowed_writer?(node.method_name)
         end
 
-        def_node_matcher :looks_like_trivial_writer?, <<-PATTERN
+        def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
           {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
         PATTERN

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

@@ -55,7 +55,7 @@ module RuboCop
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        def_node_matcher :unneeded_sort?, <<-MATCHER
+        def_node_matcher :unneeded_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
             (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})

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

@@ -25,7 +25,7 @@ module RuboCop
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
 
-        def_node_matcher :unpack_and_first_element?, <<-PATTERN
+        def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
             (send $(send (...) :unpack $(...)) :first)
             (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))

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

@@ -16,19 +16,15 @@ module RuboCop
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
+        include Interpolation
+
         MSG = 'Replace interpolated variable `%<variable>s` ' \
               'with expression `#{%<variable>s}`.'
 
-        def on_dstr(node)
-          check_for_interpolation(node)
-        end
-
-        def on_regexp(node)
-          check_for_interpolation(node)
-        end
-
-        def on_xstr(node)
-          check_for_interpolation(node)
+        def on_node_with_interpolations(node)
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
+          end
         end
 
         def autocorrect(node)
@@ -39,12 +35,6 @@ module RuboCop
 
         private
 
-        def check_for_interpolation(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
         def message(node)
           format(MSG, variable: node.source)
         end

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

@@ -71,8 +71,8 @@ module RuboCop
 
         def complex_content?(strings)
           strings.any? do |s|
-            string = s.str_content
-            !string.dup.force_encoding(::Encoding::UTF_8).valid_encoding? ||
+            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
+            !string.valid_encoding? ||
               string !~ word_regex || string =~ / /
           end
         end

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

@@ -7,7 +7,7 @@ module RuboCop
       # by a predicate method, such as receiver.length == 0,
       # receiver.length > 0, receiver.length != 0,
       # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty.
+      # replaced by receiver.empty? and !receiver.empty?.
       #
       # @example
       #   # bad
@@ -73,14 +73,14 @@ module RuboCop
           )
         end
 
-        def_node_matcher :zero_length_predicate, <<-PATTERN
+        def_node_matcher :zero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
            (send (send (...) ${:length :size}) $:<  (int $1))
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
-        def_node_matcher :nonzero_length_predicate, <<-PATTERN
+        def_node_matcher :nonzero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
         PATTERN
@@ -92,14 +92,14 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
-        def_node_matcher :zero_length_receiver, <<-PATTERN
+        def_node_matcher :zero_length_receiver, <<~PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
            (send (send $_ _) :<  (int 1))
            (send (int 1) :> (send $_ _))}
         PATTERN
 
-        def_node_matcher :other_receiver, <<-PATTERN
+        def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
         PATTERN
@@ -107,7 +107,7 @@ module RuboCop
         # Some collection like objects in the Ruby standard library
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
-        def_node_matcher :non_polymorphic_collection?, <<-PATTERN
+        def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const nil? :File) :stat _) ...) ...)
            (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN