rubocop 0.47.1 → 0.48.0

data/lib/rubocop/cop/security/yaml_load.rb

@@ -19,12 +19,12 @@ module RuboCop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
 
         def_node_matcher :yaml_load, <<-END
-          (send (const nil :YAML) :load ...)
+          (send (const {nil cbase} :YAML) :load ...)
         END
 
         def on_send(node)
-          yaml_load(node) do |method|
-            add_offense(node, :selector, format(MSG, method))
+          yaml_load(node) do
+            add_offense(node, :selector)
           end
         end
 

data/lib/rubocop/cop/severity.rb

@@ -7,7 +7,7 @@ module RuboCop
       include Comparable
 
       # @api private
-      NAMES = [:refactor, :convention, :warning, :error, :fatal].freeze
+      NAMES = %i(refactor convention warning error fatal).freeze
 
       # @api private
       CODE_TABLE = { R: :refactor, C: :convention,

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

@@ -15,7 +15,7 @@ module RuboCop
         MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
 
         def on_send(node)
-          return unless node.method_name == :alias_method && node.receiver.nil?
+          return unless node.command?(:alias_method)
           return if style == :prefer_alias_method
           return if scope_type(node) == :dynamic
 
@@ -86,14 +86,14 @@ module RuboCop
         end
 
         def bareword?(sym_node)
-          sym_node.source[0] != ':'
+          !sym_node.source.start_with?(':')
         end
 
-        def correct_alias_method_to_alias(node)
+        def correct_alias_method_to_alias(send_node)
           lambda do |corrector|
-            new, old = *node.method_args
+            new, old = *send_node.arguments
             replacement = "alias #{new.children.first} #{old.children.first}"
-            corrector.replace(node.source_range, replacement)
+            corrector.replace(send_node.source_range, replacement)
           end
         end
 

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

@@ -106,7 +106,7 @@ module RuboCop
         def on_send(node)
           return if double_splat?(node)
 
-          last_argument = node.children.last
+          last_argument = node.last_argument
 
           return unless last_argument.hash_type? &&
                         ignore_hash_argument?(last_argument)

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

@@ -16,23 +16,23 @@ module RuboCop
           'following the first line of a multi-line method %s.'.freeze
 
         def on_send(node)
-          _receiver, method, *args = *node
+          return if node.arguments.size < 2 || node.method?(:[]=)
 
-          return if method == :[]=
-          return if args.size < 2
-
-          check_alignment(args, base_column(node, args))
+          check_alignment(node.arguments, base_column(node, node.arguments))
         end
 
         def on_method_def(node, _method_name, args, _body)
           args = args.children
+
           return if args.size < 2
+
           check_alignment(args, base_column(node, args))
         end
 
         def message(node)
           type = node && node.parent.send_type? ? 'call' : 'definition'
           msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+
           format(msg, type)
         end
 

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

@@ -42,26 +42,21 @@ module RuboCop
         private
 
         def on_conditionals(node)
-          condition_node, = *node
-
-          condition_node.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
+          node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
             process_logical_op(logical_node)
           end
         end
 
         def process_logical_op(node)
-          op = node.loc.operator.source
-          op_type = node.type.to_s
-          return unless op == op_type
+          return if node.logical_operator?
 
-          add_offense(node, :operator, format(MSG, OPS[op], op))
+          add_offense(node, :operator,
+                      format(MSG, node.alternate_operator, node.operator))
         end
 
         def autocorrect(node)
-          expr1, expr2 = *node
-          replacement = (node.and_type? ? '&&' : '||')
           lambda do |corrector|
-            [expr1, expr2].each do |expr|
+            [*node].each do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
               elsif expr.return_type?
@@ -70,24 +65,23 @@ module RuboCop
                 correct_other(expr, corrector)
               end
             end
-            corrector.replace(node.loc.operator, replacement)
+
+            corrector.replace(node.loc.operator, node.alternate_operator)
           end
         end
 
         def correct_send(node, corrector)
-          receiver, method_name, *args = *node
-          return correct_not(node, receiver, corrector) if method_name == :!
-          return correct_setter(node, corrector) if setter_method?(method_name)
+          return correct_not(node, node.receiver, corrector) if node.method?(:!)
+          return correct_setter(node, corrector) if node.setter_method?
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '('.freeze)
-          corrector.insert_after(args.last.source_range, ')'.freeze)
+          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
         end
 
         def correct_setter(node, corrector)
