rubocop 0.47.1 → 0.48.0

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

@@ -16,7 +16,7 @@ module RuboCop
           lambda do |corrector|
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
-            if [:dstr, :xstr, :regexp].include?(parent_type)
+            if %i(dstr xstr regexp).include?(parent_type)
               corrector.replace(node.source_range,
                                 "{Regexp.last_match(#{backref})}")
             else

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

@@ -37,19 +37,15 @@ module RuboCop
         MSG = 'Use `Hash#%s` instead of `Hash#%s`.'.freeze
 
         OFFENDING_SELECTORS = {
-          short: [:has_key?, :has_value?],
-          verbose: [:key?, :value?]
+          short: %i(has_key? has_value?),
+          verbose: %i(key? value?)
         }.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless args.size == 1 &&
-                        offending_selector?(method_name)
+          return unless node.arguments.one? &&
+                        offending_selector?(node.method_name)
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             proper_method_name(method_name),
-                             method_name))
+          add_offense(node, :selector)
         end
 
         def autocorrect(node)
@@ -61,6 +57,10 @@ module RuboCop
 
         private
 
+        def message(node)
+          format(MSG, proper_method_name(node.method_name), node.method_name)
+        end
+
         def proper_method_name(method_name)
           if style == :verbose
             "has_#{method_name}"

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

@@ -23,7 +23,8 @@ module RuboCop
       #   # good
       #   raise StandardError, "message"
       #   fail "message"
-      #   raise RuntimeError.new(arg1, arg2, arg3)
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
       # @example
       #
@@ -35,7 +36,7 @@ module RuboCop
       #
       #   # good
       #   raise StandardError.new("message")
-      #   raise RuntimeError.new(arg1, arg2, arg3)
+      #   raise MyCustomError.new(arg1, arg2, arg3)
       #   fail "message"
       class RaiseArgs < Cop
         include ConfigurableEnforcedStyle
@@ -59,20 +60,18 @@ module RuboCop
         private
 
         def autocorrect(node)
-          _scope, method, *args = *node
-
           new_exception = if style == :compact
-                            correction_exploded_to_compact(args)
+                            correction_exploded_to_compact(node.arguments)
                           else
-                            correction_compact_to_exploded(args)
+                            correction_compact_to_exploded(node.first_argument)
                           end
-          replacement = "#{method} #{new_exception}"
+          replacement = "#{node.method_name} #{new_exception}"
 
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         def correction_compact_to_exploded(node)
-          exception_node, _new, message_node = *node.first
+          exception_node, _new, message_node = *node
 
           message = message_node && message_node.source
 
@@ -91,10 +90,8 @@ module RuboCop
         end
 
         def check_compact(node)
-          _receiver, selector, *args = *node
-
-          if args.size > 1
-            add_offense(node, :expression, message(selector)) do
+          if node.arguments.size > 1
+            add_offense(node, :expression, message(node.method_name)) do
               opposite_style_detected
             end
           else
@@ -103,26 +100,33 @@ module RuboCop
         end
 
         def check_exploded(node)
-          _receiver, selector, *args = *node
+          return correct_style_detected unless node.arguments.one?
 
-          return correct_style_detected unless args.one?
-          arg, = *args
+          first_arg = node.first_argument
 
-          return unless arg.send_type? && arg.loc.selector.is?('new')
-          _receiver, _selector, *constructor_args = *arg
+          return unless first_arg.send_type? && first_arg.method?(:new)
 
-          # Allow code like `raise Ex.new(arg1, arg2)`.
-          return unless constructor_args.size <= 1
+          return if acceptable_exploded_args?(first_arg.arguments)
 
-          # Allow code like `raise Ex.new(*args)`
-          first_arg = constructor_args.first
-          return if first_arg && first_arg.splat_type?
-
-          add_offense(node, :expression, message(selector)) do
+          add_offense(node, :expression, message(node.method_name)) do
             opposite_style_detected
           end
         end
 
+        def acceptable_exploded_args?(args)
+          # Allow code like `raise Ex.new(arg1, arg2)`.
+          return true if args.size > 1
+
+          # Disallow zero arguments.
+          return false if args.empty?
+
+          arg = args.first
+
+          # Allow code like `raise Ex.new(kw: arg)`.
+          # Allow code like `raise Ex.new(*args)`.
+          arg.hash_type? || arg.splat_type?
+        end
+
         def message(method)
           if style == :compact
             format(COMPACT_MSG, method)

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

