rubocop 0.76.0 → 1.50.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for space between the name of a receiver and a left
+      # brackets.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection [index_or_key]
+      #
+      #   # good
+      #   collection[index_or_key]
+      #
+      class SpaceBeforeBrackets < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the space before the opening brackets.'
+        RESTRICT_ON_SEND = %i[[] []=].freeze
+
+        def on_send(node)
+          return unless (first_argument = node.first_argument)
+
+          begin_pos = first_argument.source_range.begin_pos
+          return unless (range = offense_range(node, begin_pos))
+
+          register_offense(range)
+        end
+
+        private
+
+        def offense_range(node, begin_pos)
+          if reference_variable_with_brackets?(node)
+            receiver_end_pos = node.receiver.source_range.end_pos
+            selector_begin_pos = node.loc.selector.begin_pos
+            return if receiver_end_pos >= selector_begin_pos
+            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+
+            range_between(receiver_end_pos, selector_begin_pos)
+          elsif node.method?(:[]=)
+            offense_range_for_assignment(node, begin_pos)
+          end
+        end
+
+        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
+
+          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
+        end
+
+        def offense_range_for_assignment(node, begin_pos)
+          end_pos = node.receiver.source_range.end_pos
+
+          return if begin_pos - end_pos == 1 ||
+                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
+
+          range
+        end
+
+        def register_offense(range)
+          add_offense(range) { |corrector| corrector.remove(range) }
+        end
+
+        def reference_variable_with_brackets?(node)
+          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
+        end
+      end
+    end
+  end
+end

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

@@ -15,12 +15,10 @@ module RuboCop
       #   [1, 2, 3]
       #   a(1, 2)
       #   each { |a, b| }
-      class SpaceBeforeComma < Cop
+      #
+      class SpaceBeforeComma < Base
         include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
+        extend AutoCorrector
 
         def kind(token)
           'comma' if token.comma?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for missing space between a token and a comment on the
+      # Checks for missing space between a token and a comment on the
       # same line.
       #
       # @example
@@ -12,22 +12,21 @@ module RuboCop
       #
       #   # good
       #   1 + 1 # this operation does ...
-      class SpaceBeforeComment < Cop
+      class SpaceBeforeComment < Base
+        extend AutoCorrector
+
         MSG = 'Put a space before an end-of-line comment.'
 
-        def investigate(processed_source)
-          processed_source.tokens.each_cons(2) do |token1, token2|
+        def on_new_investigation
+          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
-            next unless token1.line == token2.line
+            next unless same_line?(token1, token2)
+            next unless token1.pos.end == token2.pos.begin
 
-            if token1.pos.end == token2.pos.begin
-              add_offense(token2.pos, location: token2.pos)
-            end
-          end
-        end
+            range = token2.pos
 
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_before(range, ' ') }
+            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
+          end
         end
       end
     end

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

@@ -21,31 +21,31 @@ module RuboCop
       #   something y, z
       #   something 'hello'
       #
-      class SpaceBeforeFirstArg < Cop
+      class SpaceBeforeFirstArg < Base
         include PrecedingFollowingAlignment
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Put one space between the method name and ' \
-              'the first argument.'
+        MSG = 'Put one space between the method name and the first argument.'
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
-          return unless expect_params_after_method_name?(node)
+          return if node.parenthesized?
 
           first_arg = node.first_argument.source_range
-          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)
+          first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
+          space = range_between(first_arg_with_space.begin_pos, first_arg.begin_pos)
+          return if space.length == 1
+          return unless expect_params_after_method_name?(node)
 
-          add_offense(space, location: space) if space.length != 1
+          add_offense(space) { |corrector| corrector.replace(space, ' ') }
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          ->(corrector) { corrector.replace(range, ' ') }
-        end
-
         private
 
         def regular_method_call_with_arguments?(node)
@@ -53,13 +53,19 @@ module RuboCop
         end
 
         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
 
           same_line?(first_arg, node) &&
-            !(allow_for_alignment? &&
-              aligned_with_something?(first_arg.source_range))
+            !(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

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

@@ -11,12 +11,9 @@ module RuboCop
       #
       #   # good
       #   x = 1; y = 2
-      class SpaceBeforeSemicolon < Cop
+      class SpaceBeforeSemicolon < Base
         include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
+        extend AutoCorrector
 
         def kind(token)
           'semicolon' if token.semicolon?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for spaces between `->` and opening parameter
+      # Checks for spaces between `->` and opening parameter
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
@@ -19,36 +19,28 @@ module RuboCop
       #
       #     # good
       #     a = -> (x, y) { x + y }
-      class SpaceInLambdaLiteral < Cop
+      class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
-                            '`(` in lambda literals.'
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
-                               '`(` in lambda literals.'
+        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: range_of_offense(node),
-                        message: MSG_REQUIRE_SPACE)
+            lambda_node = range_of_offense(node)
+
+            add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
+              corrector.insert_before(lambda_arguments(node), ' ')
+            end
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(node,
-                        location: range_of_offense(node),
-                        message: MSG_REQUIRE_NO_SPACE)
-          end
-        end
+            space = space_after_arrow(node)
 
-        def autocorrect(lambda_node)
-          children = lambda_node.parent.children
-          lambda do |corrector|
-            if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
-            else
-              corrector.remove(space_after_arrow(lambda_node))
+            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space)
             end
           end
         end
