rubocop 0.42.0 → 0.43.0

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

@@ -29,12 +29,11 @@ module RuboCop
         def on_send(node)
           return if ignored_node?(node)
           receiver, _method_name, *_args = *node
-          return unless receiver && receiver.type == :block &&
+          return unless receiver && receiver.block_type? &&
                         receiver.loc.end.is?('end')
 
-          range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
-                                            receiver.loc.end.begin_pos,
-                                            node.source_range.end_pos)
+          range = range_between(receiver.loc.end.begin_pos,
+                                node.source_range.end_pos)
           add_offense(nil, range)
         end
       end

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

@@ -33,9 +33,8 @@ module RuboCop
             else
               args_expr = args_node(node).source_range
               args_with_space = range_with_surrounding_space(args_expr, :left)
-              just_space = Parser::Source::Range.new(args_expr.source_buffer,
-                                                     args_with_space.begin_pos,
-                                                     args_expr.begin_pos)
+              just_space = range_between(args_with_space.begin_pos,
+                                         args_expr.begin_pos)
               corrector.replace(just_space, '(')
               corrector.insert_after(args_expr, ')')
             end
@@ -68,7 +67,7 @@ module RuboCop
         end
 
         def args_node(def_node)
-          if def_node.type == :def
+          if def_node.def_type?
             _method_name, args, _body = *def_node
           else
             _scope, _method_name, args, _body = *def_node

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

@@ -60,14 +60,22 @@ module RuboCop
         end
 
         def implements_respond_to_missing?(node)
-          node.parent.children.any? do |sibling|
-            respond_to_missing_def?(sibling)
+          node.parent.each_child_node(node.type).any? do |sibling|
+            if node.def_type?
+              respond_to_missing_def?(sibling)
+            elsif node.defs_type?
+              respond_to_missing_defs?(sibling)
+            end
           end
         end
 
         def_node_matcher :respond_to_missing_def?, <<-PATTERN
           (def :respond_to_missing? (...) ...)
         PATTERN
+
+        def_node_matcher :respond_to_missing_defs?, <<-PATTERN
+          (defs (self) :respond_to_missing? (...) ...)
+        PATTERN
       end
     end
   end

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

@@ -38,13 +38,21 @@ module RuboCop
 
         def on_module(node)
           _name, body = *node
-          return unless body && body.type == :begin
+          return unless body && body.begin_type?
 
-          body.children.each do |body_node|
-            if style == :module_function && body_node == EXTEND_SELF_NODE
-              add_offense(body_node, :expression, MODULE_FUNCTION_MSG)
-            elsif style == :extend_self && body_node == MODULE_FUNCTION_NODE
-              add_offense(body_node, :expression, EXTEND_SELF_MSG)
+          each_wrong_style(body.children) do |child_node, msg|
+            add_offense(child_node, :expression, msg)
+          end
+        end
+
+        private
+
+        def each_wrong_style(nodes)
+          nodes.each do |node|
+            if style == :module_function && node == EXTEND_SELF_NODE
+              yield node, MODULE_FUNCTION_MSG
+            elsif style == :extend_self && node == MODULE_FUNCTION_NODE
+              yield node, EXTEND_SELF_MSG
             end
           end
         end

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

@@ -71,11 +71,8 @@ module RuboCop
           when :new_line
             ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
           when :same_line
-            range = Parser::Source::Range.new(
-              node.source_range.source_buffer,
-              node.loc.operator.end_pos,
-              extract_rhs(node).source_range.begin_pos
-            )
+            range = range_between(node.loc.operator.end_pos,
+                                  extract_rhs(node).source_range.begin_pos)
 
             ->(corrector) { corrector.replace(range, ' ') }
           end

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

@@ -21,7 +21,7 @@ module RuboCop
           method, _args, _body = *node
           method.each_node(:send) do |send_node|
             receiver, _method_name, *_args = *send_node
-            next unless receiver && receiver.type == :block
+            next unless receiver && receiver.block_type?
 
             # The begin and end could also be braces, but we call the
             # variables do... and end...
@@ -29,10 +29,8 @@ module RuboCop
             end_kw_loc = receiver.loc.end
             next if do_kw_loc.line == end_kw_loc.line
 
