rubocop 0.47.1 → 0.48.0

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

@@ -14,14 +14,13 @@ module RuboCop
         def on_send(node)
           class_check?(node) do |method_name|
             return if style == method_name
+
             add_offense(node, :selector)
           end
         end
 
         def message(node)
-          _receiver, method_name, *_args = *node
-
-          if method_name == :is_a?
+          if node.method?(:is_a?)
             format(MSG, 'kind_of?', 'is_a?')
           else
             format(MSG, 'is_a?', 'kind_of?')
@@ -29,11 +28,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _receiver, method_name, *_args = *node
-
           lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              method_name == :is_a? ? 'kind_of?' : 'is_a?')
+            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+
+            corrector.replace(node.loc.selector, replacement)
           end
         end
       end

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

@@ -34,8 +34,7 @@ module RuboCop
         MSG_ALIGN = 'Align `)` with `(`.'.freeze
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          check(node, args)
+          check(node, node.arguments)
         end
 
         def on_begin(node)
@@ -50,15 +49,17 @@ module RuboCop
 
         def check(node, elements)
           right_paren = node.loc.end
-          return unless right_paren
-          return unless begins_its_line?(right_paren)
+
+          return unless right_paren && begins_its_line?(right_paren)
 
           correct_column = expected_column(node, elements)
           @column_delta = correct_column - right_paren.column
+
           return if @column_delta.zero?
 
           left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
+
           add_offense(right_paren, right_paren, msg)
         end
 

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

@@ -21,8 +21,8 @@ module RuboCop
         end
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          return unless args.one? && args.first.block_pass_type?
+          return unless node.arguments.one? &&
+                        node.first_argument.block_pass_type?
 
           check_method_node(node)
         end
@@ -36,14 +36,14 @@ module RuboCop
 
         private
 
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
+        end
+
         def check_method_node(node)
-          _receiver, method_name, *_args = *node
+          return unless preferred_methods[node.method_name]
 
-          return unless preferred_methods[method_name]
-          add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -18,19 +18,12 @@ module RuboCop
           # ignore Java interop code like Java::int
           return if java_type_node?(node)
 
-          receiver, method_name, *_args = *node
-
-          # discard methods with nil receivers and op methods(like [])
-          return unless receiver && node.loc.dot && node.loc.dot.is?('::')
-          return if allowed_name(method_name.to_s)
+          return unless node.receiver && node.double_colon?
+          return if node.camel_case_method?
 
           add_offense(node, :dot)
         end
 
-        def allowed_name(method_name)
-          method_name.match(/^[A-Z]/)
-        end
-
         def autocorrect(node)
           ->(corrector) { corrector.replace(node.loc.dot, '.') }
         end

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

@@ -31,16 +31,14 @@ module RuboCop
           branch.begin_type? ? [*branch].last : branch
         end
 
-        def lhs(node) # rubocop:disable Metrics/MethodLength
+        def lhs(node)
           case node.type
           when :send
             lhs_for_send(node)
           when :op_asgn
             "#{node.children[0].source} #{node.children[1]}= "
-          when :and_asgn
-            "#{node.children[0].source} &&= "
-          when :or_asgn
-            "#{node.children[0].source} ||= "
+          when :and_asgn, :or_asgn
+            "#{node.children[0].source} #{node.loc.operator.source} "
           when :casgn
             "#{node.children[1]} = "
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
@@ -51,15 +49,18 @@ module RuboCop
         end
 
         def indent(cop, source)
-          if cop.config[END_ALIGNMENT] &&
-             cop.config[END_ALIGNMENT][ALIGN_WITH] &&
-             cop.config[END_ALIGNMENT][ALIGN_WITH] == KEYWORD
+          conf = cop.config.for_cop(END_ALIGNMENT)
+          if conf[ALIGN_WITH] == KEYWORD
             ' ' * source.length
           else
             ''
           end
         end
 
+        def end_with_eq?(sym)
+          sym.to_s.end_with?(EQUAL)
+        end
+
         private
 
         def expand_elsif(node, elsif_branches = [])
@@ -75,22 +76,21 @@ module RuboCop
         end
 
         def lhs_for_send(node)
