rubocop 1.12.0 → 1.16.0

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

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

@@ -37,9 +37,7 @@ module RuboCop
         private
 
         def register_offense(colon)
-          add_offense(colon) do |corrector|
-            corrector.insert_after(colon, ' ')
-          end
+          add_offense(colon) { |corrector| corrector.insert_after(colon, ' ') }
         end
 
         def followed_by_space?(colon)

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

@@ -18,16 +18,14 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'
+        MSG = 'Do not put a space between a method name and the opening parenthesis.'
 
         def on_def(node)
           args = node.arguments
           return unless args.loc.begin&.is?('(')
 
           expr = args.source_range
-          pos_before_left_paren = range_between(expr.begin_pos - 1,
-                                                expr.begin_pos)
+          pos_before_left_paren = range_between(expr.begin_pos - 1, expr.begin_pos)
           return unless pos_before_left_paren.source.start_with?(' ')
 
           add_offense(pos_before_left_paren) do |corrector|

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

@@ -77,8 +77,7 @@ module RuboCop
           first = args.first.source_range
           last = args.last.source_range
 
-          check_no_space(opening_pipe.end_pos, first.begin_pos,
-                         'Space before first')
+          check_no_space(opening_pipe.end_pos, first.begin_pos, 'Space before first')
           check_no_space(last_end_pos_inside_pipes(arguments, last),
                          closing_pipe.begin_pos, 'Space after last')
         end
@@ -98,8 +97,7 @@ module RuboCop
 
           check_space(opening_pipe.end_pos, range.begin_pos, range,
                       'before first block parameter', first_arg)
-          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
-                         'Extra space before first')
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1, 'Extra space before first')
         end
 
         def check_closing_pipe_space(arguments, closing_pipe)
@@ -108,10 +106,8 @@ module RuboCop
           last         = args.last.source_range
           last_end_pos = last_end_pos_inside_pipes(arguments, last)
 
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
-          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
-                         'Extra space after last')
+          check_space(last_end_pos, closing_pipe.begin_pos, last, 'after last block parameter')
+          check_no_space(last_end_pos + 1, closing_pipe.begin_pos, 'Extra space after last')
         end
 
         def last_end_pos_inside_pipes(arguments, range)
@@ -123,9 +119,7 @@ module RuboCop
         end
 
         def check_each_arg(args)
-          args.children.each do |arg|
-            check_arg(arg)
-          end
+          args.children.each { |arg| check_arg(arg) }
         end
 
         def check_arg(arg)
@@ -160,9 +154,7 @@ module RuboCop
           return if range.source.include?("\n")
 
           message = "#{msg} block parameter detected."
-          add_offense(range, message: message) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range, message: message) { |corrector| corrector.remove(range) }
         end
       end
     end

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

@@ -47,8 +47,7 @@ module RuboCop
           space_on_both_sides = space_on_both_sides?(arg, equals)
           no_surrounding_space = no_surrounding_space?(arg, equals)
 
-          if style == :space && space_on_both_sides ||
-             style == :no_space && no_surrounding_space
+          if style == :space && space_on_both_sides || style == :no_space && no_surrounding_space
             correct_style_detected
           else
             incorrect_style_detected(arg, value)

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

@@ -33,10 +33,8 @@ module RuboCop
         DO = 'do'
         SAFE_NAVIGATION = '&.'
         NAMESPACE_OPERATOR = '::'
-        ACCEPT_LEFT_PAREN =
-          %w[break defined? next not rescue return super yield].freeze
-        ACCEPT_LEFT_SQUARE_BRACKET =
-          %w[super yield].freeze
+        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
@@ -55,6 +53,10 @@ module RuboCop
           check(node, %i[keyword else].freeze)
         end
 
+        def on_case_match(node)
+          check(node, %i[keyword else].freeze)
+        end
+
         def on_ensure(node)
           check(node, [:keyword].freeze)
         end
@@ -67,6 +69,14 @@ module RuboCop
           check(node, %i[keyword else begin end].freeze, 'then')
         end
 
+        def on_if_guard(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_in_pattern(node)
+          check(node, [:keyword].freeze)
+        end
+
         def on_kwbegin(node)
           check(node, %i[begin end].freeze, nil)
         end
@@ -111,6 +121,10 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
+        def on_unless_guard(node)
+          check(node, [:keyword].freeze)
+        end
+
         def on_until(node)
           check(node, %i[begin end keyword].freeze)
         end
@@ -194,8 +208,7 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
-          return false if accept_namespace_operator?(range) &&
-                          namespace_operator?(range, pos)
+          return false if accept_namespace_operator?(range) && namespace_operator?(range, pos)
 
           !/[\s;,#\\)}\].]/.match?(char)
         end

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

@@ -92,9 +92,7 @@ module RuboCop
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(:send,
-                           node.loc.selector,
-                           node.first_argument.source_range)
+            check_operator(:send, node.loc.selector, node.first_argument.source_range)
           end
         end
 
@@ -138,13 +136,11 @@ module RuboCop
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? &&
-            operator_with_regular_syntax?(send_node)
+          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
-          send_node.operator_method? &&
-            !IRREGULAR_METHODS.include?(send_node.method_name)
+          send_node.operator_method? && !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
         def check_operator(type, operator, right_operand)
@@ -225,8 +221,7 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config &&
-            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
 
         def space_around_exponent_operator?

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

@@ -136,8 +136,7 @@ module RuboCop
         end
 
         def conflict_with_block_delimiters?(node)
-          block_delimiters_style == 'line_count_based' &&
-            style == :no_space && node.multiline?
+          block_delimiters_style == 'line_count_based' && style == :no_space && node.multiline?
         end
 
         def block_delimiters_style

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

@@ -53,9 +53,7 @@ module RuboCop
         end
 
         def register_offense(range)
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
 
         def reference_variable_with_brackets?(node)

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

@@ -25,9 +25,7 @@ module RuboCop
 
             range = token2.pos
 
-            add_offense(range) do |corrector|
-              corrector.insert_before(range, ' ')
-            end
+            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
           end
         end
       end