kube_schema 1.11.0 → 2.0.0

data/cops/begin_block_assignment.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Bans assigning a `begin ... end` to a variable.
+#
+# @example
+#   begin
+#     lvar = ...
+#   end
+module RuboCop
+  module Cop
+    module Local
+      class BeginBlockAssignment < Base
+        MSG = "Do not assign a `begin...end` expression to a variable; " \
+              "move the assignment inside the begin block."
+
+        def on_lvasgn(node)
+          check(node)
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        private
+
+          def check(node)
+            rhs = node.children.last
+            if rhs.is_a?(RuboCop::AST::Node) && rhs.type == :kwbegin
+              add_offense(node)
+            end
+          end
+      end
+    end
+  end
+end

data/cops/comment_structure.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Checks the structure of a comment, which decode parses into three parts: the summary, the annotations, and the summary belonging to each annotation.
+#
+# @example
+#   # Connect to the given endpoint, returning the HTTP client and reference.   <- summary
+#   # @parameter endpoint [Endpoint] used to connect to the remote system.      <- annotation
+#   # @returns [Tuple(Client, Reference)] the client and reference.
+#
+# Four things are checked, each measured against how async-rest, async-discord and async-ollama document themselves:
+#
+# A paragraph occupies one line. None of the 99 summary paragraphs in those three projects is wrapped, and async-rest's run to 544 characters.
+#
+# A summary is short, and no longer than the code it describes earns. Across 76 documented methods the median summary is 4 to 9 words whatever the length of the method, so the allowance starts at ten words and grows by three per line of body, to a ceiling of thirty.
+#
+# A module's summary is ten words or fewer. The only commented module in async-rest is exactly ten.
+#
+# A documented method says what it takes and returns. A summary with no annotations describes the method in prose and leaves the signature undocumented, which is what annotations are for. A method with no comment at all is not this cop's business: that is documentation coverage, which decode reports on separately.
+#
+# Nothing here is corrected automatically. A comment which breaks these rules has to be rewritten rather than reflowed, and a correction which only moved the words around would hide that.
+#
+# Each check is configured on its own, because they are not all worth applying everywhere:
+#
+# @example
+#   Local/CommentStructure:
+#     Annotations:
+#       Include:
+#         - "lib/**/*.rb"
+#     Length:
+#       Exclude:
+#         - "bin/**/*"
+#     Wrapping:
+#       Enabled: true
+#
+# A check with no `Include` runs everywhere; given one, it runs only where a path matches. `Exclude` then removes paths from whatever is left. `Annotations` defaults to `lib` alone: a script in `bin` and a case in `test` have no interface for anyone else to call, so annotating them documents nothing.
+#
+# What a declaration says is read from the run of comment lines touching it. Where an offence is reported is read from the wider span the library attributes to the declaration, less any magic comment, because decode reports a part's position within that span rather than the line it came from.
+
+require "decode/language/ruby/generic"
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Cop
+    module Local
+      class CommentStructure < Base
+        include PrismSource
+
+        MSG_WRAPPED_SUMMARY = "Do not wrap a summary paragraph: a paragraph is one line, however long."
+
+        MSG_WRAPPED_ANNOTATION = "Do not wrap the summary of `@%<directive>s`: an annotation's summary is one line."
+
+        MSG_TOO_LONG = "This summary is %<words>d words; %<allowed>d is the most %<subject>s may have."
+
+        MSG_NO_ANNOTATIONS = "This method is described in prose but its parameters and return value are not: document them with annotations, or say nothing."
+
+        TAGS = Decode::Language::Ruby::Generic::TAGS
+
+        # Each check, and the paths it applies to when the configuration names none.
+        CHECKS = {
+          "Wrapping" => nil,
+          "Length" => nil,
+          "Annotations" => ["lib/**/*.rb"].freeze,
+        }.freeze
+
+        GLOB = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+        HEADER = /\A#\s*(frozen_string_literal:|Released under|Copyright,|!)/
+
+        # What a Ruby file says to the interpreter rather than to a reader.
+        MAGIC = /\A#\s*(frozen_string_literal:|encoding:|coding:|warn_indent:|shareable_constant_value:|!|-\*-)/
+
+        TERMINAL = [".", ":", "?", "!"].freeze
+
+        # Multi-line content is the point of these, so their summaries are left alone.
+        FREEFORM = [Decode::Comment::Example].freeze
+
+        def on_new_investigation
+          if self.applies?("Wrapping")
+            self.blocks.each do |block|
+              self.check_wrapping(block)
+            end
+          end
+
+          if self.applies?("Length")
+            self.prism_each(::Prism::ModuleNode).each do |node|
+              self.check_summary(node, "a module summary", self.cop_config.fetch("ModuleWords", 10))
+            end
+
+            self.prism_each(::Prism::ClassNode).each do |node|
+              self.check_summary(node, "a class summary", self.cop_config.fetch("MaximumWords", 30))
+            end
+          end
+
+          self.prism_each(::Prism::DefNode).each do |node|
+            self.check_method(node)
+          end
+        end
+
+        private
+
+        # Whether a check applies to the file being inspected.
+        def applies?(check)
+          configuration = self.cop_config[check] || {}
+
+          if configuration["Enabled"] == false
+            false
+          else
+            path = ::RuboCop::PathUtil.relative_path(processed_source.file_path.to_s)
+
+            included = configuration["Include"] || CHECKS.fetch(check)
+            excluded = configuration["Exclude"] || []
+
+            self.matches?(path, included, true) and !self.matches?(path, excluded, false)
+          end
+        end
+
+        # @parameter default [Boolean] what an absent or empty list of patterns means.
+        def matches?(path, patterns, default)
+          if patterns.nil? or patterns.empty?
+            default
+          else
+            patterns.any?{|pattern| File.fnmatch?(pattern, path, GLOB)}
+          end
+        end
+
+        def check_method(node)
+          lines = node.location.end_line - node.location.start_line + 1
+          base = self.cop_config.fetch("BaseWords", 10)
+          per_line = self.cop_config.fetch("WordsPerLine", 3)
+          ceiling = self.cop_config.fetch("MaximumWords", 30)
+
+          allowed = [base + (per_line * lines), ceiling].min
+
+          if self.applies?("Length")
+            self.check_summary(node, "a summary of #{lines} #{lines == 1 ? "line" : "lines"} of code", allowed)
+          end
+
+          if self.applies?("Annotations")
+            self.check_annotations(node)
+          end
+        end
+
+        # The comment which documents a declaration, as the parts decode reads it as.
+        def parts_of(node)
+          comments = self.documenting(node)
+
+          if comments.empty?
+            nil
+          else
+            self.parse(comments)
+          end
+        end
+
+        # The comment above a declaration, without the file's own header.
+        def documenting(node)
+          self.prism_leading_comments(node).reject{|comment| self.prism_source(comment).match?(HEADER)}
+        end
+
+        # Every comment the declaration owns, which is what the parts are indexed against.
+        def owned(node)
+          self.prism_owned_comments(node).drop_while{|comment| self.prism_source(comment).match?(MAGIC)}
+        end
+
+        def check_summary(node, subject, allowed)
+          parts = self.parts_of(node)
+
+          if parts
+            summary = parts.map(&:first).grep(Decode::Comment::Text)
+            words = summary.sum{|text| text.line.split.size}
+
+            if words > allowed
+              message = format(MSG_TOO_LONG, words: words, allowed: allowed, subject: subject)
+
+              add_offense(self.summary_range(node, parts, summary.first), message: message)
+            end
+          end
+        end
+
+        def check_annotations(node)
+          parts = self.parts_of(node)
+
+          if parts and parts.any?{|part, _| part.is_a?(Decode::Comment::Text)}
+            annotations = parts.map(&:first).reject{|part| part.is_a?(Decode::Comment::Text)}
+
+            if annotations.empty?
+              add_offense(self.prism_range(node.name_loc), message: MSG_NO_ANNOTATIONS)
+            end
+          end
+        end
+
+        # Consecutive comment lines: a block is what documents one thing, so a wrap can only happen inside one.
+        def blocks
+          [].tap do |found|
+            current = []
+
+            self.prism_comments.each do |comment|
+              text = self.prism_source(comment)
+
+              if text.match?(HEADER) or text.start_with?("# rubocop:")
+                next
+              end
+
+              if current.empty? or comment.location.start_line == current.last.location.start_line + 1
+                current << comment
+              else
+                found << current
+                current = [comment]
+              end
+            end
+
+            unless current.empty?
+              found << current
+            end
+          end
+        end
+
+        def check_wrapping(block)
+          nodes = self.parse(block)
+
+          nodes.each_with_index do |(node, lines), index|
+            if node.is_a?(Decode::Comment::Text)
+              following = nodes[index + 1]&.first
+
+              if following.is_a?(Decode::Comment::Text) and !self.terminated?(node.line)
+                add_offense(self.prism_range(block[lines.first.first].location), message: MSG_WRAPPED_SUMMARY)
+              end
+            elsif !FREEFORM.include?(node.class)
+              summary = lines.drop(1).reject{|line| line.last.strip.start_with?("@")}
+
+              if summary.size > 1
+                message = format(MSG_WRAPPED_ANNOTATION, directive: node.directive)
+
+                add_offense(self.prism_range(block[summary.first.first].location), message: message)
+              end
+            end
+          end
+        end
+
+        # decode consumes the lines it parses and does not report where they came from, so they are handed over through something which records what it gave away.
+        def parse(block)
+          source = Consumable.new(block.each_with_index.map{|comment, index| [index, self.text_of(comment)]})
+          nodes = []
+          cursor = 0
+
+          TAGS.parse(source) do |node|
+            if node
+              nodes << [node, source.log[cursor..]]
+              cursor = source.log.size
+            end
+          end
+
+          nodes
+        end
+
+        # The comment without its `#`, keeping the indentation which tells decode what is nested.
+        def text_of(comment)
+          self.prism_source(comment).sub(/\A#\s?/, "")
+        end
+
+        # Where to report a summary which is too long: the comment line it starts on, or the declaration itself when the summary cannot be traced back to one.
+        def summary_range(node, parts, text)
+          comments = self.owned(node)
+          entry = text && parts.find{|part, _| part.equal?(text)}
+
+          if entry and comments[entry.last.first.first]
+            self.prism_range(comments[entry.last.first.first].location)
+          else
+            self.prism_node_range(node)
+          end
+        end
+
+        def terminated?(line)
+          text = line.strip
+
+          text.empty? or TERMINAL.any?{|mark| text.end_with?(mark)}
+        end
+
+        # What decode shifts lines off, which remembers them.
+        class Consumable
+          def initialize(entries)
+            @entries = entries
+            @log = []
+          end
+
+          attr :log
+
+          def first = @entries.first&.last
+
+          def shift
+            entry = @entries.shift
+
+            if entry
+              @log << entry
+              entry.last
+            end
+          end
+
+          def empty? = @entries.empty?
+        end
+      end
+    end
+  end
+end

data/cops/constant_matches_path.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Bans a constant that does not match its file's path.
+#
+# @example
+#   lib/mailers/welcome.rb          -> Mailers::Welcome          # YES
+#   lib/mailers/welcome.rb          -> WelcomeMailer             # NO
+#   lib/models/11_organization.rb   -> Models::Organization      # YES
+#   lib/jobs/sync_tenant_claims.rb  -> Jobs::SyncTenantClaims    # YES
+#   lib/jobs/sync_tenant_claims.rb  -> SyncTenantClaimsJob       # NO
+module RuboCop
+  module Cop
+    module Local
+      class ConstantMatchesPath < Base
+        MSG = "`%<actual>s` does not match its path; this file should define " \
+              "`%<expected>s` (or a constant nested inside it)."
+
+        MSG_EMPTY = "This file defines no namespaced constant; it should define " \
+                    "`%<expected>s`."
+
+        # Directories that are a load path root, not a namespace segment.
+        def roots = Array(cop_config.fetch("Roots", ["lib"]))
+
+        def inflections = cop_config.fetch("Inflections", {})
+
+        # Paths that legitimately define something else, such as monkey patches.
+        def ignored = Array(cop_config.fetch("IgnorePaths", []))
+
+        def on_new_investigation
+          if processed_source.blank?
+            nil
+          else
+            expected_namespace(processed_source.file_path).then do |expected|
+              # A file outside a configured root, or an ignored path, has no namespace to be wrong about. Nor does one that defines no constant at all -- an empty file, or one that only runs code.
+              unless expected.nil?
+                report(top_level_constants(processed_source.ast), expected)
+              end
+            end
+          end
+        end
+
+        private
+
+          def report(defined, expected)
+            defined.each do |name, node|
+              unless matches?(name, expected)
+                add_offense(node, message: format(MSG, actual: name, expected: expected))
+              end
+            end
+          end
+
+          # `Mailers::Welcome` is right for lib/mailers/welcome.rb, and so is `Mailers` alone (a file may open its own namespace to add to it).
+          def matches?(actual, expected)
+            actual == expected ||
+              expected.start_with?("#{actual}::") ||
+              actual.start_with?("#{expected}::")
+          end
+
+          def expected_namespace(path)
+            parts = path.to_s.split(File::SEPARATOR)
+            root  = parts.rindex { |part| roots.include?(part) }
+            segments = root && parts[(root + 1)..]
+
+            if segments.nil? || segments.empty? || ignored?(segments)
+              nil
+            else
+              named = segments.dup
+              named[-1] = named[-1].sub(/\.rb\z/, "")
+              named.map { |segment| camelize(segment) }.join("::")
+            end
+          end
+
+          def ignored?(segments)
+            ignored.any? do |glob|
+              File.fnmatch?(glob, segments.join("/"), File::FNM_PATHNAME)
+            end
+          end
+
+          # `11_organization` -> `Organization`. The prefix orders loading; it is not part of the name.
+          def camelize(segment)
+            name = segment.sub(/\A\d+_/, "")
+
+            if inflections.key?(name)
+              inflections[name]
+            else
+              name.split("_").map { |word| inflections[word] || word.capitalize }.join
+            end
+          end
+
+          # The constants a file opens at its top level, flattened through compact forms so `module A; class B` and `class A::B` both read as `A::B`.
+          def top_level_constants(node, prefix = nil)
+            if node.nil?
+              []
+            elsif node.begin_type?
+              node.children.flat_map { |child| top_level_constants(child, prefix) }
+            elsif node.module_type? || node.class_type?
+              constants_in(node, prefix)
+            else
+              []
+            end
+          end
+
+          def constants_in(node, prefix)
+            name = qualified(node.children.first)
+
+            if name.nil?
+              []
+            else
+              if prefix
+                full = "#{prefix}::#{name}"
+              else
+                full = name
+              end
+
+              body = node.children[node.class_type? ? 2 : 1]
+              nested = top_level_constants(body, full)
+
+              # Report the DEEPEST constant: `module Jobs; class Foo` is an offence about `Jobs::Foo`, not about `Jobs`.
+              if nested.empty?
+                [[full, node]]
+              else
+                nested
+              end
+            end
+          end
+
+          def qualified(const)
+            if const&.const_type?
+              namespace = const.namespace
+
+              if namespace.nil? || namespace.cbase_type?
+                const.short_name.to_s
+              else
+                inner = qualified(namespace)
+                inner && "#{inner}::#{const.short_name}"
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/cops/multiline_method_arguments.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Bans a call with more than `MaxArguments` arguments.
+#
+# @example
+#   walk(rest, current_dir, controller_segments, dynamic_pairs + [[param_name, segment]], last_dir_name)
+#
+# @example Each argument on its own line
+#   walk(                                                           # YES
+#     rest,
+#     current_dir,
+#     controller_segments,
+#     dynamic_pairs + [[param_name, segment]],
+#     last_dir_name,
+#   )
+module RuboCop
+  module Cop
+    module Local
+      class MultilineMethodArguments < Base
+        extend AutoCorrector
+
+        MSG = "Call takes %<count>d arguments; put each one on its own line."
+
+        def on_send(node)
+          if too_many_on_one_line?(node)
+            add_offense(node, message: format(MSG, count: node.arguments.count)) do |corrector|
+              break_arguments(corrector, node)
+            end
+          end
+        end
+
+        alias on_csend on_send
+        alias on_super on_send
+
+        private
+
+          def too_many_on_one_line?(node)
+            node.parenthesized? &&
+              node.arguments.count > max_arguments &&
+              !every_argument_on_its_own_line?(node)
+          end
+
+          # The first argument must clear the line that opened the call, and no two arguments may share a line.
+          def every_argument_on_its_own_line?(node)
+            lines = node.arguments.map { |argument| argument.source_range.first_line }
+
+            lines.first > node.loc.begin.line && lines == lines.uniq
+          end
+
+          def break_arguments(corrector, node)
+            if safe_to_break?(node)
+              corrector.insert_after(node.loc.begin, "\n")
+
+              node.arguments.each_cons(2) do |left, right|
+                corrector.replace(between(left, right), ",\n")
+              end
+
+              corrector.insert_before(node.loc.end, "\n")
+            end
+          end
+
+          # A heredoc's body sits below its line, and comments between arguments would be overwritten; both are left alone.
+          def safe_to_break?(node)
+            node.arguments.none? { |argument| contains_heredoc?(argument) } &&
+              node.arguments.each_cons(2).none? do |left, right|
+                between(left, right).source.include?("#")
+              end
+          end
+
+          def contains_heredoc?(node)
+            node.each_node(:str, :dstr, :xstr).any?(&:heredoc?)
+          end
+
+          # The comma-and-whitespace run separating two arguments.
+          def between(left, right)
+            Parser::Source::Range.new(
+              processed_source.buffer,
+              left.source_range.end_pos,
+              right.source_range.begin_pos,
+            )
+          end
+
+          def max_arguments
+            cop_config.fetch("MaxArguments", 3)
+          end
+      end
+    end
+  end
+end