rubocop 0.51.0 → 0.87.0

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks that block braces have or don't have a space before the opening
       # brace depending on configuration.
       #
-      # @example
+      # @example EnforcedStyle: space (default)
       #   # bad
       #   foo.map{ |a|
       #     a.bar.to_s
@@ -16,11 +16,37 @@ module RuboCop
       #   foo.map { |a|
       #     a.bar.to_s
       #   }
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   foo.map { |a|
+      #     a.bar.to_s
+      #   }
+      #
+      #   # good
+      #   foo.map{ |a|
+      #     a.bar.to_s
+      #   }
+      #
+      # @example EnforcedStyleForEmptyBraces: space (default)
+      #   # bad
+      #   7.times{}
+      #
+      #   # good
+      #   7.times {}
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space
+      #   # bad
+      #   7.times {}
+      #
+      #   # good
+      #   7.times{}
       class SpaceBeforeBlockBraces < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MISSING_MSG = 'Space missing to the left of {.'.freeze
-        DETECTED_MSG = 'Space detected to the left of {.'.freeze
+        MISSING_MSG = 'Space missing to the left of {.'
+        DETECTED_MSG = 'Space detected to the left of {.'
 
         def self.autocorrect_incompatible_with
           [Style::SymbolProc]
@@ -29,8 +55,16 @@ module RuboCop
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line braces when specifying
+          # `EnforcedStyle: no_space`. It will conflict with auto-correction
+          # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
+          # That means preventing auto-correction to incorrect auto-corrected
+          # code.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7534
+          return if conflict_with_block_delimiters?(node)
+
           left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(left_brace)
+          space_plus_brace = range_with_surrounding_space(range: left_brace)
           used_style =
             space_plus_brace.source.start_with?('{') ? :no_space : :space
 
@@ -41,6 +75,15 @@ module RuboCop
           end
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            else           corrector.insert_before(range, ' ')
+            end
+          end
+        end
+
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)
@@ -89,13 +132,13 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            else           corrector.insert_before(range, ' ')
-            end
-          end
+        def conflict_with_block_delimiters?(node)
+          block_delimiters_style == 'line_count_based' &&
+            style == :no_space && node.multiline?
+        end
+
+        def block_delimiters_style
+          config.for_cop('Style/BlockDelimiters')['EnforcedStyle']
         end
 
         def empty_braces?(loc)

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

@@ -4,11 +4,26 @@ module RuboCop
   module Cop
     module Layout
       # Checks for comma (,) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   [1 , 2 , 3]
+      #   a(1 , 2)
+      #   each { |a , b| }
+      #
+      #   # good
+      #   [1, 2, 3]
+      #   a(1, 2)
+      #   each { |a, b| }
       class SpaceBeforeComma < Cop
         include SpaceBeforePunctuation
 
+        def autocorrect(space)
+          PunctuationCorrector.remove_space(space)
+        end
+
         def kind(token)
-          'comma' if token.type == :tCOMMA
+          'comma' if token.comma?
         end
       end
     end

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

@@ -13,18 +13,17 @@ module RuboCop
       #   # good
       #   1 + 1 # this operation does ...
       class SpaceBeforeComment < Cop
-        MSG = 'Put a space before an end-of-line comment.'.freeze
+        MSG = 'Put a space before an end-of-line comment.'
 
         def investigate(processed_source)
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            next unless t2.type == :tCOMMENT
-            next unless t1.pos.line == t2.pos.line
-            add_offense(t2.pos, location: t2.pos) if t1.pos.end == t2.pos.begin
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            next unless token2.comment?
+            next unless token1.line == token2.line
+
+            add_offense(token2.pos, location: token2.pos) if token1.pos.end == token2.pos.begin
           end
         end
 
-        private
-
         def autocorrect(range)
           ->(corrector) { corrector.insert_before(range, ' ') }
         end

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

@@ -11,33 +11,36 @@ module RuboCop
       # config parameter is true.
       #
       # @example
-      #   @bad
+      #   # bad
       #   something  x
       #   something   y, z
       #   something'hello'
       #
-      #   @good
+      #   # good
       #   something x
       #   something y, z
       #   something 'hello'
       #
       class SpaceBeforeFirstArg < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
 
         MSG = 'Put one space between the method name and ' \
-              'the first argument.'.freeze
+              'the first argument.'
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
           return unless expect_params_after_method_name?(node)
 
           first_arg = node.first_argument.source_range
-          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
+          first_arg_with_space = range_with_surrounding_space(range: first_arg,
+                                                              side: :left)
           space = range_between(first_arg_with_space.begin_pos,
                                 first_arg.begin_pos)
 
           add_offense(space, location: space) if space.length != 1
         end
+        alias on_csend on_send
 
         def autocorrect(range)
           ->(corrector) { corrector.replace(range, ' ') }
@@ -51,6 +54,7 @@ module RuboCop
 
         def expect_params_after_method_name?(node)
           return false if node.parenthesized?
+          return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument
 
