rubocop 0.91.0 → 0.91.1

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

@@ -33,7 +33,8 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
-          return unless last_array_item?(node)
+          return unless (array = containing_array(node))
+          return unless last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -44,12 +45,20 @@ module RuboCop
 
         private
 
-        def last_array_item?(node)
-          parent = node.parent
-          return false unless parent&.array_type?
-          return false if parent.child_nodes.all?(&:hash_type?)
+        def containing_array(hash_node)
+          parent = hash_node.parent
+          parent if parent&.array_type?
+        end
+
+        def last_array_item?(array, node)
+          return false if array.child_nodes.all?(&:hash_type?)
+
+          array.children.last.equal?(node)
+        end
 
-          parent.children.last.equal?(node)
+        def explicit_array?(array)
+          # an implicit array cannot have an "unbraced" hash
+          array.square_brackets?
         end
 
         def check_braces(node)

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

@@ -157,10 +157,6 @@ module RuboCop
             #{indentation}end
           RUBY
         end
-
-        def first_line_comment(node)
-          processed_source.comment_at_line(node.loc.line)&.text
-        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Place optional keyword parameters at the end of the parameters list.'
 
         def on_kwoptarg(node)
-          kwarg_nodes = right_siblings_of(node).select(&:kwarg_type?)
+          kwarg_nodes = node.right_siblings.select(&:kwarg_type?)
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
@@ -41,11 +41,6 @@ module RuboCop
 
         private
 
-        # TODO: Use API from `rubocop-ast` when released.
-        def right_siblings_of(node)
-          node.parent.children[node.sibling_index + 1..-1]
-        end
-
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
             with_space = range_with_surrounding_space(range: kwarg.source_range)

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

@@ -22,7 +22,7 @@ module RuboCop
       #   alive_threads.map do |t|
       #     t.object_id
       #   end
-      class MultilineBlockChain < Cop
+      class MultilineBlockChain < Base
         include RangeHelp
 
         MSG = 'Avoid multi-line chains of blocks.'
@@ -36,7 +36,7 @@ module RuboCop
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)
 
-            add_offense(nil, location: range)
+            add_offense(range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -58,6 +58,7 @@ module RuboCop
         private
 
         def require_then?(when_node)
+          return true if when_node.conditions.count >= 2
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line

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

@@ -89,7 +89,9 @@ module RuboCop
         end
 
         def else_branch_to_multiline(else_branch, indentation)
-          if else_branch.if_type? && else_branch.elsif?
+          if else_branch.nil?
+            'end'
+          elsif else_branch.if_type? && else_branch.elsif?
             multiline_replacement(else_branch, indentation)
           else
             <<~RUBY.chomp

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

@@ -26,8 +26,11 @@ module RuboCop
       class OptionalBooleanParameter < Base
         MSG = 'Use keyword arguments when defining method with boolean argument.'
         BOOLEAN_TYPES = %i[true false].freeze
+        METHODS_EXCLUDED = %i[respond_to_missing?].freeze
 
         def on_def(node)
+          return if METHODS_EXCLUDED.include?(node.method_name)
+
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 

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

@@ -36,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange}))
+              {int (irange int int) (erange int int)}))
         PATTERN
 
         def_node_matcher :rand_op_integer?, <<~PATTERN
@@ -44,7 +44,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:+ :-}
             int)
         PATTERN
@@ -54,7 +54,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:succ :pred :next})
         PATTERN
 

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

@@ -94,21 +94,13 @@ module RuboCop
             add_offense(assignment) do |corrector|
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
-              corrector.remove(right_sibling_of(assignment))
+              corrector.remove(assignment.right_sibling)
             end
           else
             last_expr = node.children.last
             check_branch(last_expr)
           end
         end
-
-        def right_sibling_of(node)
-          siblings_of(node)[node.sibling_index + 1]
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
       end
     end
   end

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

@@ -24,8 +24,9 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
         operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
         COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
@@ -36,11 +37,9 @@ module RuboCop
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node)
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement_condition(node))
           end
         end

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

@@ -175,10 +175,9 @@ module RuboCop
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
-          siblings = begin_node.parent&.children
-          return false if siblings.nil?
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
 
-          next_sibling = siblings[begin_node.sibling_index + 1]
           base_value = node.children.first
 
           base_value.negative? && next_sibling == :**

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

@@ -17,7 +17,9 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class RedundantPercentQ < Cop
+      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 ' \
@@ -45,22 +47,18 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          delimiter =
-            /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
-        end
-
         private
 
         def check(node)
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node)
+          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)

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

@@ -47,8 +47,9 @@ module RuboCop
       #     return x, y
       #   end
       #