-          receiver = node.receiver.nil? ? '' : node.receiver.source
-          method_name = node.method_name
+          receiver = node.receiver ? node.receiver.source : ''
 
-          if method_name == :[]=
-            indices = node.children[2...-1].map(&:source).join(', ')
+          if node.method?(:[]=)
+            indices = node.arguments[0...-1].map(&:source).join(', ')
             "#{receiver}[#{indices}] = "
-          elsif setter_method?(method_name)
-            "#{receiver}.#{method_name[0...-1]} = "
+          elsif node.setter_method?
+            "#{receiver}.#{node.method_name[0...-1]} = "
           else
-            "#{receiver} #{method_name} "
+            "#{receiver} #{node.method_name} "
           end
         end
 
         def setter_method?(method_name)
           method_name.to_s.end_with?(EQUAL) &&
-            ![:!=, :==, :===, :>=, :<=].include?(method_name)
+            !%i(!= == === >= <=).include?(method_name)
         end
 
         def assignment_rhs_exist?(node)
@@ -205,23 +205,30 @@ module RuboCop
         ASSIGN_TO_CONDITION_MSG =
           'Assign variables inside of conditionals'.freeze
         VARIABLE_ASSIGNMENT_TYPES =
-          [:casgn, :cvasgn, :gvasgn, :ivasgn, :lvasgn].freeze
+          %i(casgn cvasgn gvasgn ivasgn lvasgn).freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
-                           [:and_asgn, :or_asgn, :op_asgn, :masgn].freeze
+                           %i(and_asgn or_asgn op_asgn masgn).freeze
         LINE_LENGTH = 'Metrics/LineLength'.freeze
         INDENTATION_WIDTH = 'Style/IndentationWidth'.freeze
         ENABLED = 'Enabled'.freeze
         MAX = 'Max'.freeze
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'.freeze
         WIDTH = 'Width'.freeze
-        METHODS = [:[]=, :<<, :=~, :!~, :<=>].freeze
-        CONDITION_TYPES = [:if, :case].freeze
+
+        def_node_matcher :condition?, '{if case}'
+
+        # The shovel operator `<<` does not have its own type. It is a `send`
+        # type.
+        def_node_matcher :assignment_type?, <<-END
+          {
+            #{ASSIGNMENT_TYPES.join(' ')}
+            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
+          }
+        END
 
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
-            return unless style == :assign_inside_condition
-            return unless assignment_rhs_exist?(node)
 
             check_assignment_to_condition(node)
           end
@@ -229,8 +236,6 @@ module RuboCop
 
         def on_send(node)
           return unless assignment_type?(node)
-          return unless style == :assign_inside_condition
-          return unless assignment_rhs_exist?(node)
 
           check_assignment_to_condition(node)
         end
@@ -262,6 +267,8 @@ module RuboCop
         private
 
         def check_assignment_to_condition(node)
+          return unless style == :assign_inside_condition
+          return unless assignment_rhs_exist?(node)
           ignore_node(node)
 
           assignment = assignment_node(node)
@@ -270,8 +277,7 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
           return unless else_branch # empty else
-          return if single_line_conditions_only? &&
-                    [*branches, else_branch].any?(&:begin_type?)
+          return if allowed_single_line?([*branches, else_branch])
 
           add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
         end
@@ -280,6 +286,10 @@ module RuboCop
           assignment.if_type? && assignment.ternary? && !include_ternary?
         end
 
+        def allowed_single_line?(branches)
+          single_line_conditions_only? && branches.any?(&:begin_type?)
+        end
+
         def autocorrect(node)
           if assignment_type?(node)
             move_assignment_inside_condition(node)
@@ -298,10 +308,6 @@ module RuboCop
           assignment
         end
 
-        def condition?(node)
-          CONDITION_TYPES.include?(node.type)
-        end
-
         def move_assignment_outside_condition(node)
           if node.case_type?
             CaseCorrector.correct(self, node)
@@ -341,23 +347,10 @@ module RuboCop
           nodes.map(&:type).uniq.one?
         end
 
