rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/space_inside_hash_literal_braces.rb

@@ -1,11 +1,41 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: space
+      #   # 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 } }
+      #
+      #   # good
+      #   h = { a: { b: 2 }}
       class SpaceInsideHashLiteralBraces < Cop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
@@ -13,30 +43,55 @@ module RuboCop
         MSG = 'Space inside %s.'.freeze
 
         def on_hash(node)
-          b_ix = index_of_first_token(node)
           tokens = processed_source.tokens
 
-          # Hash literal with braces?
-          return unless tokens[b_ix].type == :tLBRACE
+          hash_literal_with_braces(node) do |begin_index, end_index|
+            check(tokens[begin_index], tokens[begin_index + 1])
+            return if begin_index == end_index - 1
 
-          e_ix = index_of_last_token(node)
-          return unless tokens[e_ix].type == :tRCURLY
+            check(tokens[end_index - 1], tokens[end_index])
+          end
+        end
 
-          check(tokens[b_ix], tokens[b_ix + 1])
-          check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
+        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
         end
 
         private
 
+        def hash_literal_with_braces(node)
+          tokens = processed_source.tokens
+          begin_index = index_of_first_token(node)
+          return unless tokens[begin_index].left_brace?
+
+          end_index = index_of_last_token(node)
+          return unless tokens[end_index].right_curly_brace?
+
+          yield begin_index, end_index
+        end
+
         def check(t1, t2)
           # 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 t1.line < t2.line
+          return if t2.comment? # Also indicates there's a line break.
 
-          is_empty_braces = t1.text == '{' && t2.text == '}'
+          is_empty_braces = t1.left_brace? && t2.right_curly_brace?
           expect_space    = expect_space?(t1, t2)
 
-          if offense?(t1, t2, expect_space)
+          if offense?(t1, expect_space)
             incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           else
             correct_style_detected
@@ -44,8 +99,8 @@ module RuboCop
         end
 
         def expect_space?(t1, t2)
-          is_same_braces  = t1.text == t2.text
-          is_empty_braces = t1.text == '{' && t2.text == '}'
+          is_same_braces  = t1.type == t2.type
+          is_empty_braces = t1.left_brace? && t2.right_curly_brace?
 
           if is_same_braces && style == :compact
             false
@@ -59,24 +114,26 @@ module RuboCop
         def incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           brace = (t1.text == '{' ? t1 : t2).pos
           range = expect_space ? brace : space_range(brace)
-          add_offense(range, range,
-                      message(brace, is_empty_braces, expect_space)) do
-            if expect_space
-              if t1.text == t2.text
-                ambiguous_style_detected(:no_space, :compact)
-              else
-                unexpected_style_detected(:no_space)
-              end
-            elsif t1.text == t2.text
-              unexpected_style_detected(:space)
-            else
-              ambiguous_style_detected(:space, :compact)
-            end
+          add_offense(
+            range,
+            location: range,
+            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)
           end
         end
 
-        def offense?(t1, t2, expect_space)
-          has_space = space_between?(t1, t2)
+        def ambiguous_or_unexpected_style_detected(style, is_match)
+          if is_match
+            ambiguous_style_detected(style, :compact)
+          else
+            unexpected_style_detected(style)
+          end
+        end
+
+        def offense?(t1, expect_space)
+          has_space = t1.space_after?
           expect_space ? !has_space : has_space
         end
 
@@ -90,23 +147,6 @@ module RuboCop
           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
-        end
-
         def space_range(token_range)
           if token_range.source == '{'
             range_of_space_to_the_right(token_range)
@@ -119,16 +159,16 @@ module RuboCop
           src = range.source_buffer.source
           end_pos = range.end_pos
           end_pos += 1 while src[end_pos] =~ /[ \t]/
-          Parser::Source::Range.new(range.source_buffer,
-                                    range.begin_pos + 1, end_pos)
+
+          range_between(range.begin_pos + 1, end_pos)
         end
 
         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]/
