rubocop 0.67.2 → 0.68.0

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

@@ -24,14 +24,17 @@ module RuboCop
         MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'.freeze
 
         def on_class(node)
-          name, _superclass, body = *node
-          check(name, body)
-        end
-
-        def on_module(node)
-          name, body = *node
-          check(name, body)
+          return unless node.body
+
+          if node.body.defs_type?
+            check_defs(node.identifier, node.body)
+          elsif node.body.begin_type?
+            node.body.each_child_node(:defs) do |def_node|
+              check_defs(node.identifier, def_node)
+            end
+          end
         end
+        alias on_module on_class
 
         def autocorrect(node)
           ->(corrector) { corrector.replace(node.loc.name, 'self') }
@@ -39,28 +42,17 @@ module RuboCop
 
         private
 
-        def check(name, node)
-          return unless node
-
-          if node.defs_type?
-            check_defs(name, node)
-          elsif node.begin_type?
-            node.each_child_node(:defs) { |n| check_defs(name, n) }
-          end
-        end
-
         def check_defs(name, node)
-          definee, method_name, _args, _body = *node
           # check if the class/module name matches the definee for the defs node
-          return unless name == definee
+          return unless name == node.receiver
 
-          _, class_name = *definee
-          add_offense(definee, location: :name,
-                               message: message(class_name, method_name))
+          add_offense(node.receiver, location: :name)
         end
 
-        def message(class_name, method_name)
-          format(MSG, method: method_name, class: class_name)
+        def message(node)
+          _, class_name = *node
+
+          format(MSG, method: node.parent.method_name, class: class_name)
         end
       end
     end

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

@@ -70,12 +70,12 @@ module RuboCop
         def expand_elsif(node, elsif_branches = [])
           return [] if node.nil? || !node.if_type?
 
-          _condition, elsif_branch, else_branch = *node
-          elsif_branches << elsif_branch
-          if else_branch && else_branch.if_type?
-            expand_elsif(else_branch, elsif_branches)
+          elsif_branches << node.if_branch
+
+          if node.else_branch && node.else_branch.if_type?
+            expand_elsif(node.else_branch, elsif_branches)
           else
-            elsif_branches << else_branch
+            elsif_branches << node.else_branch
           end
           elsif_branches
         end
@@ -326,10 +326,8 @@ module RuboCop
             CaseCorrector.correct(self, node)
           elsif node.ternary?
             TernaryCorrector.correct(node)
-          elsif node.if?
+          elsif node.if? || node.unless?
             IfCorrector.correct(self, node)
-          elsif node.unless?
-            UnlessCorrector.correct(self, node)
           end
         end
 
@@ -519,18 +517,18 @@ module RuboCop
           private
 
           def correction(node)
-            condition, if_branch, else_branch = *node
-
-            "#{lhs(if_branch)}#{ternary(condition, if_branch, else_branch)}"
+            "#{lhs(node.if_branch)}#{ternary(node)}"
           end
 
-          def ternary(condition, if_branch, else_branch)
-            _variable, *_operator, if_rhs = *if_branch
-            _else_variable, *_operator, else_rhs = *else_branch
+          def ternary(node)
+            _variable, *_operator, if_rhs = *node.if_branch
+            _else_variable, *_operator, else_rhs = *node.else_branch
 
-            expr = "#{condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
+            expr = "#{node.condition.source} ? " \
+                   "#{if_rhs.source} : " \
+                   "#{else_rhs.source}"
 
-            element_assignment?(if_branch) ? "(#{expr})" : expr
+            element_assignment?(node.if_branch) ? "(#{expr})" : expr
           end
 
           def element_assignment?(node)
@@ -574,7 +572,7 @@ module RuboCop
             lambda do |corrector|
               corrector.remove(assignment)
 
-              extract_branches(condition).flatten.each do |branch|
+              condition.branches.flatten.each do |branch|
                 move_branch_inside_condition(corrector, branch, condition,
                                              assignment, column)
               end
@@ -584,19 +582,12 @@ module RuboCop
           private
 
           def extract_tail_branches(node)