-        # The shovel operator `<<` does not have its own type. It is a `send`
-        # type.
-        def assignment_type?(branch)
-          return true if ASSIGNMENT_TYPES.include?(branch.type)
-
-          if branch.send_type?
-            return true if METHODS.include?(branch.method_name) ||
-                           branch.method_name.to_s.end_with?(EQUAL)
-          end
-
-          false
-        end
-
         def check_node(node, branches)
           return if allowed_ternary?(node)
           return unless allowed_statements?(branches)
-          return if single_line_conditions_only? && branches.any?(&:begin_type?)
+          return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
           add_offense(node, :expression)
@@ -368,7 +361,7 @@ module RuboCop
 
           statements = branches.map { |branch| tail(branch) }
 
-          lhs_all_match?(statements) && !statements.any?(&:masgn_type?) &&
+          lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)
         end
 

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

@@ -19,7 +19,7 @@ module RuboCop
           # NewClass = something_that_returns_a_class
           # It's also ok to assign a class constant another class constant
           # SomeClass = SomeOtherClass
-          return if value && [:send, :block, :const].include?(value.type)
+          return if value && %i(send block const).include?(value.type)
 
           add_offense(node, :name) if const_name !~ SNAKE_CASE
         end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module RuboCop
   module Cop
     module Style

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

@@ -8,7 +8,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          return unless node.loc.dot
+          return unless node.dot?
 
           if proper_dot_position?(node)
             correct_style_detected
@@ -30,9 +30,7 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          receiver, _method_name, *_args = *node
-
-          receiver_line = receiver.source_range.end.line
+          receiver_line = node.receiver.source_range.end.line
           selector_line = selector_range(node).line
 
           # receiver and selector are on the same line
@@ -61,15 +59,13 @@ module RuboCop
         end
 
         def autocorrect(node)
-          receiver, _method_name, *_args = *node
-
           lambda do |corrector|
             corrector.remove(node.loc.dot)
             case style
             when :leading
               corrector.insert_before(selector_range(node), '.')
             when :trailing
-              corrector.insert_after(receiver.source_range, '.')
+              corrector.insert_after(node.receiver.source_range, '.')
             end
           end
         end

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

@@ -25,7 +25,8 @@ module RuboCop
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)
-          return unless double_negative?(node) && node.loc.selector.is?('!')
+          return unless double_negative?(node) && node.keyword_bang?
+
           add_offense(node, :selector)
         end
       end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
       class EachWithObject < Cop
         MSG = 'Use `each_with_object` instead of `%s`.'.freeze
-        METHODS = [:inject, :reduce].freeze
+        METHODS = %i(inject reduce).freeze
 
         def_node_matcher :each_with_object_candidate?, <<-PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)

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

@@ -129,8 +129,8 @@ module RuboCop
         end
 
         def missing_else_style
-          missing_config = config.for_cop('Style/MissingElse')
-          missing_config['Enabled'] ? missing_config['EnforcedStyle'] : nil
+          missing_cfg = config.for_cop('Style/MissingElse')
+          missing_cfg.fetch('Enabled') ? missing_cfg['EnforcedStyle'] : nil
         end
       end
     end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for a newline after the final magic comment.
+      #
+      # @example
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      class EmptyLineAfterMagicComment < Cop
+        MSG = 'Add a space after magic comments.'.freeze
+        BLANK_LINE = /\A\s*\z/
+
+        def investigate(source)
+          return unless source.ast &&
+                        (last_magic_comment = last_magic_comment(source))
+          return if source[last_magic_comment.loc.line] =~ BLANK_LINE
+
+          offending_range =
+            source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
+
+          add_offense(offending_range, offending_range)
+        end
+
+        def autocorrect(token)
+          lambda do |corrector|
+            corrector.insert_before(token, "\n")
+          end
+        end
+
+        private
+
+        # Find the last magic comment in the source file.
+        #
+        # Take all comments that precede the first line of code, select the
+        # magic comments, and return the last magic comment in the file.
+        #
+        # @return [Parser::Source::Comment] if magic comments exist before code
+        # @return [nil] otherwise
+        def last_magic_comment(source)
+          source
+            .comments
+            .take_while { |comment| comment.loc.line < source.ast.loc.line }
+            .select     { |comment| MagicComment.parse(comment.text).any?  }
+            .last
+        end
+      end
+    end
+  end
+end