rubocop 1.12.1 → 1.16.1

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

@@ -132,9 +132,7 @@ module RuboCop
         end
 
         def extract_heredoc_argument(node)
-          node.arguments.find do |arg_node|
-            extract_heredoc(arg_node)
-          end
+          node.arguments.find { |arg_node| extract_heredoc(arg_node) }
         end
 
         def extract_heredoc(node)
@@ -234,12 +232,7 @@ module RuboCop
         def remove_internal_trailing_comma(node, corrector)
           offset = internal_trailing_comma_offset_from_last_arg(node)
           last_arg_end_pos = node.children.last.source_range.end_pos
-          corrector.remove(
-            range_between(
-              last_arg_end_pos,
-              last_arg_end_pos + offset
-            )
-          )
+          corrector.remove(range_between(last_arg_end_pos, last_arg_end_pos + offset))
         end
 
         def internal_trailing_comma?(node)

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

@@ -81,10 +81,7 @@ module RuboCop
         end
 
         def width_message(indentation_width)
-          format(
-            WIDTH_MSG,
-            indentation_width: indentation_width
-          )
+          format(WIDTH_MSG, indentation_width: indentation_width)
         end
 
         def line_too_long?(node)
@@ -126,8 +123,7 @@ module RuboCop
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
-                    ' ' * correct_indent_level)
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
         def indented_end(node)

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

@@ -46,9 +46,7 @@ module RuboCop
             next unless (range = find_offence(line, lineno))
             next if in_string_literal?(str_ranges, range)
 
-            add_offense(range) do |corrector|
-              autocorrect(corrector, range)
-            end
+            add_offense(range) { |corrector| autocorrect(corrector, range) }
           end
         end
 

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

@@ -135,8 +135,7 @@ module RuboCop
             check_indentation(when_node.loc.keyword, when_node.body)
           end
 
-          check_indentation(case_node.when_branches.last.loc.keyword,
-                            case_node.else_branch)
+          check_indentation(case_node.when_branches.last.loc.keyword, case_node.else_branch)
         end
 
         def on_if(node, base = node)
@@ -314,9 +313,12 @@ module RuboCop
             check_rescue?(body_node)
           elsif body_node.ensure_type?
             block_body, = *body_node
-            return unless block_body
 
-            check_rescue?(block_body) if block_body.rescue_type?
+            if block_body&.rescue_type?
+              check_rescue?(block_body)
+            else
+              !block_body.nil?
+            end
           else
             true
           end

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

@@ -41,10 +41,7 @@ module RuboCop
           return unless token
           return if token.column.zero?
 
-          space_range =
-            range_with_surrounding_space(range: token.pos,
-                                         side: :left,
-                                         newlines: false)
+          space_range = range_with_surrounding_space(range: token.pos, side: :left, newlines: false)
           # If the file starts with a byte order mark (BOM), the column can be
           # non-zero, but then we find out here if there's no space to the left
           # of the first token.

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

@@ -122,8 +122,7 @@ module RuboCop
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
 
-          breakable_range_by_line_index[line_index] =
-            range_between(pos, pos + 1)
+          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
         end
 
         def breakable_block_range(block_node)
@@ -171,11 +170,7 @@ module RuboCop
           end
           return check_uri_line(line, line_index) if allow_uri?
 
