rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for indentation that doesn't use the specified number of spaces.
+      # The indentation width can be configured using the `Width` setting. The default width is 2.
+      #
+      # See also the `Layout/IndentationConsistency` cop which is the companion to this one.
+      #
+      # @example Width: 2 (default)
+      #   # bad
+      #   class A
+      #    def test
+      #     puts 'hello'
+      #    end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['^\s*module']
+      #   # bad
+      #   module A
+      #   class B
+      #     def test
+      #     puts 'hello'
+      #     end
+      #   end
+      #   end
+      #
+      #   # good
+      #   module A
+      #   class B
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #   end
+      class IndentationWidth < Base # rubocop:disable Metrics/ClassLength
+        include EndKeywordAlignment
+        include Alignment
+        include CheckAssignment
+        include AllowedPattern
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
+              'spaces for%<name>s indentation.'
+
+        # @!method access_modifier?(node)
+        def_node_matcher :access_modifier?, <<~PATTERN
+          [(send ...) access_modifier?]
+        PATTERN
+
+        def on_rescue(node)
+          check_indentation(node.loc.else, node.else_branch)
+        end
+
+        def on_resbody(node)
+          check_indentation(node.loc.keyword, node.body)
+        end
+        alias on_for on_resbody
+
+        def on_ensure(node)
+          check_indentation(node.loc.keyword, node.branch)
+        end
+
+        def on_kwbegin(node)
+          # Check indentation against end keyword but only if it's first on its
+          # line.
+          return unless begins_its_line?(node.loc.end)
+
+          check_indentation(node.loc.end, node.children.first)
+        end
+
+        def on_block(node)
+          end_loc = node.loc.end
+
+          return unless begins_its_line?(end_loc)
+
+          check_indentation(end_loc, node.body)
+
+          return unless indented_internal_methods_style?
+
+          check_members(end_loc, [node.body])
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_class(node)
+          base = node.loc.keyword
+          return if same_line?(base, node.body)
+
+          check_members(base, [node.body])
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def on_send(node)
+          super
+          return unless node.adjacent_def_modifier?
+
+          def_end_config = config.for_cop('Layout/DefEndAlignment')
+          style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
+          base = if style == 'def'
+                   node.first_argument
+                 else
+                   leftmost_modifier_of(node) || node
+                 end
+
+          check_indentation(base.source_range, node.first_argument.body)
+          ignore_node(node.first_argument)
+        end
+        alias on_csend on_send
+
+        def on_def(node)
+          return if ignored_node?(node)
+
+          check_indentation(node.loc.keyword, node.body)
+        end
+        alias on_defs on_def
+
+        def on_while(node, base = node)
+          return if ignored_node?(node)
+
+          return unless node.single_line_condition?
+
+          check_indentation(base.loc, node.body)
+        end
+
+        alias on_until on_while
+
+        def on_case(case_node)
+          case_node.when_branches.each do |when_node|
+            check_indentation(when_node.loc.keyword, when_node.body)
+          end
+
+          check_indentation(case_node.when_branches.last.loc.keyword, case_node.else_branch)
+        end
+
+        def on_case_match(case_match)
+          case_match.each_in_pattern do |in_pattern_node|
+            check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
+          end
+
+          else_branch = case_match.else_branch&.empty_else_type? ? nil : case_match.else_branch
+
+          check_indentation(case_match.in_pattern_branches.last.loc.keyword, else_branch)
+        end
+
+        def on_if(node, base = node)
+          return if ignored_node?(node)
+          return if node.ternary? || node.modifier_form?
+
+          check_if(node, node.body, node.else_branch, base.loc)
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def check_members(base, members)
+          check_indentation(base, select_check_member(members.first))
+
+          return unless members.any? && members.first.begin_type?
+
+          if indentation_consistency_style == 'indented_internal_methods'
+            check_members_for_indented_internal_methods_style(members)
+          else
+            check_members_for_normal_style(base, members)
+          end
+        end
+
+        def select_check_member(member)
+          return unless member
+
+          if access_modifier?(member.children.first)
+            return if access_modifier_indentation_style == 'outdent'
+
+            member.children.first
+          else
+            member
+          end
+        end
+
+        def check_members_for_indented_internal_methods_style(members)
+          each_member(members) do |member, previous_modifier|
+            check_indentation(previous_modifier, member, indentation_consistency_style)
+          end
+        end
+
+        def check_members_for_normal_style(base, members)
+          members.first.children.each do |member|
+            next if member.send_type? && member.access_modifier?
+
+            check_indentation(base, member)
+          end
+        end
+
+        def each_member(members)
+          previous_modifier = nil
+          members.first.children.each do |member|
+            if member.send_type? && member.special_modifier?
+              previous_modifier = member
+            elsif previous_modifier
+              yield member, previous_modifier.source_range
+              previous_modifier = nil
+            end
+          end
+        end
+
+        def indented_internal_methods_style?
+          indentation_consistency_style == 'indented_internal_methods'
+        end
+
+        def special_modifier?(node)
+          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def access_modifier_indentation_style
+          config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle']
+        end
+
+        def indentation_consistency_style
+          config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
+        end
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check its indentation.
+          rhs = first_part_of_call_chain(rhs)
+          return unless rhs
+
+          end_config = config.for_cop('Layout/EndAlignment')
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
+
+          case rhs.type
+          when :if            then on_if(rhs, base)
+          when :while, :until then on_while(rhs, base)
+          else                     return
+          end
+
+          ignore_node(rhs)
+        end
+
+        def check_if(node, body, else_clause, base_loc)
+          return if node.ternary?
+
+          check_indentation(base_loc, body)
+          return unless else_clause
+
+          # If the else clause is an elsif, it will get its own on_if call so
+          # we don't need to process it here.
+          return if else_clause.if_type? && else_clause.elsif?
+
+          check_indentation(node.loc.else, else_clause)
+        end
+
+        def check_indentation(base_loc, body_node, style = 'normal')
+          return unless indentation_to_check?(base_loc, body_node)
+
+          indentation = column_offset_between(body_node.loc, base_loc)
+          @column_delta = configured_indentation_width - indentation
+          return if @column_delta.zero?
+
+          offense(body_node, indentation, style)
+        end
+
+        def offense(body_node, indentation, style)
+          # This cop only autocorrects the first statement in a def body, for
+          # example.
+          body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
+
+          # Since autocorrect changes a number of lines, and not only the line
+          # where the reported offending range is, we avoid autocorrection if
+          # this cop has already found other offenses is the same
+          # range. Otherwise, two corrections can interfere with each other,
+          # resulting in corrupted code.
+          node = if autocorrect? && other_offense_in_same_range?(body_node)
+                   nil
+                 else
+                   body_node
+                 end
+
+          name = style == 'normal' ? '' : " #{style}"
+          message = message(configured_indentation_width, indentation, name)
+
+          add_offense(offending_range(body_node, indentation), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def message(configured_indentation_width, indentation, name)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            indentation: indentation,
+            name: name
+          )
+        end
+
+        # Returns true if the given node is within another node that has
+        # already been marked for autocorrection by this cop.
+        def other_offense_in_same_range?(node)
+          expr = node.source_range
+          @offense_ranges ||= []
+
+          return true if @offense_ranges.any? { |r| within?(expr, r) }
+
+          @offense_ranges << expr
+          false
+        end
+
+        def indentation_to_check?(base_loc, body_node)
+          return false if skip_check?(base_loc, body_node)
+
+          if body_node.rescue_type?
+            check_rescue?(body_node)
+          elsif body_node.ensure_type?
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
+            if block_body&.rescue_type?
+              check_rescue?(block_body)
+            else
+              !block_body.nil?
+            end
+          else
+            true
+          end
+        end
+
+        def check_rescue?(rescue_node)
+          rescue_node.body
+        end
+
+        def skip_check?(base_loc, body_node)
+          return true if allowed_line?(base_loc)
+          return true unless body_node
+
+          # Don't check if expression is on same line as "then" keyword, etc.
+          return true if same_line?(body_node, base_loc)
+
+          return true if starts_with_access_modifier?(body_node)
+
+          # Don't check indentation if the line doesn't start with the body.
+          # For example, lines like "else do_something".
+          first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
+          body_node.loc.column != first_char_pos_on_line
+        end
+
+        def offending_range(body_node, indentation)
+          expr = body_node.source_range
+          begin_pos = expr.begin_pos
+          ind = expr.begin_pos - indentation
+          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          range_between(pos.begin, pos.end)
+        end
+
+        def starts_with_access_modifier?(body_node)
+          return false unless body_node.begin_type?
+
+          starting_node = body_node.children.first
+          return false unless starting_node
+
+          starting_node.send_type? && starting_node.bare_access_modifier?
+        end
+
+        def configured_indentation_width
+          cop_config['Width']
+        end
+
+        def leftmost_modifier_of(node)
+          return node unless node.parent&.send_type?
+
+          leftmost_modifier_of(node.parent)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Indentation of first line in file detected.'
+
+        def on_new_investigation
+          space_before(first_token) do |space|
+            add_offense(first_token.pos) do |corrector|
+              corrector.remove(space)
+            end
+          end
+        end
+
+        private
+
+        def first_token
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.column.zero?
+
+          space_range = range_with_surrounding_space(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,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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
+      #
+      # @example AllowRBSInlineAnnotation: false (default)
+      #
+      #   # bad
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      # @example AllowRBSInlineAnnotation: true
+      #
+      #   # good
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      # @example AllowSteepAnnotation: false (default)
+      #
+      #   # bad
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      # @example AllowSteepAnnotation: true
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      class LeadingCommentSpace < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Missing space after `#`.'
+
+        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          processed_source.comments.each do |comment|
+            next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if shebang_continuation?(comment)
+            next if doxygen_comment_style?(comment)
+            next if gemfile_ruby_comment?(comment)
+            next if rbs_inline_annotation?(comment)
+            next if steep_annotation?(comment)
+
+            add_offense(comment) do |corrector|
+              expr = comment.source_range
+
+              corrector.insert_after(hash_mark(expr), ' ')
+            end
+          end
+        end
+
+        private
+
+        def hash_mark(expr)
+          range_between(expr.begin_pos, expr.begin_pos + 1)
+        end
+
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || (rackup_config_file? && rackup_options?(comment))
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def shebang_continuation?(comment)
+          return false unless shebang?(comment)
+          return true if comment.loc.line == 1
+
+          previous_line_comment = processed_source.comment_at_line(comment.loc.line - 1)
+          return false unless previous_line_comment
+
+          # If the comment is a shebang but not on the first line, check if the previous
+          # line has a shebang comment that wasn't marked as an offense; if so, this comment
+          # continues the shebang and is acceptable.
+          shebang?(previous_line_comment) &&
+            !current_offense_locations.include?(previous_line_comment.source_range)
+        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
+
+        def allow_rbs_inline_annotation?
+          cop_config['AllowRBSInlineAnnotation']
+        end
+
+        def rbs_inline_annotation?(comment)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]/)
+        end
+
+        def allow_steep_annotation?
+          cop_config['AllowSteepAnnotation']
+        end
+
+        def steep_annotation?(comment)
+          allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary blank line at the beginning of the source.'
+
+        def on_new_investigation
+          token = processed_source.tokens[0]
+          return unless token && token.line > 1
+
+          add_offense(token.pos) do |corrector|
+            range = Parser::Source::Range.new(processed_source.buffer, 0, token.begin_pos)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end