-          Parser::Source::Range.new(range.source_buffer, begin_pos,
-                                    range.end_pos - 1)
+
+          range_between(begin_pos, range.end_pos - 1)
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for spaces inside ordinary round parentheses.
+      #
+      # @example
+      #   # bad
+      #   f( 3)
+      #   g = (a + 3 )
+      #
+      #   # good
+      #   f(3)
+      #   g = (a + 3)
+      class SpaceInsideParens < Cop
+        include SurroundingSpace
+
+        MSG = 'Space inside parentheses detected.'.freeze
+
+        def investigate(processed_source)
+          @processed_source = processed_source
+          each_extraneous_space(processed_source.tokens) do |range|
+            add_offense(range, location: range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def each_extraneous_space(tokens)
+          tokens.each_cons(2) do |t1, t2|
+            next unless parens?(t1, t2)
+
+            # 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?
+
+            yield range_between(t1.end_pos, t2.begin_pos)
+          end
+        end
+
+        def parens?(t1, t2)
+          t1.left_parens? || t2.right_parens?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/space_inside_percent_literal_delimiters.rb

@@ -1,20 +1,21 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks for unnecessary additional spaces inside the delimiters of
       # %i/%w/%x literals.
       #
-      # @good
-      # %i(foo bar baz)
+      # @example
       #
-      # @bad
-      # %w( foo bar baz )
+      #   # good
+      #   %i(foo bar baz)
       #
-      # @bad
-      # %x(  ls -l )
+      #   # bad
+      #   %w( foo bar baz )
+      #
+      #   # bad
+      #   %x(  ls -l )
       class SpaceInsidePercentLiteralDelimiters < Cop
         include MatchRange
         include PercentLiteral
@@ -24,14 +25,14 @@ module RuboCop
         END_REGEX = /(?<!\\)( +)\z/
 
         def on_array(node)
-          process(node, *%w(%i %I %w %W))
+          process(node, '%i', '%I', '%w', '%W')
         end
 
-        def on_percent_literal(node)
-          add_offenses_for_unnecessary_spaces(node)
+        def on_xstr(node)
+          process(node, '%x')
         end
 
-        def on_xstr(node)
+        def on_percent_literal(node)
           add_offenses_for_unnecessary_spaces(node)
         end
 
@@ -49,7 +50,7 @@ module RuboCop
           return unless node.single_line?
 
           regex_matches(node) do |match_range|
-            add_offense(node, match_range, MSG)
+            add_offense(node, location: match_range)
           end
         end
 

data/lib/rubocop/cop/{style → layout}/space_inside_range_literal.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks for spaces inside range literals.
       #
       # @example
@@ -29,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, :expression)
-        end
-
         def autocorrect(node)
           expression = node.source
           operator = node.loc.operator.source
@@ -58,6 +42,21 @@ module RuboCop
             )
           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 expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
+
+          add_offense(node)
+        end
       end
     end
   end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that reference brackets have or don't have
