rubocop 0.52.1 → 0.53.0

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

@@ -20,6 +20,7 @@ module RuboCop
       #   a**b
       class SpaceAroundOperators < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
 
@@ -110,34 +111,35 @@ module RuboCop
             !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
-        def check_operator(op, right_operand)
-          with_space = range_with_surrounding_space(range: op)
+        def check_operator(operator, right_operand)
+          with_space = range_with_surrounding_space(range: operator)
           return if with_space.source.start_with?("\n")
 
-          offense(op, with_space, right_operand) do |msg|
-            add_offense(with_space, location: op, message: msg)
+          offense(operator, with_space, right_operand) do |msg|
+            add_offense(with_space, location: operator, message: msg)
           end
         end
 
-        def offense(op, with_space, right_operand)
-          msg = offense_message(op, with_space, right_operand)
+        def offense(operator, with_space, right_operand)
+          msg = offense_message(operator, with_space, right_operand)
           yield msg if msg
         end
 
-        def offense_message(op, with_space, right_operand)
-          if op.is?('**')
+        def offense_message(operator, with_space, right_operand)
+          if operator.is?('**')
             'Space around operator `**` detected.' unless with_space.is?('**')
           elsif with_space.source !~ /^\s.*\s$/
-            "Surrounding space missing for operator `#{op.source}`."
-          elsif excess_leading_space?(op, with_space) ||
+            "Surrounding space missing for operator `#{operator.source}`."
+          elsif excess_leading_space?(operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
-            "Operator `#{op.source}` should be surrounded by a single space."
+            "Operator `#{operator.source}` should be surrounded " \
+            'by a single space.'
           end
         end
 
-        def excess_leading_space?(op, with_space)
+        def excess_leading_space?(operator, with_space)
           with_space.source =~ /^  / &&
-            (!allow_for_alignment? || !aligned_with_operator?(op))
+            (!allow_for_alignment? || !aligned_with_operator?(operator))
         end
 
         def excess_trailing_space?(right_operand, with_space)

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,8 +16,20 @@ 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
+      #   }
       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

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

@@ -16,10 +16,12 @@ module RuboCop
         MSG = 'Put a space before an end-of-line comment.'.freeze
 
         def investigate(processed_source)
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            next unless t2.comment?
-            next unless t1.line == t2.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
+            if token1.pos.end == token2.pos.begin
+              add_offense(token2.pos, location: token2.pos)
+            end
           end
         end
 

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

@@ -23,6 +23,7 @@ module RuboCop
       #
       class SpaceBeforeFirstArg < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
 
         MSG = 'Put one space between the method name and ' \
               'the first argument.'.freeze

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

@@ -21,6 +21,7 @@ module RuboCop
       #     a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         ARROW = '->'.freeze
         MSG_REQUIRE_SPACE = 'Use a space between `->` and opening brace ' \

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

@@ -16,7 +16,7 @@ module RuboCop
       #   # good
       #   array = [ a, b, c, d ]
       #
-      # @example EnforcedStyle: no_space
+      # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
       #
@@ -36,6 +36,32 @@ module RuboCop
       #
       #   # good
       #   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
@@ -47,7 +73,7 @@ module RuboCop
           return unless node.square_brackets?
           left, right = array_brackets(node)
           if empty_brackets?(left, right)
-            return empty_offenses(node, left, right)
+            return empty_offenses(node, left, right, EMPTY_MSG)
           end
 
           start_ok = next_to_newline?(node, left)
@@ -61,7 +87,8 @@ module RuboCop
 
           lambda do |corrector|
             if empty_brackets?(left, right)
-              empty_corrections(corrector, left, right)
+              SpaceCorrector.empty_corrections(processed_source, corrector,
+                                               empty_config, left, right)
             elsif style == :no_space
               SpaceCorrector.remove_space(processed_source, corrector,
                                           left, right)
@@ -87,52 +114,10 @@ module RuboCop
           tokens(node).reverse.find(&:right_bracket?)
         end
 
-        def empty_brackets?(left, right)
-          processed_source.tokens.index(left) ==
-            processed_source.tokens.index(right) - 1
-        end
-
-        def empty_offenses(node, left, right)
-          empty_offense(node, 'Use one') if offending_empty_space?(left, right)
-          return unless offending_empty_no_space?(left, right)
-          empty_offense(node, 'Do not use')
-        end
-
-        def empty_offense(node, command)
-          add_offense(node, message: format(EMPTY_MSG, command: command))
-        end
-
-        def offending_empty_space?(left, right)
-          empty_config == 'space' && !space_between?(left, right)
-        end
-
-        def offending_empty_no_space?(left, right)
-          empty_config == 'no_space' && !no_space_between?(left, right)
-        end
-
-        def space_between?(left, right)
-          left.end_pos + 1 == right.begin_pos
-        end
-
-        def no_space_between?(left, right)
-          left.end_pos == right.begin_pos
-        end
-
         def empty_config
           cop_config['EnforcedStyleForEmptyBrackets']
         end
 
-        def empty_corrections(corrector, left, right)
-          if offending_empty_space?(left, right)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
-            corrector.insert_after(left.pos, ' ')
-          elsif offending_empty_no_space?(left, right)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
-          end
-        end
-
         def next_to_newline?(node, token)
           tokens(node)[index_for(node, token) + 1].line != token.line
         end

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

@@ -43,7 +43,7 @@ module RuboCop
       #
       # @example EnforcedStyleForEmptyBraces: space
       #   # The `space` EnforcedStyleForEmptyBraces style enforces that
-      #   # block braces have at least a spece in between when empty.
+      #   # block braces have at least a space in between when empty.
       #
       #   # bad
       #   some_array.each {}
@@ -65,7 +65,7 @@ module RuboCop
       #   # good
       #   [1, 2, 3].each { |n| n * 2 }
       #
-      # @example SpaceBeforeBlockParameters: true
+      # @example SpaceBeforeBlockParameters: false
       #   # The SpaceBeforeBlockParameters style set to `false` enforces that
       #   # there is no space between `{` and `|`. Overrides `EnforcedStyle`
       #   # if there is a conflict.
@@ -79,6 +79,7 @@ module RuboCop
       class SpaceInsideBlockBraces < Cop
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        include RangeHelp
 
         def on_block(node)
           return if node.keywords?

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
       #
-      # @example EnforcedStyle: space
+      # @example EnforcedStyle: space (default)
       #   # The `space` style enforces that hash literals have
       #   # surrounding space.
       #
@@ -36,11 +36,38 @@ module RuboCop
       #
       #   # good
       #   h = { a: { b: 2 }}
+      #
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+      #   # empty hash braces do not contain spaces.
+      #
+      #   # bad
+      #   foo = { }
+      #   bar = {    }
+      #
+      #   # good
+      #   foo = {}
+      #   bar = {}
+      #
+      # @example EnforcedStyleForEmptyBraces: space
+      #   # The `space` EnforcedStyleForEmptyBraces style enforces that
+      #   # empty hash braces contain space.
+      #
+      #   # bad
+      #   foo = {}
+      #
+      #   # good
+      #   foo = { }
+      #   foo = {  }
+      #   foo = {     }
+      #
       class SpaceInsideHashLiteralBraces < Cop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = 'Space inside %s.'.freeze
+        MSG = 'Space inside %<problem>s.'.freeze
 
         def on_hash(node)
           tokens = processed_source.tokens
@@ -83,24 +110,25 @@ module RuboCop
           yield begin_index, end_index
         end
 
-        def check(t1, t2)
+        def check(token1, token2)
           # No offense if line break inside.
-          return if t1.line < t2.line
-          return if t2.comment? # Also indicates there's a line break.
+          return if token1.line < token2.line
+          return if token2.comment? # Also indicates there's a line break.
 
-          is_empty_braces = t1.left_brace? && t2.right_curly_brace?
-          expect_space    = expect_space?(t1, t2)
+          is_empty_braces = token1.left_brace? && token2.right_curly_brace?
+          expect_space    = expect_space?(token1, token2)
 
-          if offense?(t1, expect_space)
-            incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
+          if offense?(token1, expect_space)
+            incorrect_style_detected(token1, token2,
+                                     expect_space, is_empty_braces)
           else
             correct_style_detected
           end
         end
 
-        def expect_space?(t1, t2)
-          is_same_braces  = t1.type == t2.type
-          is_empty_braces = t1.left_brace? && t2.right_curly_brace?
+        def expect_space?(token1, token2)
+          is_same_braces  = token1.type == token2.type
+          is_empty_braces = token1.left_brace? && token2.right_curly_brace?
 
           if is_same_braces && style == :compact
             false
@@ -111,8 +139,9 @@ module RuboCop
           end
         end
 
-        def incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
-          brace = (t1.text == '{' ? t1 : t2).pos
+        def incorrect_style_detected(token1, token2,
+                                     expect_space, is_empty_braces)
+          brace = (token1.text == '{' ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           add_offense(
             range,
@@ -120,7 +149,8 @@ module RuboCop
             message: message(brace, is_empty_braces, expect_space)
           ) do
             style = expect_space ? :no_space : :space
-            ambiguous_or_unexpected_style_detected(style, t1.text == t2.text)
+            ambiguous_or_unexpected_style_detected(style,
+                                                   token1.text == token2.text)
           end
         end
 
@@ -132,8 +162,8 @@ module RuboCop
           end
         end
 
-        def offense?(t1, expect_space)
-          has_space = t1.space_after?
+        def offense?(token1, expect_space)
+          has_space = token1.space_after?
           expect_space ? !has_space : has_space
         end
 
@@ -144,7 +174,7 @@ module RuboCop
                           brace.source
                         end
           problem = expect_space ? 'missing' : 'detected'
-          format(MSG, "#{inside_what} #{problem}")
+          format(MSG, problem: "#{inside_what} #{problem}")
         end
 
         def space_range(token_range)

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

@@ -15,6 +15,7 @@ module RuboCop
       #   g = (a + 3)
       class SpaceInsideParens < Cop
         include SurroundingSpace
+        include RangeHelp
 
         MSG = 'Space inside parentheses detected.'.freeze
 
@@ -32,20 +33,20 @@ module RuboCop
         private
 
         def each_extraneous_space(tokens)
-          tokens.each_cons(2) do |t1, t2|
-            next unless parens?(t1, t2)
+          tokens.each_cons(2) do |token1, token2|
+            next unless parens?(token1, token2)
 
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
-            next if t2.comment?
-            next unless t2.line == t1.line && t1.space_after?
+            next if token2.comment?
+            next unless token2.line == token1.line && token1.space_after?
 
-            yield range_between(t1.end_pos, t2.begin_pos)
+            yield range_between(token1.end_pos, token2.begin_pos)
           end
         end
 
-        def parens?(t1, t2)
-          t1.left_parens? || t2.right_parens?
+        def parens?(token1, token2)
+          token1.left_parens? || token2.right_parens?
         end
       end
     end

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

@@ -29,17 +29,50 @@ module RuboCop
       #   # good
       #   hash[ :key ]
       #   array[ index ]
+      #
+      #
+      # @example EnforcedStyleForEmptyBrackets: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets do not contain spaces.
+      #
+      #   # bad
+      #   foo[ ]
+      #   foo[     ]
+      #
+      #   # good
+      #   foo[]
+      #
+      # @example EnforcedStyleForEmptyBrackets: space
+      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets contain exactly one space.
+      #
+      #   # bad
+      #   foo[]
+      #   foo[    ]
+      #
+      #   # good
+      #   foo[ ]
+      #
       class SpaceInsideReferenceBrackets < Cop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
 
         MSG = '%<command>s space inside reference brackets.'.freeze
+        EMPTY_MSG = '%<command>s space inside empty reference brackets.'.freeze
+
+        BRACKET_METHODS = %i[[] []=].freeze
 
         def on_send(node)
           return if node.multiline?
-          return unless left_ref_bracket(node)
-          left_token = left_ref_bracket(node)
-          right_token = closing_bracket(node, left_token)
+          return unless bracket_method?(node)
+          tokens = tokens(node)
+          left_token = left_ref_bracket(tokens)
+          return unless left_token
+          right_token = closing_bracket(tokens, left_token)
+
+          if empty_brackets?(left_token, right_token)
+            return empty_offenses(node, left_token, right_token, EMPTY_MSG)
+          end
 
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
@@ -52,7 +85,10 @@ module RuboCop
           lambda do |corrector|
             left, right = reference_brackets(node)
 
-            if style == :no_space
+            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)
             else
@@ -64,19 +100,25 @@ module RuboCop
         private
 
         def reference_brackets(node)
-          left = left_ref_bracket(node)
-          [left, closing_bracket(node, left)]
+          tokens = tokens(node)
+          left = left_ref_bracket(tokens)
+          [left, closing_bracket(tokens, left)]
         end
 
-        def left_ref_bracket(node)
-          tokens(node).reverse.find(&:left_ref_bracket?)
+        def bracket_method?(node)
+          _, method, = *node
+          BRACKET_METHODS.include?(method)
         end
 
-        def closing_bracket(node, opening_bracket)
-          i = tokens(node).index(opening_bracket)
+        def left_ref_bracket(tokens)
+          tokens.reverse.find(&:left_ref_bracket?)
+        end
+
+        def closing_bracket(tokens, opening_bracket)
+          i = tokens.index(opening_bracket)
           inner_left_brackets_needing_closure = 0
 
-          tokens(node)[i..-1].each do |token|
+          tokens[i..-1].each do |token|
             inner_left_brackets_needing_closure += 1 if token.left_bracket?
             inner_left_brackets_needing_closure -= 1 if token.right_bracket?
             if inner_left_brackets_needing_closure.zero? && token.right_bracket?
@@ -84,6 +126,10 @@ module RuboCop
             end
           end
         end
+
+        def empty_config
+          cop_config['EnforcedStyleForEmptyBrackets']
+        end
       end
     end
   end