rubocop 0.51.0 → 0.87.0

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

@@ -7,19 +7,107 @@ module RuboCop
       # them on configuration. For blocks taking parameters, it checks that the
       # left brace has or doesn't have trailing space depending on
       # configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # The `space` style enforces that block braces have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   some_array.each {puts e}
+      #
+      #   # good
+      #   some_array.each { puts e }
+      #
+      # @example EnforcedStyle: no_space
+      #   # The `no_space` style enforces that block braces don't
+      #   # have surrounding space.
+      #
+      #   # bad
+      #   some_array.each { puts e }
+      #
+      #   # good
+      #   some_array.each {puts e}
+      #
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces don't have a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {   }
+      #   some_array.each {  }
+      #   some_array.each { }
+      #
+      #   # good
+      #   some_array.each {}
+      #
+      # @example EnforcedStyleForEmptyBraces: space
+      #   # The `space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces have at least a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {}
+      #
+      #   # good
+      #   some_array.each { }
+      #   some_array.each {  }
+      #   some_array.each {   }
+      #
+      #
+      # @example SpaceBeforeBlockParameters: true (default)
+      #   # The SpaceBeforeBlockParameters style set to `true` enforces that
+      #   # there is a space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      # @example SpaceBeforeBlockParameters: false
+      #   # The SpaceBeforeBlockParameters style set to `false` enforces that
+      #   # there is no space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
       class SpaceInsideBlockBraces < Cop
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        include RangeHelp
 
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line empty braces. That means
+          # preventing auto-correction to single-line empty braces. It will
+          # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
+          # if auto-corrected to a single-line empty braces.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7363
+          return if node.body.nil? && node.multiline?
+
           left_brace = node.loc.begin
           right_brace = node.loc.end
 
           check_inside(node, left_brace, right_brace)
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{}' then corrector.replace(range, '{ }')
+            when '{|' then corrector.replace(range, '{ |')
+            else           corrector.insert_before(range, ' ')
+            end
+          end
+        end
+
         private
 
         def check_inside(node, left_brace, right_brace)
@@ -29,7 +117,7 @@ module RuboCop
             range = range_between(left_brace.end_pos, right_brace.begin_pos)
             inner = range.source
 
-            if inner =~ /\S/
+            if /\S/.match?(inner)
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
@@ -49,26 +137,38 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.end, block_length(node))
+          check_right_brace(inner, node.loc.begin, node.loc.end,
+                            node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
-          if inner =~ /\A\S/
+          if /\A\S/.match?(inner)
             no_space_inside_left_brace(left_brace, args_delimiter)
           else
             space_inside_left_brace(left_brace, args_delimiter)
           end
         end
 
-        def check_right_brace(inner, right_brace, block_length)
-          if inner =~ /\S$/ && block_length.zero?
+        def check_right_brace(inner, left_brace, right_brace, single_line)
+          if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(left_brace, right_brace)
+
             space_inside_right_brace(right_brace)
           end
         end
 
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(left_brace, right_brace)
+          left_brace.first_line == right_brace.last_column
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
@@ -96,18 +196,20 @@ module RuboCop
               end
             end
           else
-            brace_with_space = range_with_surrounding_space(left_brace, :right)
+            brace_with_space = range_with_surrounding_space(range: left_brace,
+                                                            side: :right)
             space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
         end
 
         def pipe?(args_delimiter)
-          args_delimiter && args_delimiter.is?('|')
+          args_delimiter&.is?('|')
         end
 
         def space_inside_right_brace(right_brace)
-          brace_with_space = range_with_surrounding_space(right_brace, :left)
+          brace_with_space = range_with_surrounding_space(range: right_brace,
+                                                          side: :left)
           space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
                 'Space inside } detected.')
         end
@@ -140,17 +242,6 @@ module RuboCop
           else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
           end
         end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{}' then corrector.replace(range, '{ }')
-            when '{|' then corrector.replace(range, '{ |')
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
       end
     end
   end

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

@@ -5,11 +5,70 @@ module RuboCop
     module Layout
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # The `space` style enforces that hash literals have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   h = {a: 1, b: 2}
+      #
+      #   # good
+      #   h = { a: 1, b: 2 }
+      #
+      # @example EnforcedStyle: no_space
+      #   # The `no_space` style enforces that hash literals have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   h = { a: 1, b: 2 }
+      #
+      #   # good
+      #   h = {a: 1, b: 2}
+      #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style normally requires a space inside
+      #   # hash braces, with the exception that successive left
+      #   # braces or right braces are collapsed together in nested hashes.
+      #
+      #   # bad
+      #   h = { a: { b: 2 } }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
+      #
+      #   # good
+      #   h = { a: { b: 2 }}
+      #   foo = {{ a: 1 } => { b: { c: 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.'
 
         def on_hash(node)
           tokens = processed_source.tokens