@@ -17,13 +17,11 @@ module RuboCop
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
               'effect.'.freeze
 
-        def_node_matcher :freezing?, '(send $_ :freeze)'
-
         def on_send(node)
-          freezing?(node) do |receiver|
-            return unless immutable_literal?(receiver)
-            add_offense(node, :expression)
-          end
+          return unless node.receiver && node.method?(:freeze) &&
+                        immutable_literal?(node.receiver)
+
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)
@@ -36,8 +34,8 @@ module RuboCop
         private
 
         def immutable_literal?(node)
-          return false unless node
           return true if node.immutable_literal?
+
           FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
             frozen_string_literals_enabled?
         end

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

@@ -16,7 +16,7 @@ module RuboCop
       class RedundantParentheses < Cop
         include Parentheses
 
-        ALLOWED_LITERALS = [:irange, :erange].freeze
+        ALLOWED_LITERALS = %i(irange erange).freeze
 
         def_node_matcher :square_brackets?,
                          '(send {(send _recv _msg) str array hash} :[] ...)'
@@ -191,8 +191,7 @@ module RuboCop
         def call_chain_starts_with_int?(begin_node, send_node)
           recv = first_part_of_call_chain(send_node)
           recv && recv.int_type? && (parent = begin_node.parent) &&
-            parent.send_type? &&
-            (parent.method_name == :-@ || parent.method_name == :+@)
+            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
       end
     end

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

@@ -84,26 +84,22 @@ module RuboCop
         end
 
         def on_lvasgn(node)
-          lhs, _rhs = *node
-          @local_variables_scopes[node] << lhs
+          lhs, rhs = *node
+          @local_variables_scopes[rhs] << lhs
         end
 
-        # Detect offenses
-
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver && receiver.self_type?
-          return unless regular_method_call?(node)
+          return unless node.self_receiver? && regular_method_call?(node)
 
           return if @allowed_send_nodes.include?(node) ||
-                    @local_variables_scopes[node].include?(method_name)
+                    @local_variables_scopes[node].include?(node.method_name)
+
           add_offense(node, :expression)
         end
 
         def autocorrect(node)
-          receiver, _method_name, *_args = *node
           lambda do |corrector|
-            corrector.remove(receiver.source_range)
+            corrector.remove(node.receiver.source_range)
             corrector.remove(node.loc.dot)
           end
         end
@@ -118,13 +114,11 @@ module RuboCop
         end
 
         def regular_method_call?(node)