+      # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that reference brackets have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   hash[ :key ]
+      #   array[ index ]
+      #
+      #   # good
+      #   hash[:key]
+      #   array[index]
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that reference brackets have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   hash[:key]
+      #   array[index]
+      #
+      #   # good
+      #   hash[ :key ]
+      #   array[ index ]
+      class SpaceInsideReferenceBrackets < Cop
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
+        MSG = '%<command>s space inside reference brackets.'.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)
+
+          if style == :no_space
+            no_space_offenses(node, left_token, right_token, MSG)
+          else
+            space_offenses(node, left_token, right_token, MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            left, right = reference_brackets(node)
+
+            if style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector,
+                                          left, right)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, left, right)
+            end
+          end
+        end
+
+        private
+
+        def reference_brackets(node)
+          left = left_ref_bracket(node)
+          [left, closing_bracket(node, left)]
+        end
+
+        def left_ref_bracket(node)
+          tokens(node).reverse.find(&:left_ref_bracket?)
+        end
+
+        def closing_bracket(node, opening_bracket)
+          i = tokens(node).index(opening_bracket)
+          inner_left_brackets_needing_closure = 0
+
+          tokens(node)[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?
+              return token
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for whitespace within string interpolations.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # bad
+      #      var = "This is the #{ space } example"
+      #
+      #   # good
+      #      var = "This is the #{no_space} example"
+      #
+      # @example EnforcedStyle: space
+      #   # bad
+      #      var = "This is the #{no_space} example"
+      #
+      #   # good
+      #      var = "This is the #{ space } example"
+      class SpaceInsideStringInterpolation < Cop
+        include ConfigurableEnforcedStyle
+
+        NO_SPACE_MSG = 'Space inside string interpolation detected.'.freeze
+        SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
+
+        def on_dstr(node)
+          each_style_violation(node) do |final_node|
+            add_offense(final_node)
+          end
+        end
+
+        def autocorrect(node)
+          new_source = style == :no_space ? node.source : " #{node.source} "
+          lambda do |corrector|
+            corrector.replace(
+              range_with_surrounding_space(range: node.source_range),
+              new_source
+            )
+          end
+        end
+
+        private
+
+        def each_style_violation(node)
+          node.each_child_node(:begin) do |begin_node|
+            final_node = begin_node.children.last
+            next unless final_node
+
+            if style == :no_space && space_on_any_side?(final_node)
+              yield final_node
+            elsif style == :space && !space_on_each_side?(final_node)
+              yield final_node
+            end
+          end
+        end
+
+        def message(_node)
+          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
+        end
+
+        def space_on_any_side?(node)
+          interp = node.source_range
+          interp_with_surrounding_space =
+            range_with_surrounding_space(range: interp)
+
+          interp_with_surrounding_space != interp
+        end
+
+        def space_on_each_side?(node)
+          interp = node.source_range
+          interp_with_surrounding_space =
+            range_with_surrounding_space(range: interp)
+
+          interp_with_surrounding_space.source == " #{interp.source} "
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/tab.rb

@@ -1,13 +1,14 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'set'
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for tabs inside the source code.
       class Tab < Cop
+        include Alignment
+
         MSG = 'Tab detected.'.freeze
 
         def investigate(processed_source)
@@ -23,18 +24,19 @@ module RuboCop
                                  index + 1,
                                  (spaces.length)...(match.end(0)))
 
-            add_offense(range, range, MSG)
+            add_offense(range, location: range)
           end
         end
 
-        private
-
         def autocorrect(range)
           lambda do |corrector|
-            corrector.replace(range, range.source.gsub(/\t/, '  '))
+            spaces = ' ' * configured_indentation_width
+            corrector.replace(range, range.source.gsub(/\t/, spaces))
           end
         end
 
+        private
+
         def string_literal_lines(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?

data/lib/rubocop/cop/{style → layout}/trailing_blank_lines.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop looks for trailing blank lines and a final newline in the
       # source code.
       class TrailingBlankLines < Cop
@@ -29,18 +28,24 @@ module RuboCop
                            whitespace_at_end)
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+
         private
 
         def offense_detected(sb, wanted_blank_lines, blank_lines,
                              whitespace_at_end)
           begin_pos = sb.source.length - whitespace_at_end.length
-          autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
-                                                        sb.source.length)
+          autocorrect_range = range_between(begin_pos, sb.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
-          report_range = Parser::Source::Range.new(sb, begin_pos,
-                                                   sb.source.length)
-          add_offense(autocorrect_range, report_range,
-                      message(wanted_blank_lines, blank_lines))
+          report_range = range_between(begin_pos, sb.source.length)
+
+          add_offense(autocorrect_range,
+                      location: report_range,
+                      message: message(wanted_blank_lines, blank_lines))
         end
 
         def ends_in_end?(processed_source)
@@ -49,7 +54,7 @@ module RuboCop
           return true if sb.source.strip.start_with?('__END__')
           return false if processed_source.tokens.empty?
 
-          extra = sb.source[processed_source.tokens.last.pos.end_pos..-1]
+          extra = sb.source[processed_source.tokens.last.end_pos..-1]
           extra && extra.strip.start_with?('__END__')
         end
 
@@ -69,12 +74,6 @@ module RuboCop
                    instead_of)
           end
         end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/{style → layout}/trailing_whitespace.rb

@@ -1,22 +1,21 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop looks for trailing whitespace in the source code.
       class TrailingWhitespace < Cop
         MSG = 'Trailing whitespace detected.'.freeze
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
-            next unless line =~ /.*[ \t]+$/
+            next unless line.end_with?(' ', "\t")
 
             range = source_range(processed_source.buffer,
                                  index + 1,
                                  (line.rstrip.length)...(line.length))
 
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end