-            if_branch, elsif_branches, else_branch = extract_branches(node)
+            if_branch, *elsif_branches, else_branch = *node.branches
             elsif_branches.map! { |branch| tail(branch) }
 
             [tail(if_branch), elsif_branches, tail(else_branch)]
           end
 
-          def extract_branches(node)
-            _condition, if_branch, else_branch = *node
-            elsif_branches, else_branch = expand_elses(else_branch)
-
-            [if_branch, elsif_branches, else_branch]
-          end
-
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
@@ -653,10 +644,10 @@ module RuboCop
             [when_branches, tail(else_branch)]
           end
 
-          def extract_branches(node)
-            _condition, *when_branches, else_branch = *node
-            when_branches = expand_when_branches(when_branches)
-            [when_branches, else_branch]
+          def extract_branches(case_node)
+            when_branches = expand_when_branches(case_node.when_branches)
+
+            [when_branches, case_node.else_branch]
           end
 
           def move_branch_inside_condition(corrector, branch, condition,
@@ -673,26 +664,6 @@ module RuboCop
           end
         end
       end
-
-      # Corrector to correct conditional assignment in `unless` statements.
-      class UnlessCorrector
-        class << self
-          include ConditionalAssignmentHelper
-          include ConditionalCorrectorHelper
-
-          def correct(cop, node)
-            ->(corrector) { correct_if_branches(corrector, cop, node) }
-          end
-
-          private
-
-          def extract_tail_branches(node)
-            _condition, else_branch, if_branch = *node
-
-            [tail(if_branch), [], tail(else_branch)]
-          end
-        end
-      end
     end
   end
 end

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

@@ -33,17 +33,13 @@ module RuboCop
         def_node_search :outer_module, '(const (const nil? _) _)'
 
         def on_class(node)
-          _, _, body = *node
+          return unless node.body
 
-          return unless body
-
-          check(node, body, :class)
+          check(node, node.body, :class)
         end
 
         def on_module(node)
-          _, body = *node
-
-          check(node, body, :module)
+          check(node, node.body, :module)
         end
 
         private

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

@@ -71,7 +71,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            _receiver, detected_method = *node
+            detected_method = node.method_name
 
             case detected_method
             when :%
@@ -90,32 +90,29 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          receiver, _method, args = *node
-          format = receiver.source
-          args = if args.array_type? || args.hash_type?
-                   args.children.map(&:source).join(', ')
+          args = if %i[array hash].include?(node.first_argument.type)
+                   node.first_argument.children.map(&:source).join(', ')
                  else
-                   args.source
+                   node.first_argument.source
                  end
-          corrected = "#{style}(#{format}, #{args})"
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
           corrector.replace(node.loc.expression, corrected)
         end
 
         def autocorrect_to_percent(corrector, node)
-          _nil, _method, format, *args = *node
-          format = format.source
-          args   = if args.one?
-                     arg = args.first
-                     if arg.hash_type?
-                       "{ #{arg.source} }"
-                     else
-                       arg.source
-                     end
-                   else
-                     "[#{args.map(&:source).join(', ')}]"
-                   end
-          corrected = "#{format} % #{args}"
-          corrector.replace(node.loc.expression, corrected)
+          format = node.first_argument.source
+
+          args = if node.arguments.size == 2
+                   arg = node.arguments.last
+
+                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                 else
+                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node.loc.expression, "#{format} % #{args}")
         end
       end
     end

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

@@ -132,7 +132,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.sym_type?
+          return false unless pair.key.sym_type? || pair.key.dsym_type?
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end

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

