rubocop 1.12.0 → 1.16.0

data/lib/rubocop/cop/internal_affairs/method_name_equal.rb

@@ -16,8 +16,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `method?(%<method_name>s)` instead of ' \
-              '`method_name == %<method_name>s`.'
+        MSG = 'Use `method?(%<method_name>s)` instead of `method_name == %<method_name>s`.'
         RESTRICT_ON_SEND = %i[==].freeze
 
         # @!method method_name?(node)
@@ -43,9 +42,7 @@ module RuboCop
         private
 
         def range(method_name_node, node)
-          range_between(
-            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
-          )
+          range_between(method_name_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
       end
     end

data/lib/rubocop/cop/internal_affairs/node_destructuring.rb

@@ -30,9 +30,7 @@ module RuboCop
         PATTERN
 
         def on_masgn(node)
-          node_destructuring?(node) do
-            add_offense(node)
-          end
+          node_destructuring?(node) { add_offense(node) }
         end
 
         private

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -30,9 +30,7 @@ module RuboCop
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.loc.expression.with(
-                begin_pos: receiver.loc.expression.end_pos + 1
-              )
+              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -16,8 +16,7 @@ module RuboCop
       class OffenseLocationKeyword < Base
         extend AutoCorrector
 
-        MSG = 'Use `:%<keyword>s` as the location argument to ' \
-              '`#add_offense`.'
+        MSG = 'Use `:%<keyword>s` as the location argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
         def on_send(node)

data/lib/rubocop/cop/internal_affairs/style_detected_api_use.rb

@@ -58,8 +58,7 @@ module RuboCop
         MSG_FOR_NEGATIVE_WITHOUT_POSITIVE =
           'negative `*_style_detected` methods called without ' \
           'calling `correct_style_detected` method.'
-        MSG_FOR_CONDITIONAL_USE =
-          '`*_style_detected` method called in conditional.'
+        MSG_FOR_CONDITIONAL_USE = '`*_style_detected` method called in conditional.'
         RESTRICT_ON_SEND = %i[
           correct_style_detected opposite_style_detected
           unexpected_style_detected ambiguous_style_detected

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -27,9 +27,7 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
-          assertions_using_described_class_msg.each do |node|
-            add_offense(node)
-          end
+          assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 
         private

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -56,8 +56,7 @@ module RuboCop
         end
 
         def check_body(body, node)
-          modifiers = body.each_child_node(:send)
-                          .select(&:bare_access_modifier?)
+          modifiers = body.each_child_node(:send).select(&:bare_access_modifier?)
           end_range = node.loc.end
 
           modifiers.each { |modifier| check_modifier(modifier, end_range) }

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -10,53 +10,69 @@ module RuboCop
       #   # good
       #
       #   foo :bar,
-      #       :baz
+      #       :baz,
+      #       key: value
       #
       #   foo(
       #     :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #   )
       #
       #   # bad
       #
       #   foo :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #
       #   foo(
       #     :bar,
-      #       :baz
+      #       :baz,
+      #       key: value
       #   )
       #
       # @example EnforcedStyle: with_fixed_indentation
       #   # good
       #
       #   foo :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #
       #   # bad
       #
       #   foo :bar,
-      #       :baz
+      #       :baz,
+      #       key: value
       class ArgumentAlignment < Base
         include Alignment
         extend AutoCorrector
 
-        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
-          'they span more than one line.'
+        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if they span more than one line.'
 
         FIXED_INDENT_MSG = 'Use one level of indentation for arguments ' \
           'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if node.arguments.size < 2 ||
-                    node.send_type? && node.method?(:[]=)
+          first_arg = node.first_argument
+          return if !multiple_arguments?(node, first_arg) || node.send_type? && node.method?(:[]=)
 
-          check_alignment(node.arguments, base_column(node, node.arguments))
+          if first_arg.hash_type? && !first_arg.braces?
+            pairs = first_arg.pairs
+            check_alignment(pairs, base_column(node, pairs.first))
+          else
+            check_alignment(node.arguments, base_column(node, first_arg))
+          end
         end
         alias on_csend on_send
 
         private
 
+        def multiple_arguments?(node, first_argument)
+          return true if node.arguments.size >= 2
+
+          first_argument&.hash_type? && first_argument.pairs.count >= 2
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
@@ -69,14 +85,14 @@ module RuboCop
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
-        def base_column(node, args)
-          if fixed_indentation?
+        def base_column(node, first_argument)
+          if fixed_indentation? || first_argument.nil?
             lineno = target_method_lineno(node)
             line = node.source_range.source_buffer.source_line(lineno)
             indentation_of_line = /\S.*/.match(line).begin(0)
             indentation_of_line + configured_indentation_width
           else
-            display_column(args.first.source_range)
+            display_column(first_argument.source_range)
           end
         end
 

data/lib/rubocop/cop/layout/assignment_indentation.rb

@@ -26,8 +26,7 @@ module RuboCop
         include Alignment
         extend AutoCorrector
 
-        MSG = 'Indent the first line of the right-hand-side of a ' \
-              'multi-line assignment.'
+        MSG = 'Indent the first line of the right-hand-side of a multi-line assignment.'
 
         private
 
@@ -45,8 +44,7 @@ module RuboCop
         end
 
         def leftmost_multiple_assignment(node)
-          return node unless same_line?(node, node.parent) &&
-                             node.parent.assignment?
+          return node unless same_line?(node, node.parent) && node.parent.assignment?
 
           leftmost_multiple_assignment(node.parent)
 

data/lib/rubocop/cop/layout/begin_end_alignment.rb

@@ -52,10 +52,7 @@ module RuboCop
         private
 
         def check_begin_alignment(node)
-          align_with = {
-            begin: node.loc.begin,
-            start_of_line: start_line_range(node)
-          }
+          align_with = { begin: node.loc.begin, start_of_line: start_line_range(node) }
           check_end_kw_alignment(node, align_with)
         end
 

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -109,13 +109,11 @@ module RuboCop
         end
 
         def end_align_target?(node, parent)
-          disqualified_parent?(parent, node) ||
-            !block_end_align_target?(parent, node)
+          disqualified_parent?(parent, node) || !block_end_align_target?(parent, node)
         end
 
         def disqualified_parent?(parent, node)
-          parent&.loc && parent.first_line != node.first_line &&
-            !parent.masgn_type?
+          parent&.loc && parent.first_line != node.first_line && !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)
@@ -123,19 +121,12 @@ module RuboCop
           return unless begins_its_line?(end_loc)
 
           start_loc = start_node.source_range
-          return unless start_loc.column != end_loc.column ||
-                        style == :start_of_block
+          return unless start_loc.column != end_loc.column || style == :start_of_block
 
-          do_source_line_column =
-            compute_do_source_line_column(block_node, end_loc)
+          do_source_line_column = compute_do_source_line_column(block_node, end_loc)
           return unless do_source_line_column
 
-          register_offense(
-            block_node,
-            start_loc,
-            end_loc,
-            do_source_line_column
-          )
+          register_offense(block_node, start_loc, end_loc, do_source_line_column)
         end
 
         def register_offense(block_node,
@@ -174,9 +165,7 @@ module RuboCop
                            error_source_line_column)
           format(
             MSG,
-            current: format_source_line_column(
-              loc_to_source_line_column(end_loc)
-            ),
+            current: format_source_line_column(loc_to_source_line_column(end_loc)),
             prefer: format_source_line_column(error_source_line_column),
             alt_prefer: alt_start_msg(start_loc, do_source_line_column)
           )
@@ -192,8 +181,7 @@ module RuboCop
           # blocks.
           match = /\S.*/.match(do_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line ||
-                        style == :start_of_line
+          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
 
           {
             source: match[0],

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the ``when``s of a `case` expression
+      # This cop checks how the `when` and `in`s of a `case` expression
       # are indented in relation to its `case` or `end` keyword.
       #
-      # It will register a separate offense for each misaligned `when`.
+      # It will register a separate offense for each misaligned `when` and `in`.
       #
       # @example
       #   # If Layout/EndAlignment is set to keyword style (default)
@@ -22,6 +22,13 @@ module RuboCop
       #       y / 3
       #   end
       #
+      #   case n
+      #     in pattern
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
       #   # good for all styles
       #   case n
       #   when 0
@@ -30,6 +37,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       # @example EnforcedStyle: case (default)
       #   # if EndAlignment is set to other style such as
       #   # start_of_line (as shown below), then *when* alignment
@@ -43,6 +57,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #       when 0
@@ -51,6 +72,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       # @example EnforcedStyle: end
       #   # bad
       #   a = case n
@@ -60,6 +88,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #   when 0
@@ -67,32 +102,43 @@ module RuboCop
       #   else
       #     y / 3
       #   end
+      #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
       class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Indent `when` %<depth>s `%<base>s`.'
+        MSG = 'Indent `%<branch_type>s` %<depth>s `%<base>s`.'
 
         def on_case(case_node)
           return if case_node.single_line?
 
-          case_node.each_when do |when_node|
-            check_when(when_node)
-          end
+          case_node.each_when { |when_node| check_when(when_node, 'when') }
+        end
+
+        def on_case_match(case_match_node)
+          return if case_match_node.single_line?
+
+          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
-        def check_when(when_node)
+        def check_when(when_node, branch_type)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, style)
 
           if when_column == base_column + indentation_width
             correct_style_detected
           else
-            incorrect_style(when_node)
+            incorrect_style(when_node, branch_type)
           end
         end
 
@@ -104,9 +150,9 @@ module RuboCop
           indent_one_step? ? configured_indentation_width : 0
         end
 
-        def incorrect_style(when_node)
+        def incorrect_style(when_node, branch_type)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
-          message = format(MSG, depth: depth, base: style)
+          message = format(MSG, branch_type: branch_type, depth: depth, base: style)
 
           add_offense(when_node.loc.keyword, message: message) do |corrector|
             detect_incorrect_style(when_node)
@@ -143,7 +189,7 @@ module RuboCop
         end
 
         def replacement(node)
-          case_node = node.each_ancestor(:case).first
+          case_node = node.each_ancestor(:case, :case_match).first
           base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
 
           column = base_column(case_node, base_type)

data/lib/rubocop/cop/layout/class_structure.rb

@@ -144,8 +144,7 @@ module RuboCop
           sclass: :class_singleton
         }.freeze
 
-        MSG = '`%<category>s` is supposed to appear before ' \
-              '`%<previous>s`.'
+        MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
         # @!method dynamic_constant?(node)
         def_node_matcher :dynamic_constant?, <<~PATTERN
@@ -159,11 +158,8 @@ module RuboCop
           walk_over_nested_class_definition(class_node) do |node, category|
             index = expected_order.index(category)
             if index < previous
-              message = format(MSG, category: category,
-                                    previous: expected_order[previous])
-              add_offense(node, message: message) do |corrector|
-                autocorrect(corrector, node)
-              end
+              message = format(MSG, category: category, previous: expected_order[previous])
+              add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
             end
             previous = index
           end
@@ -254,9 +250,7 @@ module RuboCop
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) ||
-            classification == sibling_class ||
-            dynamic_constant?(node)
+          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
         end
 
         def humanize_node(node)