@@ -58,6 +62,13 @@ module RuboCop
             !(allow_for_alignment? &&
               aligned_with_something?(first_arg.source_range))
         end
+
+        def no_space_between_method_name_and_first_argument?(node)
+          end_pos_of_method_name = node.loc.selector.end_pos
+          begin_pos_of_argument = node.first_argument.source_range.begin_pos
+
+          end_pos_of_method_name == begin_pos_of_argument
+        end
       end
     end
   end

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

@@ -14,8 +14,12 @@ module RuboCop
       class SpaceBeforeSemicolon < Cop
         include SpaceBeforePunctuation
 
+        def autocorrect(space)
+          PunctuationCorrector.remove_space(space)
+        end
+
         def kind(token)
-          'semicolon' if token.type == :tSEMI
+          'semicolon' if token.semicolon?
         end
       end
     end

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

@@ -3,46 +3,41 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for spaces between -> and opening parameter
-      # brace in lambda literals.
+      # This cop checks for spaces between `->` and opening parameter
+      # parenthesis (`(`) in lambda literals.
       #
-      # @example
-      #
-      #   EnforcedStyle: require_no_space (default)
-      #
-      #     @bad
+      # @example EnforcedStyle: require_no_space (default)
+      #     # bad
       #     a = -> (x, y) { x + y }
       #
-      #     @good
+      #     # good
       #     a = ->(x, y) { x + y }
       #
-      # @example
-      #
-      #   EnforcedStyle: require_space
-      #
-      #     @bad
+      # @example EnforcedStyle: require_space
+      #     # bad
       #     a = ->(x, y) { x + y }
       #
-      #     @good
+      #     # good
       #     a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        ARROW = '->'.freeze
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and opening brace ' \
-                            'in lambda literals'.freeze
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and opening ' \
-                               'brace in lambda literals'.freeze
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
+                            '`(` in lambda literals.'
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
+                               '`(` in lambda literals.'
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
+
           if style == :require_space && !space_after_arrow?(node)
             add_offense(node,
-                        location: node.parent.loc.expression,
+                        location: range_of_offense(node),
                         message: MSG_REQUIRE_SPACE)
           elsif style == :require_no_space && space_after_arrow?(node)
             add_offense(node,
-                        location: node.parent.loc.expression,
+                        location: range_of_offense(node),
                         message: MSG_REQUIRE_NO_SPACE)
           end
         end
@@ -51,11 +46,9 @@ module RuboCop
           children = lambda_node.parent.children
           lambda do |corrector|
             if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
+              corrector.insert_before(children[1], ' ')
             else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
+              corrector.remove(space_after_arrow(lambda_node))
             end
           end
         end
@@ -63,27 +56,25 @@ module RuboCop
         private
 
         def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
+          node.lambda_literal? && node.parent.arguments?
         end
 
-        def lambda_node?(node)
-          receiver, call = *node
-          receiver.nil? && call == :lambda
+        def space_after_arrow?(lambda_node)
+          !space_after_arrow(lambda_node).empty?
         end
 
-        def arrow_form?(lambda_node)
-          lambda_node.loc.selector.source == ARROW
-        end
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
 
-        def args?(lambda_node)
-          _call, args, _body = *lambda_node.parent
-          !args.children.empty?
+          arrow.end.join(parentheses.begin)
         end
 