@@ -37,6 +37,10 @@ module RuboCop
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::Not]
+        end
+
         def_node_matcher :inverse_candidate?, <<-PATTERN
           {
             (send $(send $(...) $_ $...) :!)

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

@@ -110,14 +110,18 @@ module RuboCop
         end
 
         def autocorrect_method_to_literal(corrector, node)
-          block_method, args = *node
-          corrector.replace(block_method.source_range, '->')
-          return if args.children.empty?
-
-          arg_str = "(#{lambda_arg_string(args)})"
-          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
-          corrector.insert_after(block_method.source_range, arg_str)
-          corrector.remove(whitespace_and_old_args)
+          corrector.replace(node.send_node.source_range, '->')
+
+          return unless node.arguments?
+
+          arg_str = "(#{lambda_arg_string(node.arguments)})"
+
+          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.remove(arguments_with_whitespace(node))
+        end
+
+        def arguments_with_whitespace(node)
+          node.loc.begin.end.join(node.arguments.loc.end)
         end
 
         def lambda_arg_string(args)

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

@@ -123,22 +123,20 @@ module RuboCop
         end
 
         def separate_mixins(node)
-          _receiver, mixin, *args = *node
-          args.reverse!
-          first_mixin = String.new("#{mixin} #{args.first.source}")
+          arguments = node.arguments.reverse
+          mixins = ["#{node.method_name} #{arguments.first.source}"]
 
-          args[1..-1].inject(first_mixin) do |replacement, arg|
-            replacement << "\n#{indent(node)}#{mixin} #{arg.source}"
-          end
+          arguments[1..-1].inject(mixins) do |replacement, arg|
+            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+          end.join("\n")
         end
 
         def group_mixins(node, mixins)
-          _receiver, mixin, *_args = *node
-          all_mixin_arguments = mixins.reverse.flat_map do |m|
-            m.arguments.map(&:source)
+          mixin_names = mixins.reverse.flat_map do |mixin|
+            mixin.arguments.map(&:source)
           end
 
-          "#{mixin} #{all_mixin_arguments.join(', ')}"
+          "#{node.method_name} #{mixin_names.join(', ')}"
         end
 
         def indent(node)

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

@@ -61,10 +61,9 @@ module RuboCop
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          _name, body = *node
-          return unless body && body.begin_type?
+          return unless node.body && node.body.begin_type?
 
-          each_wrong_style(body.children) do |child_node|
+          each_wrong_style(node.body.children) do |child_node|
             add_offense(child_node)
           end
         end

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

@@ -132,42 +132,38 @@ module RuboCop
 
         def offense_node(body)
           *_, condition = *body
+
           condition && condition.if_type? ? condition : body
         end
 
         def offense_location(offense_node)
-          condition_expression, = *offense_node
           offense_begin_pos = offense_node.source_range.begin
-          offense_begin_pos.join(condition_expression.source_range)
+          offense_begin_pos.join(offense_node.condition.source_range)
         end
 
         def autocorrect_modifier(corrector, node)
-          cond, if_body, else_body = *node
-          body = if_body || else_body
+          body = node.if_branch || node.else_branch
 
-          replacement = "next #{opposite_kw(if_body)} #{cond.source}\n" \
-                        "#{' ' * node.source_range.column}#{body.source}"
+          replacement =
+            "next #{node.inverse_keyword} #{node.condition.source}\n" \
+            "#{' ' * node.source_range.column}#{body.source}"
 
           corrector.replace(node.source_range, replacement)
         end
 
         def autocorrect_block(corrector, node)
-          cond, if_body, = *node
+          next_code = "next #{node.inverse_keyword} #{node.condition.source}"
 
-          next_code = "next #{opposite_kw(if_body)} #{cond.source}"
           corrector.insert_before(node.source_range, next_code)
 
-          corrector.remove(cond_range(node, cond))
+          corrector.remove(cond_range(node, node.condition))
           corrector.remove(end_range(node))
 
           lines = reindentable_lines(node)
-          return if lines.empty?
 
-          reindent(lines, cond, corrector)
-        end
+          return if lines.empty?
 
-        def opposite_kw(if_body)
-          if_body.nil? ? 'if' : 'unless'
+          reindent(lines, node.condition, corrector)
         end
 
         def cond_range(node, cond)

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

@@ -61,9 +61,11 @@ module RuboCop
         end
 
         def to_ternary(node)
-          cond, body, else_clause = *node
-          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " \
-            "#{expr_replacement(else_clause)}"
+          condition, if_branch, else_branch = *node
+
+          "#{expr_replacement(condition)} ? " \
+            "#{expr_replacement(if_branch)} : " \
+            "#{expr_replacement(else_branch)}"
         end
 
         def expr_replacement(node)

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

@@ -22,10 +22,7 @@ module RuboCop
               'of the argument list.'.freeze
 
         def on_def(node)
-          _method, arguments, = *node
-          arguments = *arguments
-
-          each_misplaced_optional_arg(arguments) do |argument|
+          each_misplaced_optional_arg(node.arguments) do |argument|
             add_offense(argument)
           end
         end

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

@@ -80,81 +80,78 @@ module RuboCop
 
         private
 
-        def corrected_integer_op_rand(node)
-          left, operator, right = *node
-
-          offset = int_from_int_node(left)
+        def_node_matcher :random_call, <<-PATTERN
+          {(send (send $_ _ $_) ...)
+           (send _ _ (send $_ _ $_))}
+        PATTERN
 
-          prefix_node, _, random_node = *right
+        def corrected_integer_op_rand(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
 
-          prefix = prefix_from_prefix_node(prefix_node)
-          left_int, right_int = boundaries_from_random_node(random_node)
+            offset = to_int(node.receiver)
 
-          if operator == :+
-            "#{prefix}(#{offset + left_int}..#{offset + right_int})"
-          else
-            "#{prefix}(#{offset - right_int}..#{offset - left_int})"
+            if node.method?(:+)
+              "#{prefix}(#{offset + left_int}..#{offset + right_int})"
+            else
+              "#{prefix}(#{offset - right_int}..#{offset - left_int})"
+            end
           end
         end
 
         def corrected_rand_op_integer(node)
-          left, operator, right = *node
-
-          prefix_node, _, random_node = *left
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
 
-          offset = int_from_int_node(right)
+            offset = to_int(node.first_argument)
 
-          prefix = prefix_from_prefix_node(prefix_node)
-          left_int, right_int = boundaries_from_random_node(random_node)
-
-          if operator == :+
-            "#{prefix}(#{left_int + offset}..#{right_int + offset})"
-          else
-            "#{prefix}(#{left_int - offset}..#{right_int - offset})"
+            if node.method?(:+)
+              "#{prefix}(#{left_int + offset}..#{right_int + offset})"
+            else
+              "#{prefix}(#{left_int - offset}..#{right_int - offset})"
+            end
           end
         end
 
         def corrected_rand_modified(node)
-          rand, method = *node
-          prefix_node, _, random_node = *rand
-
-          prefix = prefix_from_prefix_node(prefix_node)
-          left_int, right_int = boundaries_from_random_node(random_node)
-
-          if %i[succ next].include?(method)
-            "#{prefix}(#{left_int + 1}..#{right_int + 1})"
-          elsif method == :pred
-            "#{prefix}(#{left_int - 1}..#{right_int - 1})"
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            if %i[succ next].include?(node.method_name)
+              "#{prefix}(#{left_int + 1}..#{right_int + 1})"
+            elsif node.method?(:pred)
+              "#{prefix}(#{left_int - 1}..#{right_int - 1})"
+            end
           end
         end
 
+        def_node_matcher :namespace, <<-PATTERN
+          {$nil? (const nil? $_)}
+        PATTERN
+
         def prefix_from_prefix_node(node)
-          if node.nil?
-            'rand'
-          else
-            _, prefix = *node
-            "#{prefix}.rand"
+          namespace(node) do |namespace|
+            [namespace, 'rand'].compact.join('.')
           end
         end
 
         def boundaries_from_random_node(random_node)
-          children = random_node.children
-
           case random_node.type
           when :int
-            [0, int_from_int_node(random_node) - 1]
+            [0, to_int(random_node) - 1]
           when :irange
-            [int_from_int_node(children.first),
-             int_from_int_node(children[1])]
+            [to_int(random_node.begin), to_int(random_node.end)]
           when :erange
-            [int_from_int_node(children.first),
-             int_from_int_node(children[1]) - 1]
+            [to_int(random_node.begin), to_int(random_node.end) - 1]
           end
         end
 
-        def int_from_int_node(node)
-          node.children.first
-        end
+        def_node_matcher :to_int, <<-PATTERN
+          (int $_)
+        PATTERN
       end
     end
   end