-            range =
-              Parser::Source::Range.new(end_kw_loc.source_buffer,
-                                        end_kw_loc.begin_pos,
-                                        method.source_range.end_pos)
+            range = range_between(end_kw_loc.begin_pos,
+                                  method.source_range.end_pos)
             add_offense(nil, 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_block_layout.rb

@@ -43,19 +43,16 @@ module RuboCop
                   'block start.'.freeze
 
         def on_block(node)
-          end_loc = node.loc.end
-          do_loc = node.loc.begin # Actually it's either do or {.
-          return if do_loc.line == end_loc.line # One-liner, no newline needed.
+          return if oneliner?(node)
 
           # A block node has three children: the block start,
           # the arguments, and the expression. We care if the block start
           # with arguments and the expression start on the same line.
           _block_start, args, last_expression = node.children
+          do_loc = node.loc.begin # Actually it's either do or {.
 
-          unless args.children.empty?
-            if do_loc.line != args.loc.last_line
-              add_offense_for_expression(node, args, ARG_MSG)
-            end
+          if args_on_different_line?(do_loc.line, args)
+            add_offense_for_expression(node, args, ARG_MSG)
           end
 
           return unless last_expression
@@ -64,11 +61,19 @@ module RuboCop
           add_offense_for_expression(node, last_expression, MSG)
         end
 
+        def oneliner?(node)
+          node.loc.begin.line == node.loc.end.line
+        end
+
+        def args_on_different_line?(do_line, args)
+          return false if args.children.empty?
+
+          do_line != args.loc.last_line
+        end
+
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
-          range = Parser::Source::Range.new(expression.source_buffer,
-                                            expression.begin_pos,
-                                            expression.end_pos)
+          range = range_between(expression.begin_pos, expression.end_pos)
 
           add_offense(node, range, msg)
         end
@@ -76,7 +81,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             _method, args, block_body = *node
-            unless args.children.empty? || args.loc.last_line == node.loc.line
+            unless arguments_on_different_line?(node, args)
               autocorrect_arguments(corrector, node, args)
               expr_before_body = args.source_range.end
             end
@@ -90,18 +95,20 @@ module RuboCop
           end
         end
 
+        def arguments_on_different_line?(node, args)
+          args.children.empty? || args.loc.last_line == node.loc.line
+        end
+
         def autocorrect_arguments(corrector, node, args)
           end_pos =
             range_with_surrounding_space(args.source_range, :right, false)
             .end_pos
-          range = Parser::Source::Range.new(args.source_range.source_buffer,
-                                            node.loc.begin.end.begin_pos,
-                                            end_pos)
+          range = range_between(node.loc.begin.end.begin_pos, end_pos)
           corrector.replace(range, " |#{block_arg_string(args)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
-          first_node = if block_body.type == :begin
+          first_node = if block_body.begin_type?
                          block_body.children.first
                        else
                          block_body

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

@@ -84,6 +84,15 @@ module RuboCop
 
           args
         end
+
+        def ignored_literal?(node)
+          single_line_ignoring_receiver?(node) || super
+        end
+
+        def single_line_ignoring_receiver?(node)
+          return false unless node.loc.begin && node.loc.end
+          node.loc.begin.line == node.loc.end.line
+        end
       end
     end
   end

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

@@ -36,13 +36,13 @@ module RuboCop
         include MultilineExpressionIndentation
 
         def validate_config
-          if style == :aligned && cop_config['IndentationWidth']
-            raise ValidationError,
-                  'The `Style/MultilineMethodCallIndentation`' \
-                  ' cop only accepts an `IndentationWidth` ' \
-                  'configuration parameter when ' \
-                  '`EnforcedStyle` is `indented`.'
-          end
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError,
+                'The `Style/MultilineMethodCallIndentation`' \
+                ' cop only accepts an `IndentationWidth` ' \
+                'configuration parameter when ' \
+                '`EnforcedStyle` is `indented`.'
         end
 
         private
@@ -74,23 +74,44 @@ module RuboCop
         end
 
         def message(node, lhs, rhs)
-          if @base
-            base_source = @base.source[/[^\n]*/]
-            if style == :indented_relative_to_receiver
-              "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
-              "more than `#{base_source}` on line #{@base.line}."
-            else
-              "Align `#{rhs.source}` with `#{base_source}` on " \
-              "line #{@base.line}."
-            end
+          if should_indent_relative_to_receiver?
+            relative_to_receiver_message(rhs)
+          elsif should_align_with_base?
+            align_with_base_message(rhs)
           else
-            used_indentation = rhs.column - indentation(lhs)
-            what = operation_description(node, rhs)
-            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
-              "spaces for indenting #{what} spanning multiple lines."
+            no_base_message(lhs, rhs, node)
           end
         end
 
+        def should_indent_relative_to_receiver?
+          @base && style == :indented_relative_to_receiver
+        end
+
+        def should_align_with_base?
+          @base && style != :indented_relative_to_receiver
+        end
+
+        def relative_to_receiver_message(rhs)
+          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+            "more than `#{base_source}` on line #{@base.line}."
+        end
+
+        def align_with_base_message(rhs)
+          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
+        end
+
+        def base_source
+          @base.source[/[^\n]*/]
+        end
+
+        def no_base_message(lhs, rhs, node)
+          used_indentation = rhs.column - indentation(lhs)
+          what = operation_description(node, rhs)
+
+          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+            "spaces for indenting #{what} spanning multiple lines."
+        end
+
         def alignment_base(node, rhs, given_style)
           return nil if given_style == :indented
 

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

@@ -27,12 +27,12 @@ module RuboCop
         end
 
         def validate_config
-          if style == :aligned && cop_config['IndentationWidth']
-            raise ValidationError, 'The `Style/MultilineOperationIndentation`' \
-                                  ' cop only accepts an `IndentationWidth` ' \
-                                  'configuration parameter when ' \
-                                  '`EnforcedStyle` is `indented`.'
-          end
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError, 'The `Style/MultilineOperationIndentation`' \
+                                ' cop only accepts an `IndentationWidth` ' \
+                                'configuration parameter when ' \
+                                '`EnforcedStyle` is `indented`.'
         end
 
         private

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

@@ -12,13 +12,11 @@ module RuboCop
               'use `if` or `unless` instead.'.freeze
 
         def on_if(node)
-          _condition, _if_branch, else_branch = *node
+          _condition, _if_branch, = *node
 
-          return unless ternary?(node)
+          return unless ternary?(node) && node.multiline?
 
-          unless node.loc.line == else_branch.loc.line
-            add_offense(node, :expression)
-          end
+          add_offense(node, :expression)
         end
       end
     end

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

@@ -14,10 +14,10 @@ module RuboCop
       #   # good
       #   CONST = [1, 2, 3].freeze
       class MutableConstant < Cop
-        MSG = 'Freeze mutable objects assigned to constants.'.freeze
-
         include FrozenStringLiteral
 
+        MSG = 'Freeze mutable objects assigned to constants.'.freeze
+
         def on_casgn(node)
           _scope, _const_name, value = *node
           on_assignment(value)
@@ -25,7 +25,22 @@ module RuboCop
 
         def on_or_asgn(node)
           lhs, value = *node
-          on_assignment(value) if lhs && lhs.type == :casgn
+
+          return unless lhs && lhs.casgn_type?
+
+          on_assignment(value)
+        end
+
+        private
+
+        def on_assignment(value)
+          value = splat_value(value) if splat_value(value)
+
+          return unless value && value.mutable_literal?
+          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
+                    frozen_string_literals_enabled?(processed_source)
+
+          add_offense(value, :expression)
         end
 
         def autocorrect(node)
@@ -40,16 +55,9 @@ module RuboCop
           end
         end
 
-        private
-
-        def on_assignment(value)
-          return unless value
-          return unless value.mutable_literal?
-          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
-                    frozen_string_literals_enabled?(processed_source)
-
-          add_offense(value, :expression)
-        end
+        def_node_matcher :splat_value, <<-PATTERN
+          (array (splat $_))
+        PATTERN
       end
     end
   end

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

@@ -32,7 +32,7 @@ module RuboCop
           lambda do |corrector|
             condition, _body, _rest = *node
             # look inside parentheses around the condition
-            condition = condition.children.first while condition.type == :begin
+            condition = condition.children.first while condition.begin_type?
             # unwrap the negated portion of the condition (a send node)
             pos_condition, _method, = *condition
             corrector.replace(

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

@@ -19,7 +19,7 @@ module RuboCop
         end
 
         def message(node)
-          if node.type == :while
+          if node.while_type?
             format(MSG, 'until', 'while')
           else
             format(MSG, 'while', 'until')
@@ -32,12 +32,12 @@ module RuboCop
           lambda do |corrector|
             condition, _body, _rest = *node
             # Look inside parentheses around the condition, if any.
-            condition, = *condition while condition.type == :begin
+            condition, = *condition while condition.begin_type?
             # Unwrap the negated portion of the condition (a send node).
             pos_condition, _method, = *condition
             corrector.replace(
               node.loc.keyword,
-              node.type == :while ? 'until' : 'while'
+              node.while_type? ? 'until' : 'while'
             )
             corrector.replace(condition.source_range, pos_condition.source)
           end

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

@@ -66,10 +66,8 @@ module RuboCop
         def autocorrect_if_unless(outer_node, inner_node)
           outer_cond, = *outer_node
 
-          range =
-            Parser::Source::Range.new(inner_node.source_range.source_buffer,
-                                      inner_node.loc.keyword.begin_pos,
-                                      outer_cond.source_range.end_pos)
+          range = range_between(inner_node.loc.keyword.begin_pos,
+                                outer_cond.source_range.end_pos)
 
           lambda do |corrector|
             corrector.replace(range, new_expression(outer_node, inner_node))