-        def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          parentheses.source_range.begin_pos - arrow.source_range.end_pos > 0
+        def range_of_offense(node)
+          range_between(
+            node.parent.loc.expression.begin_pos,
+            node.parent.arguments.loc.expression.end_pos
+          )
         end
       end
     end

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that brackets used for array literals have or don't have
+      # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that array literals have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   array = [a, b, c, d]
+      #
+      #   # good
+      #   array = [ a, b, c, d ]
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that array literals have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   array = [ a, b, c, d ]
+      #
+      #   # good
+      #   array = [a, b, c, d]
+      #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style normally requires a space inside
+      #   # array brackets, with the exception that successive left
+      #   # or right brackets are collapsed together in nested arrays.
+      #
+      #   # bad
+      #   array = [ a, [ b, c ] ]
+      #   array = [
+      #     [ a ],
+      #     [ b, c ]
+      #   ]
+      #
+      #   # good
+      #   array = [ a, [ b, c ]]
+      #   array = [[ a ],
+      #     [ b, c ]]
+      #
+      # @example EnforcedStyleForEmptyBrackets: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty array brackets do not contain spaces.
+      #
+      #   # bad
+      #   foo = [ ]
+      #   bar = [     ]
+      #
+      #   # good
+      #   foo = []
+      #   bar = []
+      #
+      # @example EnforcedStyleForEmptyBrackets: space
+      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty array brackets contain exactly one space.
+      #
+      #   # bad
+      #   foo = []
+      #   bar = [    ]
+      #
+      #   # good
+      #   foo = [ ]
+      #   bar = [ ]
+      #
+      class SpaceInsideArrayLiteralBrackets < Cop
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
+        MSG = '%<command>s space inside array brackets.'
+        EMPTY_MSG = '%<command>s space inside empty array brackets.'
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          left, right = array_brackets(node)
+          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
+
+          start_ok = next_to_newline?(node, left)
+          end_ok = node.single_line? ? false : end_has_own_line?(right)
+
+          issue_offenses(node, left, right, start_ok, end_ok)
+        end
+
+        def autocorrect(node)
+          left, right = array_brackets(node)
+
+          lambda do |corrector|
+            if empty_brackets?(left, right)
+              SpaceCorrector.empty_corrections(processed_source, corrector,
+                                               empty_config, left, right)
+            elsif style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector,
+                                          left, right)
+            elsif style == :space
+              SpaceCorrector.add_space(processed_source, corrector, left, right)
+            else
+              compact_corrections(corrector, node, left, right)
+            end
+          end
+        end
+
+        private
+
+        def array_brackets(node)
+          [left_array_bracket(node), right_array_bracket(node)]
+        end
+
+        def left_array_bracket(node)
+          tokens(node).find(&:left_array_bracket?)
+        end
+
+        def right_array_bracket(node)
+          tokens(node).reverse.find(&:right_bracket?)
+        end
+
+        def empty_config
+          cop_config['EnforcedStyleForEmptyBrackets']
+        end
+
+        def next_to_newline?(node, token)
+          tokens(node)[index_for(node, token) + 1].line != token.line
+        end
+
+        def end_has_own_line?(token)
+          line, col = line_and_column_for(token)
+          return true if col == -1
+
+          !/\S/.match?(processed_source.lines[line][0..col])
+        end
+
+        def index_for(node, token)
+          tokens(node).index(token)
+        end
+
+        def line_and_column_for(token)
+          [token.line - 1, token.column - 1]
+        end
+
+        def issue_offenses(node, left, right, start_ok, end_ok)
+          if style == :no_space
+            start_ok = next_to_comment?(node, left)
+            no_space_offenses(node, left, right, MSG, start_ok: start_ok,
+                                                      end_ok: end_ok)
+          elsif style == :space
+            space_offenses(node, left, right, MSG, start_ok: start_ok,
+                                                   end_ok: end_ok)
+          else
+            compact_offenses(node, left, right, start_ok, end_ok)
+          end
+        end
+
+        def next_to_comment?(node, token)
+          tokens(node)[index_for(node, token) + 1].comment?
+        end
+
+        def compact_offenses(node, left, right, start_ok, end_ok)
+          if qualifies_for_compact?(node, left, side: :left)
+            compact_offense(node, left, side: :left)
+          elsif !multi_dimensional_array?(node, left, side: :left)
+            space_offenses(node, left, nil, MSG, start_ok: start_ok,
+                                                 end_ok: true)
+          end
+          if qualifies_for_compact?(node, right)
+            compact_offense(node, right)
+          elsif !multi_dimensional_array?(node, right)
+            space_offenses(node, nil, right, MSG, start_ok: true,
+                                                  end_ok: end_ok)
+          end
+        end
+
+        def qualifies_for_compact?(node, token, side: :right)
+          if side == :right
+            multi_dimensional_array?(node, token) &&
+              !next_to_bracket?(token)
+          else
+            multi_dimensional_array?(node, token, side: :left) &&
+              !next_to_bracket?(token, side: :left)
+          end
+        end
+
+        def multi_dimensional_array?(node, token, side: :right)
+          i = index_for(node, token)
+          if side == :right
+            tokens(node)[i - 1].right_bracket?
+          else
+            tokens(node)[i + 1].left_array_bracket?
+          end
+        end
+
+        def next_to_bracket?(token, side: :right)
+          line_index, col = line_and_column_for(token)
+          line = processed_source.lines[line_index]
+          side == :right ? line[col] == ']' : line[col + 2] == '['
+        end
+
+        def compact_offense(node, token, side: :right)
+          if side == :right
+            space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
+          else
+            space_offense(node, token, :right, MSG, NO_SPACE_COMMAND)
+          end
+        end
+
+        def compact_corrections(corrector, node, left, right)
+          if qualifies_for_compact?(node, left, side: :left)
+            compact(corrector, left, :right)
+          elsif !left.space_after?
+            corrector.insert_after(left.pos, ' ')
+          end
+          if qualifies_for_compact?(node, right)
+            compact(corrector, right, :left)
+          elsif !right.space_before?
+            corrector.insert_before(right.pos, ' ')
+          end
+        end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

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

@@ -7,18 +7,18 @@ module RuboCop
       # (i.e. %i/%w).
       #
       # @example
-      #   @good
-      #   %i(foo bar baz)
       #
-      #   @bad
+      #   # bad
       #   %w(foo  bar  baz)
+      #   # good
+      #   %i(foo bar baz)
       class SpaceInsideArrayPercentLiteral < Cop
         include MatchRange
         include PercentLiteral
 
-        MSG = 'Use only a single space inside array percent literal.'.freeze
+        MSG = 'Use only a single space inside array percent literal.'
         MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
-          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/
+          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')