-          register_offense(
-            excess_range(nil, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(nil, line, line_index), line, line_index)
         end
 
         def ignored_line?(line, line_index)
@@ -242,9 +237,7 @@ module RuboCop
         end
 
         def line_in_heredoc?(line_number)
-          heredocs.any? do |range, _delimiter|
-            range.cover?(line_number)
-          end
+          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
         def check_directive_line(line, line_index)
@@ -266,11 +259,7 @@ module RuboCop
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
 
-          register_offense(
-            excess_range(uri_range, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(uri_range, line, line_index), line, line_index)
         end
       end
     end

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

@@ -24,8 +24,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each item in a multi-line array must start ' \
-          'on a separate line.'
+        MSG = 'Each item in a multi-line array must start on a separate line.'
 
         def on_array(node)
           check_line_breaks(node, node.children)

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

@@ -52,17 +52,14 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Block body expression is on the same line as ' \
-              'the block start.'
-        ARG_MSG = 'Block argument expression is not on the same line as the ' \
-                  'block start.'
+        MSG = 'Block body expression is on the same line as the block start.'
+        ARG_MSG = 'Block argument expression is not on the same line as the block start.'
         PIPE_SIZE = '|'.length
 
         def on_block(node)
           return if node.single_line?
 
-          unless args_on_beginning_line?(node) ||
-                 line_break_necessary_in_args?(node)
+          unless args_on_beginning_line?(node) || line_break_necessary_in_args?(node)
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
@@ -74,8 +71,7 @@ module RuboCop
         private
 
         def args_on_beginning_line?(node)
-          !node.arguments? ||
-            node.loc.begin.line == node.arguments.loc.last_line
+          !node.arguments? || node.loc.begin.line == node.arguments.loc.last_line
         end
 
         def line_break_necessary_in_args?(node)
@@ -101,9 +97,7 @@ module RuboCop
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
 
-          add_offense(range, message: msg) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -128,8 +122,7 @@ module RuboCop
             newlines: false
           ).end_pos
           range = range_between(node.loc.begin.end.begin_pos, end_pos)
-          corrector.replace(range,
-                            " |#{block_arg_string(node, node.arguments)}|")
+          corrector.replace(range, " |#{block_arg_string(node, node.arguments)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
@@ -141,8 +134,7 @@ module RuboCop
 
           block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node,
-                                  "\n  #{' ' * block_start_col}")
+          corrector.insert_before(first_node, "\n  #{' ' * block_start_col}")
         end
 
         def block_arg_string(node, args)

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

@@ -24,8 +24,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each key in a multi-line hash must start on a ' \
-          'separate line.'
+        MSG = 'Each key in a multi-line hash must start on a separate line.'
 
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly

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

@@ -23,8 +23,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each argument in a multi-line method call must start ' \
-          'on a separate line.'
+        MSG = 'Each argument in a multi-line method call must start on a separate line.'
 
         def on_send(node)
           return if node.method?(:[]=)

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

@@ -152,8 +152,7 @@ module RuboCop
         def alignment_base(node, rhs, given_style)
           case given_style
           when :aligned
-            semantic_alignment_base(node, rhs) ||
-              syntactic_alignment_base(node, rhs)
+            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
           when :indented
             nil
           when :indented_relative_to_receiver
@@ -170,15 +169,11 @@ module RuboCop
 
           # a = b
           #     .c
-          part_of_assignment_rhs(lhs, rhs) do |base|
-            return assignment_rhs(base).source_range
-          end
+          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
 
           # a + b
           #     .c
-          operation_rhs(lhs) do |base|
-            return base.source_range
-          end
+          operation_rhs(lhs) { |base| return base.source_range }
         end
 
         # a.b
@@ -228,8 +223,7 @@ module RuboCop
         end
 
         def operator_rhs?(node, receiver)
-          node.operator_method? && node.arguments? &&
-            within_node?(receiver, node.first_argument)
+          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
         end
       end
     end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether certain expressions, e.g. method calls, that could fit
+      # completely on a single line, are broken up into multiple lines unnecessarily.
+      #
+      # @example any configuration
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   puts 'string that fits on ' \
+      #        'a single line'
+      #
+      #   things
+      #     .select { |thing| thing.cond? }
+      #     .join('-')
+      #
+      #   # good
+      #   foo(a, b)
+      #
+      #   puts 'string that fits on a single line'
+      #
+      #   things.select { |thing| thing.cond? }.join('-')
+      #
+      # @example InspectBlocks: false (default)
+      #   # good
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      # @example InspectBlocks: true
+      #   # bad
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      #   # good
+      #   foo(a) { |x| puts x }
+      #
+      class RedundantLineBreak < Cop
+        include CheckAssignment
+
+        MSG = 'Redundant line break detected.'
+
+        def on_send(node)
+          # Include "the whole expression".
+          node = node.parent while convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
+                                   node.parent&.send_type?
+
+          return unless offense?(node) && !part_of_ignored_node?(node)
+
+          add_offense(node)
+          ignore_node(node)
+        end
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          add_offense(node)
+          ignore_node(node)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.source_range, to_single_line(node.source).strip) }
+        end
+
+        private
+
+        def offense?(node)
+          return false if configured_to_not_be_inspected?(node)
+
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+        end
+
+        def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+
+          !cop_config['InspectBlocks'] && (node.block_type? ||
+                                           node.each_descendant(:block).any?(&:multiline?))
+        end
+
+        def other_cop_takes_precedence?(node)
+          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+          end
+        end
+
+        def single_line_block_chain_enabled?
+          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
+        end
+
+        def suitable_as_single_line?(node)
+          !comment_within?(node) &&
+            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
+            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
+            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+        end
+
+        def convertible_block?(node)
+          return false unless node.parent&.block_type?
+
+          send_node = node.parent&.send_node
+          send_node.parenthesized? || !send_node.arguments?
+        end
+
+        def comment_within?(node)
+          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+            comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          end
+        end
+
+        def too_long?(node)
+          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+          to_single_line(lines.join("\n")).length > max_line_length
+        end
+
+        def to_single_line(source)
+          source
+            .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
+            .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
+            .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max']
+        end
+      end
+    end
+  end
+end

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

