rbhint 0.8.5.rc1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for indentation of the first non-blank non-comment
+      # line in a file.
+      #
+      # @example
+      #   # bad
+      #      class A
+      #        def foo; end
+      #      end
+      #
+      #   # good
+      #   class A
+      #     def foo; end
+      #   end
+      #
+      class InitialIndentation < Cop
+        include RangeHelp
+
+        MSG = 'Indentation of first line in file detected.'
+
+        def investigate(_processed_source)
+          space_before(first_token) do |space|
+            add_offense(space, location: first_token.pos)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def first_token
+          processed_source.find_token { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.column.zero?
+
+          space_range =
+            range_with_surrounding_space(range: token.pos,
+                                         side: :left,
+                                         newlines: false)
+          # If the file starts with a byte order mark (BOM), the column can be
+          # non-zero, but then we find out here if there's no space to the left
+          # of the first token.
+          return if space_range == token.pos
+
+          yield range_between(space_range.begin_pos, token.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether comments have a leading space after the
+      # `#` denoting the start of the comment. The leading space is not
+      # required for some RDoc special syntax, like `#++`, `#--`,
+      # `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
+      # or rackup options.
+      #
+      # @example
+      #
+      #   # bad
+      #   #Some comment
+      #
+      #   # good
+      #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowGemfileRubyComment: false (default)
+      #
+      #   # bad
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      # @example AllowGemfileRubyComment: true
+      #
+      #   # good
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      class LeadingCommentSpace < Cop
+        include RangeHelp
+
+        MSG = 'Missing space after `#`.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if doxygen_comment_style?(comment)
+            next if gemfile_ruby_comment?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        end
+
+        private
+
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def rackup_options?(comment)
+          comment.text.start_with?('#\\')
+        end
+
+        def rackup_config_file?
+          File.basename(processed_source.file_path).eql?('config.ru')
+        end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          allow_doxygen_comment? && comment.text.start_with?('#*')
+        end
+
+        def allow_gemfile_ruby_comment?
+          cop_config['AllowGemfileRubyComment']
+        end
+
+        def gemfile?
+          File.basename(processed_source.file_path).eql?('Gemfile')
+        end
+
+        def ruby_comment_in_gemfile?(comment)
+          gemfile? && comment.text.start_with?('#ruby')
+        end
+
+        def gemfile_ruby_comment?(comment)
+          allow_gemfile_ruby_comment? && ruby_comment_in_gemfile?(comment)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for unnecessary leading blank lines at the beginning
+      # of a file.
+      #
+      # @example
+      #
+      #   # bad
+      #   # (start of file)
+      #
+      #   class Foo
+      #   end
+      #
+      #   # bad
+      #   # (start of file)
+      #
+      #   # a comment
+      #
+      #   # good
+      #   # (start of file)
+      #   class Foo
+      #   end
+      #
+      #   # good
+      #   # (start of file)
+      #   # a comment
+      class LeadingEmptyLines < Cop
+        MSG = 'Unnecessary blank line at the beginning of the source.'
+
+        def investigate(processed_source)
+          token = processed_source.tokens[0]
+          return unless token && token.line > 1
+
+          add_offense(processed_source.tokens[0],
+                      location: processed_source.tokens[0].pos)
+        end
+
+        def autocorrect(node)
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            0,
+                                            node.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the length of lines in the source code.
+      # The maximum length is configurable.
+      # The tab size is configured in the `IndentationWidth`
+      # of the `Layout/IndentationStyle` cop.
+      # It also ignores a shebang line by default.
+      #
+      # This cop has some autocorrection capabilities.
+      # It can programmatically shorten certain long lines by
+      # inserting line breaks into expressions that can be safely
+      # split across lines. These include arrays, hashes, and
+      # method calls with argument lists.
+      #
+      # If autocorrection is enabled, the following Layout cops
+      # are recommended to further format the broken lines.
+      # (Many of these are enabled by default.)
+      #
+      # * ArgumentAlignment
+      # * BlockAlignment
+      # * BlockDelimiters
+      # * BlockEndNewline
+      # * ClosingParenthesisIndentation
+      # * FirstArgumentIndentation
+      # * FirstArrayElementIndentation
+      # * FirstHashElementIndentation
+      # * FirstParameterIndentation
+      # * HashAlignment
+      # * IndentationWidth
+      # * MultilineArrayLineBreaks
+      # * MultilineBlockLayout
+      # * MultilineHashBraceLayout
+      # * MultilineHashKeyLineBreaks
+      # * MultilineMethodArgumentLineBreaks
+      # * ParameterAlignment
+      #
+      # Together, these cops will pretty print hashes, arrays,
+      # method calls, etc. For example, let's say the max columns
+      # is 25:
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good
+      #   {foo: "0000000000",
+      #   bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good (with recommended cops enabled)
+      #   {
+      #     foo: "0000000000",
+      #     bar: "0000000000",
+      #     baz: "0000000000",
+      #   }
+      class LineLength < Cop
+        include CheckLineBreakable
+        include ConfigurableMax
+        include IgnoredPattern
+        include RangeHelp
+        include LineLengthHelp
+
+        MSG = 'Line is too long. [%<length>d/%<max>d]'
+
+        def on_block(node)
+          check_for_breakable_block(node)
+        end
+
+        def on_potential_breakable_node(node)
+          check_for_breakable_node(node)
+        end
+        alias on_array on_potential_breakable_node
+        alias on_hash on_potential_breakable_node
+        alias on_send on_potential_breakable_node
+
+        def investigate(processed_source)
+          check_for_breakable_semicolons(processed_source)
+        end
+
+        def investigate_post_walk(processed_source)
+          processed_source.lines.each_with_index do |line, line_index|
+            check_line(line, line_index)
+          end
+        end
+
+        def autocorrect(range)
+          return if range.nil?
+
+          lambda do |corrector|
+            corrector.insert_before(range, "\n")
+          end
+        end
+
+        private
+
+        def check_for_breakable_node(node)
+          breakable_node = extract_breakable_node(node, max)
+          return if breakable_node.nil?
+
+          line_index = breakable_node.first_line - 1
+          range = breakable_node.source_range
+
+          existing = breakable_range_by_line_index[line_index]
+          return if existing
+
+          breakable_range_by_line_index[line_index] = range
+        end
+
+        def check_for_breakable_semicolons(processed_source)
+          tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
+          tokens.reverse_each do |token|
+            range = breakable_range_after_semicolon(token)
+            breakable_range_by_line_index[range.line - 1] = range if range
+          end
+        end
+
+        def check_for_breakable_block(block_node)
+          return unless block_node.single_line?
+
+          line_index = block_node.loc.line - 1
+          range = breakable_block_range(block_node)
+          pos = range.begin_pos + 1
+
+          breakable_range_by_line_index[line_index] =
+            range_between(pos, pos + 1)
+        end
+
+        def breakable_block_range(block_node)
+          if block_node.arguments? && !block_node.lambda?
+            block_node.arguments.loc.end
+          else
+            block_node.loc.begin
+          end
+        end
+
+        def breakable_range_after_semicolon(semicolon_token)
+          range = semicolon_token.pos
+          end_pos = range.end_pos
+          next_range = range_between(end_pos, end_pos + 1)
+          return nil unless next_range.line == range.line
+
+          next_char = next_range.source
+          return nil if /[\r\n]/.match?(next_char)
+          return nil if next_char == ';'
+
+          next_range
+        end
+
+        def breakable_range_by_line_index
+          @breakable_range_by_line_index ||= {}
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
+        def highlight_start(line)
+          # TODO: The max with 0 is a quick fix to avoid crashes when a line
+          # begins with many tabs, but getting a correct highlighting range
+          # when tabs are used for indentation doesn't work currently.
+          [max - indentation_difference(line), 0].max
+        end
+
+        def check_line(line, line_index)
+          return if line_length(line) <= max
+          return if ignored_line?(line, line_index)
+
+          if ignore_cop_directives? && directive_on_source_line?(line_index)
+            return check_directive_line(line, line_index)
+          end
+          return check_uri_line(line, line_index) if allow_uri?
+
+          register_offense(
+            excess_range(nil, line, line_index),
+            line,
+            line_index
+          )
+        end
+
+        def ignored_line?(line, line_index)
+          matches_ignored_pattern?(line) ||
+            shebang?(line, line_index) ||
+            heredocs && line_in_permitted_heredoc?(line_index.succ)
+        end
+
+        def shebang?(line, line_index)
+          line_index.zero? && line.start_with?('#!')
+        end
+
+        def register_offense(loc, line, line_index)
+          message = format(MSG, length: line_length(line), max: max)
+
+          breakable_range = breakable_range_by_line_index[line_index]
+          add_offense(breakable_range, location: loc, message: message) do
+            self.max = line_length(line)
+          end
+        end
+
+        def excess_range(uri_range, line, line_index)
+          excessive_position = if uri_range && uri_range.begin < max
+                                 uri_range.end
+                               else
+                                 highlight_start(line)
+                               end
+
+          source_range(processed_source.buffer, line_index + 1,
+                       excessive_position...(line_length(line)))
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_heredoc?
+          allowed_heredoc
+        end
+
+        def allowed_heredoc
+          cop_config['AllowHeredoc']
+        end
+
+        def extract_heredocs(ast)
+          return [] unless ast
+
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            delimiter = node.location.heredoc_end.source.strip
+            [body.first_line...body.last_line, delimiter]
+          end
+        end
+
+        def line_in_permitted_heredoc?(line_number)
+          return false unless allowed_heredoc
+
+          heredocs.any? do |range, delimiter|
+            range.cover?(line_number) &&
+              (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
+          end
+        end
+
+        def line_in_heredoc?(line_number)
+          heredocs.any? do |range, _delimiter|
+            range.cover?(line_number)
+          end
+        end
+
+        def check_directive_line(line, line_index)
+          return if line_length_without_directive(line) <= max
+
+          range = max..(line_length_without_directive(line) - 1)
+          register_offense(
+            source_range(
+              processed_source.buffer,
+              line_index + 1,
+              range
+            ),
+            line,
+            line_index
+          )
+        end
+
+        def check_uri_line(line, line_index)
+          uri_range = find_excessive_uri_range(line)
+          return if uri_range && allowed_uri_position?(line, uri_range)
+
+          register_offense(
+            excess_range(uri_range, line, line_index),
+            line,
+            line_index
+          )
+        end
+      end
+    end
+  end
+end