@@ -22,45 +81,48 @@ module RuboCop
           end
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{' then corrector.insert_after(range, ' ')
+            else corrector.insert_before(range, ' ')
+            end
+          end
+        end
+
         private
 
         def hash_literal_with_braces(node)
           tokens = processed_source.tokens
           begin_index = index_of_first_token(node)
-          return unless left_brace?(tokens[begin_index])
+          return unless tokens[begin_index].left_brace?
 
           end_index = index_of_last_token(node)
-          return unless right_brace?(tokens[end_index])
+          return unless tokens[end_index].right_curly_brace?
 
           yield begin_index, end_index
         end
 
-        def left_brace?(token)
-          token.type == :tLBRACE
-        end
-
-        def right_brace?(token)
-          token.type == :tRCURLY
-        end
-
-        def check(t1, t2)
+        def check(token1, token2)
           # No offense if line break inside.
-          return if t1.pos.line < t2.pos.line
-          return if t2.type == :tCOMMENT # 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 = left_brace?(t1) && right_brace?(t2)
-          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, t2, 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 = left_brace?(t1) && right_brace?(t2)
+        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
@@ -71,8 +133,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,
@@ -80,7 +143,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
 
@@ -92,8 +156,8 @@ module RuboCop
           end
         end
 
-        def offense?(t1, t2, expect_space)
-          has_space = space_between?(t1, t2)
+        def offense?(token1, expect_space)
+          has_space = token1.space_after?
           expect_space ? !has_space : has_space
         end
 
@@ -104,24 +168,7 @@ module RuboCop
                           brace.source
                         end
           problem = expect_space ? 'missing' : 'detected'
-          format(MSG, "#{inside_what} #{problem}")
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            # It is possible that BracesAroundHashParameters will remove the
-            # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code. If we replace the brace with a
-            # brace plus space (rather than just inserting a space), then any
-            # removal of the same brace will give us a clobbering error. This
-            # in turn will make RuboCop fall back on cop-by-cop
-            # auto-correction.  Problem solved.
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{' then corrector.replace(range, '{ ')
-            else corrector.replace(range, ' }')
-            end
-          end
+          format(MSG, problem: "#{inside_what} #{problem}")
         end
 
         def space_range(token_range)
@@ -135,7 +182,7 @@ module RuboCop
         def range_of_space_to_the_right(range)
           src = range.source_buffer.source
           end_pos = range.end_pos
-          end_pos += 1 while src[end_pos] =~ /[ \t]/
+          end_pos += 1 while /[ \t]/.match?(src[end_pos])
 
           range_between(range.begin_pos + 1, end_pos)
         end
@@ -143,7 +190,7 @@ module RuboCop
         def range_of_space_to_the_left(range)
           src = range.source_buffer.source
           begin_pos = range.begin_pos
-          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
+          begin_pos -= 1 while /[ \t]/.match?(src[begin_pos - 1])
 
           range_between(begin_pos, range.end_pos - 1)
         end

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

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # Checks for spaces inside ordinary round parentheses.
       #
-      # @example
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that parentheses do not have spaces.
+      #
       #   # bad
       #   f( 3)
       #   g = (a + 3 )
@@ -13,11 +15,97 @@ module RuboCop
       #   # good
       #   f(3)
       #   g = (a + 3)
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that parentheses have a space at the
+      #   # beginning and end.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #
       class SpaceInsideParens < Cop
-        include SpaceInside
+        include SurroundingSpace
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+
+        MSG       = 'Space inside parentheses detected.'
+        MSG_SPACE = 'No space inside parentheses detected.'
+
+        def investigate(processed_source)
+          @processed_source = processed_source
+
+          if style == :space
+            each_missing_space(processed_source.tokens) do |range|
+              add_offense(range, location: range, message: MSG_SPACE)
+            end
+          else
+            each_extraneous_space(processed_source.tokens) do |range|
+              add_offense(range, location: range)
+            end
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            if style == :space
+              corrector.insert_before(range, ' ')
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        private
+
+        def each_extraneous_space(tokens)
+          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 token2.comment?
+            next unless same_line?(token1, token2) && token1.space_after?
+
+            yield range_between(token1.end_pos, token2.begin_pos)
+          end
+        end
+
+        def each_missing_space(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            next if can_be_ignored?(token1, token2)
+
+            if token1.left_parens?
+              yield range_between(token2.begin_pos, token2.begin_pos + 1)
+            elsif token2.right_parens?
+              yield range_between(token2.begin_pos, token2.end_pos)
+            end
+          end
+        end
+
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
+        def parens?(token1, token2)
+          token1.left_parens? || token2.right_parens?
+        end
+
+        def can_be_ignored?(token1, token2)
+          return true 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.
+          return true if token2.comment?
 
-        def specifics
-          [%i[tLPAREN tLPAREN2], :tRPAREN, 'parentheses']
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

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

@@ -20,9 +20,9 @@ module RuboCop
         include MatchRange
         include PercentLiteral
 
-        MSG = 'Do not use spaces inside percent literal delimiters.'.freeze
-        BEGIN_REGEX = /\A( +)/
-        END_REGEX = /(?<!\\)( +)\z/
+        MSG = 'Do not use spaces inside percent literal delimiters.'
+        BEGIN_REGEX = /\A( +)/.freeze
+        END_REGEX = /(?<!\\)( +)\z/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #   'a'..'z'
       class SpaceInsideRangeLiteral < Cop
-        MSG = 'Space inside range literal.'.freeze
+        MSG = 'Space inside range literal.'
 
         def on_irange(node)
           check(node)
@@ -28,21 +28,6 @@ module RuboCop
           check(node)
         end
 
-        private
-
-        def check(node)
-          expression = node.source
-          op = node.loc.operator.source
-          escaped_op = op.gsub(/\./, '\.')
-
-          # account for multiline range literals
-          expression.sub!(/#{escaped_op}\n\s*/, op)
-
-          return unless expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
-
-          add_offense(node)
-        end
-
         def autocorrect(node)
           expression = node.source
           operator = node.loc.operator.source
@@ -50,13 +35,28 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(
-              node.source_range,
+              node,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)
             )
           end
         end
+
+        private
+
+        def check(node)
+          expression = node.source
+          op = node.loc.operator.source
+          escaped_op = op.gsub(/\./, '\.')
+
+          # account for multiline range literals
+          expression.sub!(/#{escaped_op}\n\s*/, op)
+
+          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
+
+          add_offense(node)
+        end
       end
     end
   end