rubbycop 0.49.0

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks that braces used for hash literals have or don't have
+      # surrounding space depending on configuration.
+      class SpaceInsideHashLiteralBraces < Cop
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Space inside %s.'.freeze
+
+        def on_hash(node)
+          tokens = processed_source.tokens
+
+          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
+
+            check(tokens[end_index - 1], tokens[end_index])
+          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])
+
+          end_index = index_of_last_token(node)
+          return unless right_brace?(tokens[end_index])
+
+          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)
+          # 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.
+
+          is_empty_braces = left_brace?(t1) && right_brace?(t2)
+          expect_space    = expect_space?(t1, t2)
+
+          if offense?(t1, t2, expect_space)
+            incorrect_style_detected(t1, t2, 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)
+
+          if is_same_braces && style == :compact
+            false
+          elsif is_empty_braces
+            cop_config['EnforcedStyleForEmptyBraces'] != 'no_space'
+          else
+            style != :no_space
+          end
+        end
+
+        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
+            style = expect_space ? :no_space : :space
+            ambiguous_or_unexpected_style_detected(style, t1.text == t2.text)
+          end
+        end
+
+        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, t2, expect_space)
+          has_space = space_between?(t1, t2)
+          expect_space ? !has_space : has_space
+        end
+
+        def message(brace, is_empty_braces, expect_space)
+          inside_what = if is_empty_braces
+                          'empty hash literal braces'
+                        else
+                          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 RubbyCop 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)
+          else
+            range_of_space_to_the_left(token_range)
+          end
+        end
+
+        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]/
+
+          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]/
+
+          range_between(begin_pos, range.end_pos - 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for spaces inside ordinary round parentheses.
+      class SpaceInsideParens < Cop
+        include SpaceInside
+
+        def specifics
+          [%i[tLPAREN tLPAREN2], :tRPAREN, 'parentheses']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for unnecessary additional spaces inside the delimiters of
+      # %i/%w/%x literals.
+      #
+      # @example
+      #   @good
+      #   %i(foo bar baz)
+      #
+      #   @bad
+      #   %w( foo bar baz )
+      #
+      #   @bad
+      #   %x(  ls -l )
+      class SpaceInsidePercentLiteralDelimiters < Cop
+        include MatchRange
+        include PercentLiteral
+
+        MSG = 'Do not use spaces inside percent literal delimiters.'.freeze
+        BEGIN_REGEX = /\A( +)/
+        END_REGEX = /(?<!\\)( +)\z/
+
+        def on_array(node)
+          process(node, '%i', '%I', '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          add_offenses_for_unnecessary_spaces(node)
+        end
+
+        def on_xstr(node)
+          add_offenses_for_unnecessary_spaces(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            regex_matches(node) do |match_range|
+              corrector.remove(match_range)
+            end
+          end
+        end
+
+        private
+
+        def add_offenses_for_unnecessary_spaces(node)
+          return unless node.single_line?
+
+          regex_matches(node) do |match_range|
+            add_offense(node, match_range, MSG)
+          end
+        end
+
+        def regex_matches(node, &blk)
+          [BEGIN_REGEX, END_REGEX].each do |regex|
+            each_match_range(contents_range(node), regex, &blk)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for spaces inside range literals.
+      #
+      # @example
+      #   # bad
+      #   1 .. 3
+      #
+      #   # good
+      #   1..3
+      #
+      #   # bad
+      #   'a' .. 'z'
+      #
+      #   # good
+      #   'a'..'z'
+      class SpaceInsideRangeLiteral < Cop
+        MSG = 'Space inside range literal.'.freeze
+
+        def on_irange(node)
+          check(node)
+        end
+
+        def on_erange(node)
+          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
+          operator_escaped = operator.gsub(/\./, '\.')
+
+          lambda do |corrector|
+            corrector.replace(
+              node.source_range,
+              expression
+                .sub(/\s+#{operator_escaped}/, operator)
+                .sub(/#{operator_escaped}\s+/, operator)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for whitespace within string interpolations.
+      #
+      # @example
+      #   # Good if EnforcedStyle is no_space, bad if space.
+      #      var = "This is the #{no_space} example"
+      #
+      #   # Good if EnforceStyle is space, bad if no_space.
+      #      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, msg|
+            add_offense(final_node, :expression, msg)
+          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, NO_SPACE_MSG
+            elsif style == :space && !space_on_each_side?(final_node)
+              yield final_node, SPACE_MSG
+            end
+          end
+        end
+
+        def space_on_any_side?(node)
+          interp = node.source_range
+          interp_with_surrounding_space = range_with_surrounding_space(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(interp)
+
+          interp_with_surrounding_space.source == " #{interp.source} "
+        end
+
+        def autocorrect(node)
+          new_source = style == :no_space ? node.source : " #{node.source} "
+          lambda do |corrector|
+            corrector.replace(range_with_surrounding_space(node.source_range),
+                              new_source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/tab.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for tabs inside the source code.
+      class Tab < Cop
+        MSG = 'Tab detected.'.freeze
+
+        def investigate(processed_source)
+          str_lines = string_literal_lines(processed_source.ast)
+
+          processed_source.lines.each_with_index do |line, index|
+            match = line.match(/^( *)[\t ]*\t/)
+            next unless match
+            next if str_lines.include?(index + 1)
+
+            spaces = match.captures[0]
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 (spaces.length)...(match.end(0)))
+
+            add_offense(range, range, MSG)
+          end
+        end
+
+        private
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, range.source.gsub(/\t/, '  '))
+          end
+        end
+
+        def string_literal_lines(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, lines|
+            loc = str.location
+
+            str_lines = if loc.is_a?(Parser::Source::Map::Heredoc)
+                          body = loc.heredoc_body
+                          (body.first_line)..(body.last_line)
+                        else
+                          (loc.first_line + 1)..(loc.last_line)
+                        end
+
+            lines.merge(str_lines.to_a)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/trailing_blank_lines.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop looks for trailing blank lines and a final newline in the
+      # source code.
+      class TrailingBlankLines < Cop
+        include ConfigurableEnforcedStyle
+
+        def investigate(processed_source)
+          sb = processed_source.buffer
+          return if sb.source.empty?
+
+          # The extra text that comes after the last token could be __END__
+          # followed by some data to read. If so, we don't check it because
+          # there could be good reasons why it needs to end with a certain
+          # number of newlines.
+          return if ends_in_end?(processed_source)
+
+          whitespace_at_end = sb.source[/\s*\Z/]
+          blank_lines = whitespace_at_end.count("\n") - 1
+          wanted_blank_lines = style == :final_newline ? 0 : 1
+
+          return unless blank_lines != wanted_blank_lines
+
+          offense_detected(sb, wanted_blank_lines, blank_lines,
+                           whitespace_at_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 = range_between(begin_pos, sb.source.length)
+          begin_pos += 1 unless whitespace_at_end.empty?
+          report_range = range_between(begin_pos, sb.source.length)
+          add_offense(autocorrect_range, report_range,
+                      message(wanted_blank_lines, blank_lines))
+        end
+
+        def ends_in_end?(processed_source)
+          sb = processed_source.buffer
+
+          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 && extra.strip.start_with?('__END__')
+        end
+
+        def message(wanted_blank_lines, blank_lines)
+          case blank_lines
+          when -1
+            'Final newline missing.'
+          when 0
+            'Trailing blank line missing.'
+          else
+            instead_of = if wanted_blank_lines.zero?
+                           ''
+                         else
+                           "instead of #{wanted_blank_lines} "
+                         end
+            format('%d trailing blank lines %sdetected.', blank_lines,
+                   instead_of)
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+      end
+    end
+  end
+end