@@ -32,8 +32,7 @@ module RuboCop
         ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
         RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
-        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method
-                                          private_class_method].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -118,8 +117,7 @@ module RuboCop
         def alignment_node(node)
           ancestor_node = ancestor_node(node)
 
-          return ancestor_node if ancestor_node.nil? ||
-                                  ancestor_node.kwbegin_type?
+          return ancestor_node if ancestor_node.nil? || ancestor_node.kwbegin_type?
 
           assignment_node = assignment_node(ancestor_node)
           return assignment_node if same_line?(ancestor_node, assignment_node)
@@ -173,8 +171,7 @@ module RuboCop
         end
 
         def access_modifier?(node)
-          return true if node.respond_to?(:access_modifier?) &&
-                         node.access_modifier?
+          return true if node.respond_to?(:access_modifier?) && node.access_modifier?
 
           return true if node.respond_to?(:method_name) &&
                          ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks if method calls are chained onto single line blocks. It considers that a
+      # line break before the dot improves the readability of the code.
+      #
+      # @example
+      #   # bad
+      #   example.select { |item| item.cond? }.join('-')
+      #
+      #   # good
+      #   example.select { |item| item.cond? }
+      #          .join('-')
+      #
+      #   # good (not a concern for this cop)
+      #   example.select do |item|
+      #     item.cond?
+      #   end.join('-')
+      #
+      class SingleLineBlockChain < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Put method call on a separate line if chained to a single line block.'
+
+        def on_send(node)
+          range = offending_range(node)
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+        end
+
+        private
+
+        def offending_range(node)
+          receiver = node.receiver
+          return unless receiver&.block_type?
+
+          receiver_location = receiver.loc
+          closing_block_delimiter_line_number = receiver_location.end.line
+          return if receiver_location.begin.line < closing_block_delimiter_line_number
+
+          node_location = node.loc
+          dot_range = node_location.dot
+          return unless dot_range
+          return if dot_range.line > closing_block_delimiter_line_number
+
+          range_between(dot_range.begin_pos, node_location.selector.end_pos)
+        end
+      end
+    end
+  end
+end