-          receiver, _method_name, *args = *node
-          corrector.insert_before(receiver.source_range, '('.freeze)
-          corrector.insert_after(args.last.source_range, ')'.freeze)
+          corrector.insert_before(node.receiver.source_range, '('.freeze)
+          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
         end
 
         # ! is a special case:
@@ -95,7 +89,7 @@ module RuboCop
         # recurse down a level and add parens to 'obj.method arg'
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
-          if node.loc.selector.source == '!'
+          if node.keyword_bang?
             return unless receiver.send_type?
 
             correct_send(receiver, corrector)
@@ -107,23 +101,14 @@ module RuboCop
         end
 
         def correct_other(node, corrector)
-          return unless node.source_range.begin.source != '('
+          return if node.source_range.begin.is?('(')
+
           corrector.insert_before(node.source_range, '(')
           corrector.insert_after(node.source_range, ')')
         end
 
-        def setter_method?(method_name)
-          method_name.to_s.end_with?('=')
-        end
-
         def correctable_send?(node)
-          _receiver, method_name, *args = *node
-          # don't clobber if we already have a starting paren
-          return false unless !node.loc.begin || node.loc.begin.source != '('
-          # don't touch anything unless we are sure it is a method call.
-          return false unless args.last && method_name.to_s =~ /[a-z]/
-
-          true
+          !node.parenthesized? && node.arguments?
         end
 
         def whitespace_before_arg(node)

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

@@ -5,16 +5,19 @@ module RuboCop
     module Style
       # This cop checks for uses of Module#attr.
       class Attr < Cop
+        MSG = 'Do not use `attr`. Use `%s` instead.'.freeze
+
         def on_send(node)
-          return unless node.command?(:attr)
-          _receiver, _method_name, *args = *node
-          msg = "Do not use `attr`. Use `#{replacement_method(node)}` instead."
+          return unless node.command?(:attr) && node.arguments?
 
-          add_offense(node, :selector, msg) if args.any?
+          add_offense(node, :selector)
         end
 
+        private
+
         def autocorrect(node)
-          _receiver, _method_name, attr_name, setter = *node
+          attr_name, setter = *node.arguments
+
           node_expr = node.source_range
           attr_expr = attr_name.source_range
 
@@ -24,14 +27,17 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(node.loc.selector, replacement_method(node))
-            corrector.replace(remove, '') if remove
+            corrector.remove(remove) if remove
           end
         end
 
-        private
+        def message(node)
+          format(MSG, replacement_method(node))
+        end
 
         def replacement_method(node)
-          _receiver, _method_name, _attr_name, setter = *node
+          setter = node.last_argument
+
           if setter && (setter.true_type? || setter.false_type?)
             setter.true_type? ? 'attr_accessor' : 'attr_reader'
           else

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

@@ -19,23 +19,20 @@ module RuboCop
       class AutoResourceCleanup < Cop
         MSG = 'Use the block version of `%s.%s`.'.freeze
 
-        TARGET_METHODS = [
-          [:File, :open]
-        ].freeze
+        TARGET_METHODS = {
+          File: :open
+        }.freeze
 
         def on_send(node)
-          receiver_node, method_name, *arg_nodes = *node
-
-          TARGET_METHODS.each do |(target_class, target_method)|
+          TARGET_METHODS.each do |target_class, target_method|
             target_receiver = s(:const, nil, target_class)
 
-            next if receiver_node != target_receiver
-            next if method_name != target_method
+            next if node.receiver != target_receiver
+            next if node.method_name != target_method
             next if node.parent && node.parent.block_type?
-            next if !arg_nodes.empty? && arg_nodes.last.block_pass_type?
+            next if node.block_argument?
 