-      class RedundantReturn < Cop
+      class RedundantReturn < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
@@ -58,16 +59,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.arguments?
-              correct_with_arguments(node, corrector)
-            else
-              correct_without_arguments(node, corrector)
-            end
-          end
-        end
-
         private
 
         def correct_without_arguments(return_node, corrector)
@@ -108,8 +99,8 @@ module RuboCop
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
           when :if     then check_if_node(node)
-          when :rescue, :resbody
-            check_rescue_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)
@@ -121,7 +112,13 @@ module RuboCop
           return if cop_config['AllowMultipleReturnValues'] &&
                     node.children.size > 1
 
-          add_offense(node, location: :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)
@@ -137,9 +134,12 @@ module RuboCop
         end
 
         def check_rescue_node(node)
-          node.child_nodes.each do |child_node|
-            check_branch(child_node)
-          end
+          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
 
         def check_ensure_node(node)

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

@@ -41,7 +41,9 @@ module RuboCop
       #       self.bar == bar  # Resolves name clash with argument of the block.
       #     end
       #   end
-      class RedundantSelf < Cop
+      class RedundantSelf < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `self` detected.'
         KERNEL_METHODS = Kernel.methods(false)
         KEYWORDS = %i[alias and begin break case class def defined? do
@@ -106,20 +108,16 @@ module RuboCop
 
           return if allowed_send_node?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
         end
 
         def on_block(node)
           add_scope(node, @local_variables_scopes[node])
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver)
-            corrector.remove(node.loc.dot)
-          end
-        end
-
         private
 
         def add_scope(node, local_variables = [])

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

@@ -49,8 +49,9 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class RedundantSort < Cop
+      class RedundantSort < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
@@ -82,35 +83,23 @@ module RuboCop
             return
           end
 
-          add_offense(ancestor,
-                      location: offense_range(sort_node, ancestor),
-                      message: message(ancestor,
-                                       sorter,
-                                       accessor))
-        end
-
-        def autocorrect(node)
-          sort_node, sorter, accessor = redundant_sort?(node)
-
-          lambda do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(
-              range_between(
-                accessor_start(node),
-                node.loc.expression.end_pos
-              )
-            )
+          message = message(ancestor, sorter, accessor)
 
-            # Replace "sort" or "sort_by" with the appropriate min/max method.
-            corrector.replace(
-              sort_node.loc.selector,
-              suggestion(sorter, accessor, arg_value(node))
-            )
+          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
+            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
           end
         end
 
         private
 
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+        end
+
         def offense_range(sort_node, ancestor)
           range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
         end

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

@@ -15,8 +15,9 @@ module RuboCop
       #
       #   # good
       #   array.sort
-      class RedundantSortBy < Cop
+      class RedundantSortBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
 
@@ -28,17 +29,12 @@ module RuboCop
           redundant_sort_by(node) do |send, var_name|
             range = sort_by_range(send, node)
 
-            add_offense(node,
-                        location: range,
-                        message: format(MSG, var: var_name))
+            add_offense(range, message: format(MSG, var: var_name)) do |corrector|
+              corrector.replace(range, 'sort')
+            end
           end
         end
 
-        def autocorrect(node)
-          send = node.send_node
-          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
-        end
-
         private
 
         def sort_by_range(send, node)

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

@@ -70,10 +70,11 @@ module RuboCop
       #   rescue StandardError, SecurityError
       #     bar
       #   end
-      class RescueStandardError < Cop
+      class RescueStandardError < Base
         include RescueNode
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_IMPLICIT = 'Omit the error class when rescuing ' \
           '`StandardError` by itself.'
@@ -94,28 +95,31 @@ module RuboCop
           case style
           when :implicit
             rescue_standard_error?(node) do |error|
-              add_offense(node,
-                          location: node.loc.keyword.join(error.loc.expression),
-                          message: MSG_IMPLICIT)
+              offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
             rescue_without_error_class?(node) do
-              add_offense(node, location: :keyword, message: MSG_EXPLICIT)
+              offense_for_exlicit_enforced_style(node)
             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
+        private
+
+        def offense_for_implicit_enforced_style(node, error)
+          range = node.loc.keyword.join(error.loc.expression)
+
+          add_offense(range, message: MSG_IMPLICIT) do |corrector|
+            error = rescue_standard_error?(node)
+            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+
+            corrector.remove(range)
+          end
+        end
+
+        def offense_for_exlicit_enforced_style(node)
+          add_offense(node.loc.keyword, message: MSG_EXPLICIT) do |corrector|
+            corrector.insert_after(node.loc.keyword, ' StandardError')
           end
         end
       end