@@ -72,10 +64,14 @@ module RuboCop
 
         def range_of_offense(node)
           range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
           )
         end
+
+        def lambda_arguments(node)
+          node.parent.children[1]
+        end
       end
     end
   end

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

@@ -6,16 +6,6 @@ module RuboCop
       # 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.
@@ -26,6 +16,16 @@ module RuboCop
       #   # good
       #   array = [a, b, c, d]
       #
+      # @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: compact
       #   # The `compact` style normally requires a space inside
       #   # array brackets, with the exception that successive left
@@ -67,9 +67,10 @@ module RuboCop
       #   foo = [ ]
       #   bar = [ ]
       #
-      class SpaceInsideArrayLiteralBrackets < Cop
+      class SpaceInsideArrayLiteralBrackets < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '%<command>s space inside array brackets.'
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
@@ -77,8 +78,9 @@ module RuboCop
         def on_array(node)
           return unless node.square_brackets?
 
-          left, right = array_brackets(node)
-          if empty_brackets?(left, right)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
             return empty_offenses(node, left, right, EMPTY_MSG)
           end
 
@@ -88,36 +90,29 @@ module RuboCop
           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
+        private
+
+        def autocorrect(corrector, node)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            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
 
-        private
-
         def array_brackets(node)
-          [left_array_bracket(node), right_array_bracket(node)]
-        end
+          tokens = processed_source.tokens_within(node)
 
-        def left_array_bracket(node)
-          tokens(node).find(&:left_array_bracket?)
-        end
+          left = tokens.find(&:left_array_bracket?)
+          right = tokens.reverse_each.find(&:right_bracket?)
 
-        def right_array_bracket(node)
-          tokens(node).reverse.find(&:right_bracket?)
+          [tokens, left, right]
         end
 
         def empty_config
@@ -125,18 +120,18 @@ module RuboCop
         end
 
         def next_to_newline?(node, token)
-          tokens(node)[index_for(node, token) + 1].line != token.line
+          processed_source.tokens_within(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
 
-          processed_source.lines[line][0..col] !~ /\S/
+          !/\S/.match?(processed_source.lines[line][0..col])
         end
 
         def index_for(node, token)
-          tokens(node).index(token)
+          processed_source.tokens_within(node).index(token)
         end
 
         def line_and_column_for(token)
@@ -144,53 +139,50 @@ module RuboCop
         end
 
         def issue_offenses(node, left, right, start_ok, end_ok)
-          if style == :no_space
+          case style
+          when :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)
+            no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
+          when :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?
+          processed_source.tokens_within(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)
+            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)
+            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)
+            multi_dimensional_array?(node, token) && token.space_before?
           else
-            multi_dimensional_array?(node, token, side: :left) &&
-              !next_to_bracket?(token, side: :left)
+            multi_dimensional_array?(node, token, side: :left) && token.space_after?
           end
         end
 
         def multi_dimensional_array?(node, token, side: :right)
-          i = index_for(node, token)
+          offset = side == :right ? -1 : +1
+          i = index_for(node, token) + offset
+          i += offset while processed_source.tokens_within(node)[i].new_line?
           if side == :right
-            tokens(node)[i - 1].right_bracket?
+            processed_source.tokens_within(node)[i].right_bracket?
           else
-            tokens(node)[i + 1].left_array_bracket?
+            processed_source.tokens_within(node)[i].left_array_bracket?
           end
         end
 
@@ -209,12 +201,13 @@ module RuboCop
         end
 
         def compact_corrections(corrector, node, left, right)
-          if qualifies_for_compact?(node, left, side: :left)
+          if multi_dimensional_array?(node, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
-          if qualifies_for_compact?(node, right)
+
+          if multi_dimensional_array?(node, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
@@ -222,7 +215,7 @@ module RuboCop
         end
 
         def compact(corrector, bracket, side)
-          range = side_space_range(range: bracket.pos, side: side)
+          range = side_space_range(range: bracket.pos, side: side, include_newlines: true)
           corrector.remove(range)
         end
       end

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

@@ -6,19 +6,22 @@ module RuboCop
       # Checks for unnecessary additional spaces inside array percent literals
       # (i.e. %i/%w).
       #
+      # Note that blank percent literals (e.g. `%i( )`) are checked by
+      # `Layout/SpaceInsidePercentLiteralDelimiters`.
+      #
       # @example
       #
       #   # bad
       #   %w(foo  bar  baz)
       #   # good
       #   %i(foo bar baz)
-      class SpaceInsideArrayPercentLiteral < Cop
+      class SpaceInsideArrayPercentLiteral < Base
         include MatchRange
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Use only a single space inside array percent literal.'
-        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
-          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')
@@ -26,13 +29,7 @@ module RuboCop
 
         def on_percent_literal(node)
           each_unnecessary_space_match(node) do |range|
-            add_offense(node, location: range)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            each_unnecessary_space_match(node) do |range|
+            add_offense(range) do |corrector|
               corrector.replace(range, ' ')
             end
           end
@@ -41,11 +38,7 @@ module RuboCop
         private
 
         def each_unnecessary_space_match(node, &blk)
-          each_match_range(
-            contents_range(node),
-            MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX,
-            &blk
-          )
+          each_match_range(contents_range(node), MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX, &blk)
         end
       end
     end