-            add_offense(node,
-                        :expression,
+            add_offense(node, :expression,
                         format(MSG, target_class, target_method))
           end
         end

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

@@ -9,11 +9,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if parentheses?(node) || operator?(method_name)
+          return unless node.arguments?
+          return if node.parenthesized? || node.operator_method?
 
-          args.each do |arg|
+          node.arguments.each do |arg|
             get_blocks(arg) do |block|
               # If there are no parentheses around the arguments, then braces
               # and do-end have different meaning due to how they bind, so we
@@ -116,21 +115,22 @@ module RuboCop
           when :block
             yield node
           when :send
-            receiver, _method_name, *_args = *node
-            get_blocks(receiver, &block) if receiver
+            get_blocks(node.receiver, &block) if node.receiver
           when :hash
             # A hash which is passed as method argument may have no braces
             # In that case, one of the K/V pairs could contain a block node
             # which could change in meaning if do...end replaced {...}
             return if node.loc.begin
-            node.children.each { |child| get_blocks(child, &block) }
+            node.each_child_node { |child| get_blocks(child, &block) }
           when :pair
-            node.children.each { |child| get_blocks(child, &block) }
+            node.each_child_node { |child| get_blocks(child, &block) }
           end
           nil
         end
 
         def proper_block_style?(node)
+          return true if ignored_method?(node.method_name)
+
           case style
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
@@ -146,8 +146,6 @@ module RuboCop
 
         def semantic_block_style?(node)
           method_name = node.method_name
-          return true if ignored_method?(method_name)
-
           block_begin = node.loc.begin.source
 
           if block_begin == '{'
@@ -169,7 +167,7 @@ module RuboCop
         end
 
         def return_value_chaining?(node)
-          node.parent && node.parent.send_type? && node.parent.loc.dot
+          node.parent && node.parent.send_type? && node.parent.dot?
         end
 
         def correction_would_break_code?(node)
@@ -178,8 +176,8 @@ module RuboCop
           # Converting `obj.method arg do |x| end` to use `{}` would cause
           # a syntax error.
           send = node.children.first
-          _receiver, _method_name, *args = *send
-          !args.empty? && !parentheses?(send)
+
+          send.arguments? && !send.parenthesized?
         end
 
         def ignored_method?(method_name)

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

@@ -11,26 +11,21 @@ module RuboCop
         MSG = '%s curly braces around a hash parameter.'.freeze
 
         def on_send(node)
-          return if node.asgn_method_call?
+          return if node.asgn_method_call? || node.operator_method?
 
-          _receiver, method_name, *args = *node
+          return unless node.arguments? && node.last_argument.hash_type? &&
+                        !node.last_argument.empty?
 
-          return if operator?(method_name)
-          return if args.empty?
-
-          return unless args.last.hash_type? && !args.last.pairs.empty?
-
-          check(args.last, args)
+          check(node.last_argument, node.arguments)
         end
 
         private
 
         def check(arg, args)
           if style == :braces && !arg.braces?
-            add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
+            add_arg_offense(arg, :missing)
           elsif style == :no_braces && arg.braces?
-            add_offense(arg.parent, arg.source_range,
-                        format(MSG, 'Redundant'))
+            add_arg_offense(arg, :redundant)
           elsif style == :context_dependent
             check_context_dependent(arg, args)
           end
@@ -38,28 +33,33 @@ module RuboCop
 
         def check_context_dependent(arg, args)
           braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
+
           if arg.braces?
             unless braces_around_second_from_end
-              add_offense(arg.parent, arg.source_range,
-                          format(MSG, 'Redundant'))
+              add_arg_offense(arg, :redundant)
             end
           elsif braces_around_second_from_end
-            add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
+            add_arg_offense(arg, :missing)
           end
         end
 
+        def add_arg_offense(arg, type)
+          add_offense(arg.parent, arg.source_range,
+                      format(MSG, type.to_s.capitalize))
+        end
+
         # We let AutocorrectUnlessChangingAST#autocorrect work with the send
         # node, because that context is needed. When parsing the code to see if
         # the AST has changed, a braceless hash would not be parsed as a hash
         # otherwise.
         def autocorrect(send_node)
-          _receiver, _method_name, *args = *send_node
-          node = args.last
+          hash_node = send_node.last_argument
+
           lambda do |corrector|
-            if node.braces?
-              remove_braces_with_whitespace(corrector, node)
+            if hash_node.braces?
+              remove_braces_with_whitespace(corrector, hash_node)
             else
-              add_braces(corrector, node)
+              add_braces(corrector, hash_node)
             end
           end
         end
@@ -98,10 +98,6 @@ module RuboCop
           corrector.insert_before(node.source_range, '{')
           corrector.insert_after(node.source_range, '}')
         end
-
-        def braces?(arg)
-          arg.loc.begin
-        end
       end
     end
   end

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

@@ -14,6 +14,8 @@ module RuboCop
         MSG = 'Indent `when` %s `%s`.'.freeze
 
         def on_case(case_node)
+          return if case_node.single_line?
+
           case_node.each_when do |when_node|
             check_when(when_node)
           end

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

@@ -57,7 +57,7 @@ module RuboCop
         end
 
         def one_child?(body)
-          body && [:module, :class].include?(body.type)
+          body && %i(module class).include?(body.type)
         end
 
         def compact_node_name?(node)