-          _receiver, method_name, *_args = *node
-
-          !(operator?(method_name) ||
-            keyword?(method_name) ||
-            constant_name?(method_name) ||
-            node.asgn_method_call? ||
-            braces_style_call?(node))
+          !(operator?(node.method_name) ||
+            keyword?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
         end
 
         def on_argument(node)
@@ -133,27 +127,15 @@ module RuboCop
         end
 
         def keyword?(method_name)
-          [:alias, :and, :begin, :break, :case, :class, :def, :defined?, :do,
-           :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
-           :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
-           :super, :then, :true, :undef, :unless, :until, :when, :while,
-           :yield].include?(method_name)
-        end
-
-        def constant_name?(method_name)
-          method_name.match(/^[A-Z]/)
-        end
-
-        def braces_style_call?(node)
-          node.loc.selector.nil?
+          %i(alias and begin break case class def defined? do
+             else elsif end ensure false for if in module
+             next nil not or redo rescue retry return self
+             super then true undef unless until when while
+             yield).include?(method_name)
         end
 
         def allow_self(node)
-          return unless node.send_type?
-
-          receiver, _method_name, *_args = *node
-
-          return unless receiver && receiver.self_type?
+          return unless node.send_type? && node.self_receiver?
 
           @allowed_send_nodes << node
         end

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

@@ -6,18 +6,12 @@ module RuboCop
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
         include AutocorrectAlignment
+        include RescueNode
 
         MSG = 'Avoid using `rescue` in its modifier form.'.freeze
 
-        def investigate(processed_source)
-          @modifier_locations = processed_source
-                                .tokens
-                                .select { |t| t.type == :kRESCUE_MOD }
-                                .map(&:pos)
-        end
-
         def on_resbody(node)
-          return unless modifier?(node)
+          return unless rescue_modifier?(node)
           add_offense(node.parent, :expression)
         end
 
@@ -37,12 +31,6 @@ module RuboCop
             corrector.replace(node.source_range, correction)
           end
         end
-
-        private
-
-        def modifier?(node)
-          @modifier_locations.include?(node.loc.keyword)
-        end
       end
     end
   end

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

@@ -14,7 +14,7 @@ module RuboCop
       #   x += 1
       class SelfAssignment < Cop
         MSG = 'Use self-assignment shorthand `%s=`.'.freeze
-        OPS = [:+, :-, :*, :**, :/, :|, :&].freeze
+        OPS = %i(+ - * ** / | &).freeze
 
         def on_lvasgn(node)
           check(node, :lvar)
@@ -36,7 +36,7 @@ module RuboCop
 
           if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
-          elsif [:and, :or].include?(rhs.type)
+          elsif %i(and or).include?(rhs.type)
             check_boolean_node(node, rhs, var_name, var_type)
           end
         end
@@ -66,7 +66,7 @@ module RuboCop
 
           if rhs.send_type?
             autocorrect_send_node(node, rhs)
-          elsif [:and, :or].include?(rhs.type)
+          elsif %i(and or).include?(rhs.type)
             autocorrect_boolean_node(node, rhs)
           end
         end

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

@@ -8,13 +8,12 @@ module RuboCop
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'.freeze
 
-        def_node_matcher :sending?, '(send _ :send $...)'
+        def_node_matcher :sending?, '(send _ :send ...)'
 
         def on_send(node)
-          sending?(node) do |args|
-            return if args.empty?
-            add_offense(node, :selector)
-          end
+          return unless sending?(node) && node.arguments?
+
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -15,22 +15,21 @@ module RuboCop
         MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
-          return unless node.keyword_bang? && whitespace_after_bang_op?(node)
+          return unless node.keyword_bang? && whitespace_after_operator?(node)
 
           add_offense(node, :expression)
         end
 
-        def whitespace_after_bang_op?(node)
-          receiver, _method_name, *_args = *node
-          receiver.loc.column - node.loc.column > 1
+        def whitespace_after_operator?(node)
+          node.receiver.loc.column - node.loc.column > 1
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, _method_name, *_args = *node
-            space_range = range_between(node.loc.selector.end_pos,
-                                        receiver.source_range.begin_pos)
-            corrector.remove(space_range)
+            corrector.remove(
+              range_between(node.loc.selector.end_pos,
+                            node.receiver.source_range.begin_pos)
+            )
           end
         end
       end

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

@@ -40,7 +40,7 @@ module RuboCop
         end
 
         def on_block(node)
-          check(node, [:begin, :end].freeze)
+          check(node, %i(begin end).freeze)
         end
 
         def on_break(node)
@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def on_case(node)
-          check(node, [:keyword, :else].freeze)
+          check(node, %i(keyword else).freeze)
         end
 
         def on_ensure(node)
@@ -56,15 +56,15 @@ module RuboCop
         end
 
         def on_for(node)
-          check(node, [:begin, :end].freeze)
+          check(node, %i(begin end).freeze)
         end
 
         def on_if(node)
-          check(node, [:keyword, :else, :begin, :end].freeze, 'then'.freeze)
+          check(node, %i(keyword else begin end).freeze, 'then'.freeze)
         end
 
         def on_kwbegin(node)
-          check(node, [:begin, :end].freeze, nil)
+          check(node, %i(begin end).freeze, nil)
         end
 
         def on_next(node)
@@ -108,7 +108,7 @@ module RuboCop
         end
 
         def on_until(node)
-          check(node, [:begin, :end, :keyword].freeze)
+          check(node, %i(begin end keyword).freeze)
         end
 
         def on_when(node)
@@ -116,7 +116,7 @@ module RuboCop
         end
 
         def on_while(node)
-          check(node, [:begin, :end, :keyword].freeze)
+          check(node, %i(begin end keyword).freeze)
         end
 
         def on_yield(node)
@@ -203,11 +203,10 @@ module RuboCop
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
-          while (ancestor = node.parent)
+          node.each_ancestor do |ancestor|
             return true if ancestor.and_type? || ancestor.or_type?
             return false unless ancestor.send_type?
             return true if operator?(ancestor.method_name)
-            node = ancestor
           end
           false
         end