rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Common functionality for checking if presence/absence of empty lines
+      # around some kind of body matches the configuration.
+      module EmptyLinesAroundBody
+        extend NodePattern::Macros
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_EXTRA = 'Extra empty line detected at %<kind>s body %<location>s.'
+        MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
+        MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
+
+        private
+
+        # @!method constant_definition?(node)
+        def_node_matcher :constant_definition?, '{class module}'
+
+        # @!method empty_line_required?(node)
+        def_node_matcher :empty_line_required?,
+                         '{any_def class module (send nil? {:private :protected :public})}'
+
+        def check(node, body, adjusted_first_line: nil)
+          return if valid_body_style?(body)
+          return if node.single_line?
+
+          first_line = adjusted_first_line || node.source_range.first_line
+          last_line = node.source_range.last_line
+
+          case style
+          when :empty_lines_except_namespace
+            check_empty_lines_except_namespace(body, first_line, last_line)
+          when :empty_lines_special
+            check_empty_lines_special(body, first_line, last_line)
+          else
+            check_both(style, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_except_namespace(body, first_line, last_line)
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            check_both(:empty_lines, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_special(body, first_line, last_line)
+          return unless body
+
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            if first_child_requires_empty_line?(body)
+              check_beginning(:empty_lines, first_line)
+            else
+              check_beginning(:no_empty_lines, first_line)
+              check_deferred_empty_line(body)
+            end
+            check_ending(:empty_lines, last_line)
+          end
+        end
+
+        def check_both(style, first_line, last_line)
+          case style
+          when :beginning_only
+            check_beginning(:empty_lines, first_line)
+            check_ending(:no_empty_lines, last_line)
+          when :ending_only
+            check_beginning(:no_empty_lines, first_line)
+            check_ending(:empty_lines, last_line)
+          else
+            check_beginning(style, first_line)
+            check_ending(style, last_line)
+          end
+        end
+
+        def check_beginning(style, first_line)
+          check_source(style, first_line, 'beginning')
+        end
+
+        def check_ending(style, last_line)
+          check_source(style, last_line - 2, 'end')
+        end
+
+        def check_source(style, line_no, desc)
+          case style
+          when :no_empty_lines
+            check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
+          when :empty_lines
+            check_line(style, line_no, message(MSG_MISSING, desc)) { |line| !line.empty? }
+          end
+        end
+
+        def check_line(style, line, msg)
+          return unless yield(processed_source.lines[line])
+
+          offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          range = source_range(processed_source.buffer, line + offset, 0)
+          add_offense(range, message: msg) do |corrector|
+            EmptyLineCorrector.correct(corrector, [style, range])
+          end
+        end
+
+        def check_deferred_empty_line(body)
+          node = first_empty_line_required_child(body)
+          return unless node
+
+          line = previous_line_ignoring_comments(node.first_line)
+          return if processed_source[line].empty?
+
+          range = source_range(processed_source.buffer, line + 2, 0)
+
+          add_offense(range, message: deferred_message(node)) do |corrector|
+            EmptyLineCorrector.correct(corrector, [:empty_lines, range])
+          end
+        end
+
+        def namespace?(body, with_one_child: false)
+          if body.begin_type?
+            return false if with_one_child
+
+            body.children.all? { |child| constant_definition?(child) }
+          else
+            constant_definition?(body)
+          end
+        end
+
+        def first_child_requires_empty_line?(body)
+          if body.begin_type?
+            empty_line_required?(body.children.first)
+          else
+            empty_line_required?(body)
+          end
+        end
+
+        def first_empty_line_required_child(body)
+          if body.begin_type?
+            body.children.find { |child| empty_line_required?(child) }
+          elsif empty_line_required?(body)
+            body
+          end
+        end
+
+        def previous_line_ignoring_comments(send_line)
+          (send_line - 2).downto(0) do |line|
+            return line unless comment_line?(processed_source[line])
+          end
+          0
+        end
+
+        def message(type, desc)
+          format(type, kind: self.class::KIND, location: desc)
+        end
+
+        def deferred_message(node)
+          format(MSG_DEFERRED, type: node.type)
+        end
+
+        def valid_body_style?(body)
+          # When style is `empty_lines`, if the body is empty, we don't enforce
+          # the presence OR absence of an empty line
+          # But if style is `no_empty_lines`, there must not be an empty line
+          body.nil? && style != :no_empty_lines
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/empty_parameter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      # @!method empty_arguments?(node)
+      def_node_matcher :empty_arguments?, <<~PATTERN
+        (block _ $(args) _)
+      PATTERN
+
+      def check(node)
+        empty_arguments?(node) do |args|
+          return if args.empty_and_without_delimiters?
+
+          add_offense(args) { |corrector| autocorrect(corrector, args) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Functions for checking the alignment of the `end` keyword.
+    module EndKeywordAlignment
+      include ConfigurableEnforcedStyle
+      include RangeHelp
+
+      MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
+            '`%<source>s` at %<align_line>d, %<align_col>d.'
+
+      private
+
+      def check_end_kw_in_node(node)
+        check_end_kw_alignment(node, style => node.loc.keyword)
+      end
+
+      def check_end_kw_alignment(node, align_ranges)
+        return if ignored_node?(node)
+
+        end_loc = node.loc.end
+        return if accept_end_kw_alignment?(end_loc)
+
+        matching = matching_ranges(end_loc, align_ranges)
+
+        if matching.key?(style)
+          correct_style_detected
+        else
+          add_offense_for_misalignment(node, align_ranges[style])
+          style_detected(matching.keys)
+        end
+      end
+
+      def matching_ranges(end_loc, align_ranges)
+        align_ranges.select do |_, range|
+          same_line?(range, end_loc) || column_offset_between(range, end_loc).zero?
+        end
+      end
+
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
+      def add_offense_for_misalignment(node, align_with)
+        end_loc = node.loc.end
+        msg = format(MSG, end_line: end_loc.line,
+                          end_col: end_loc.column,
+                          source: align_with.source,
+                          align_line: align_with.line,
+                          align_col: align_with.column)
+        add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
+      end
+
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
+      end
+
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
+      end
+
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        return false if end_alignment_style == :keyword
+
+        !line_break_before_keyword?(whole_expression, rhs)
+      end
+
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.first_line > whole_expression.line
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/endless_method_rewriter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for rewriting endless methods to normal method definitions
+    module EndlessMethodRewriter
+      def correct_to_multiline(corrector, node)
+        replacement = <<~RUBY.strip
+          def #{node.method_name}#{arguments(node)}
+            #{node.body.source}
+          end
+        RUBY
+
+        corrector.replace(node, replacement)
+      end
+
+      private
+
+      def arguments(node, missing = '')
+        node.arguments.any? ? node.arguments.source : missing
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for enforcing a specific superclass.
+    #
+    # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+    # Rails department has been extracted to RuboCop Rails gem.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
+    # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+    # with existing RuboCop Rails 2.8 or lower.
+    #
+    # @api private
+    module EnforceSuperclass
+      def self.included(base)
+        warn Rainbow(
+          '`RuboCop::Cop::EnforceSuperclass` is deprecated and will be removed in RuboCop 2.0. ' \
+          'Please upgrade to RuboCop Rails 2.9 or newer to continue.'
+        ).yellow
+
+        # @!method class_definition(node)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        PATTERN
+
+        # @!method class_new_definition(node)
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
+        PATTERN
+      end
+
+      def on_class(node)
+        class_definition(node) { add_offense(node.children[1]) }
+      end
+
+      def on_send(node)
+        class_new_definition(node) { add_offense(node.children.last) }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before the first
+    # element in a multi-line collection.
+    module FirstElementLineBreak
+      private
+
+      def check_method_line_break(node, children, ignore_last: false)
+        return if children.empty?
+
+        return unless method_uses_parens?(node, children.first)
+
+        check_children_line_break(node, children, ignore_last: ignore_last)
+      end
+
+      def method_uses_parens?(node, limit)
+        source = node.source_range.source_line[0...limit.loc.column]
+        /\s*\(\s*$/.match?(source)
+      end
+
+      def check_children_line_break(node, children, start = node, ignore_last: false)
+        return if children.empty?
+
+        line = start.first_line
+
+        min = first_by_line(children)
+        return if line != min.first_line
+
+        max_line = last_line(children, ignore_last: ignore_last)
+        return if line == max_line
+
+        add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
+      end
+
+      def first_by_line(nodes)
+        nodes.min_by(&:first_line)
+      end
+
+      def last_line(nodes, ignore_last:)
+        if ignore_last
+          nodes.map(&:first_line)
+        else
+          nodes.map(&:last_line)
+        end.max
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/forbidden_identifiers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        name = name.to_s.delete(SIGILS)
+
+        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(name)
+        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+      end
+
+      def forbidden_patterns
+        cop_config.fetch('ForbiddenPatterns', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with frozen string literals.
+    module FrozenStringLiteral
+      module_function
+
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
+      FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27
+
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
+      end
+
+      private
+
+      def frozen_string_literal?(node)
+        frozen_string = if target_ruby_version >= 3.0
+                          uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
+                        end
+
+        frozen_string && frozen_string_literals_enabled?
+      end
+
+      def uninterpolated_string?(node)
+        node.str_type? || (
+          node.dstr_type? && node.each_descendant(:begin, :ivar, :cvar, :gvar).none?
+        )
+      end
+
+      def uninterpolated_heredoc?(node)
+        return false unless node.dstr_type? && node.heredoc?
+
+        node.children.all?(&:str_type?)
+      end
+      alias frozen_heredoc? uninterpolated_heredoc?
+
+      def frozen_string_literals_enabled?
+        ruby_version = processed_source.ruby_version
+        return false unless ruby_version
+
+        # Check if a magic string literal comment specifies what to do
+        magic_comments = leading_comment_lines.filter_map { |line| MagicComment.parse(line) }
+        if (literal_magic_comment = magic_comments.find(&:frozen_string_literal_specified?))
+          return literal_magic_comment.frozen_string_literal?
+        end
+
+        # TODO: Ruby officially abandon making frozen string literals default
+        # for Ruby 3.0.
+        # https://bugs.ruby-lang.org/issues/11473#note-53
+        # Whether frozen string literals will be the default after Ruby 4.0
+        # or not is still unclear as of July 2024.
+        # It may be necessary to add this code in the future.
+        #
+        #   return ruby_version >= 4.0 if string_literals_frozen_by_default?.nil?
+        #
+        # And the above `ruby_version >= 4.0` is undecided whether it will be
+        # Ruby 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/20205 for details.
+        # For now, offer a configuration value to override behavior is using RUBYOPT.
+        return false if string_literals_frozen_by_default?.nil?
+
+        string_literals_frozen_by_default?
+      end
+
+      def frozen_string_literals_disabled?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal == false
+        end
+      end
+
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
+
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
+      def leading_comment_lines
+        first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
+
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...first_non_comment_token.line - 1]
+        else
+          processed_source.lines
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/gem_declaration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemDeclaration
+      extend NodePattern::Macros
+
+      # @!method gem_declaration?(node)
+      def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
+    end
+  end
+end

data/lib/rubocop/cop/mixin/gemspec_help.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemspecHelp
+      extend NodePattern::Macros
+
+      # @!method gem_specification?(node)
+      def_node_matcher :gem_specification?, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method gem_specification(node)
+      def_node_search :gem_specification, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+    end
+  end
+end