kube_cluster 1.9.0 → 2.0.0

data/cops/support/prism_source.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Reads the file under inspection with Prism, which ships with Ruby, instead of through the parser gem syntax tree RuboCop hands a cop.
+#
+# A cop which includes this does not use the `on_<type>` callbacks: those are driven by the parser gem tree, so a cop which reads a different tree walks it itself from `on_new_investigation`. What it gains is one parse of the file by the same Prism which runs the program, and a uniform walk over every node.
+#
+# Offences are still reported against `Parser::Source::Range`, because that is what RuboCop and its correctors take. THE TWO DO NOT MEASURE THE SAME WAY: a Prism location counts BYTES and a `Parser::Source::Range` counts CHARACTERS, so a range built from `start_offset` is correct only until the first multibyte character in the file and silently wrong after it. Prism gives both, and `prism_range` takes the character pair.
+#
+# Prism does not track parentage - a node does not name the node it is written inside - so the walk records the parent of each node as it descends.
+
+require "prism"
+
+module RuboCop
+  module Cop
+    module PrismSource
+      # @returns [Prism::ParseResult] the file, parsed once however many times this is called.
+      def prism_result
+        self.prism_state.fetch(:result)
+      end
+
+      # Every node in the file, outermost first, in source order.
+      #
+      # @returns [Array(Prism::Node)] the nodes.
+      def prism_nodes
+        self.prism_state.fetch(:nodes)
+      end
+
+      # @parameter classes [Array(Class)] the Prism node classes wanted.
+      # @returns [Array(Prism::Node)] the nodes which are one of them.
+      def prism_each(*classes)
+        if classes.empty?
+          self.prism_nodes
+        else
+          self.prism_nodes.select{|node| classes.any?{|klass| node.is_a?(klass)}}
+        end
+      end
+
+      # @parameter node [Prism::Node] the node whose parent is wanted.
+      # @returns [Prism::Node | nil] the node it is written inside, or nil at the root.
+      def prism_parent(node)
+        self.prism_state.fetch(:parents)[node]
+      end
+
+      # The nodes a node is written inside, innermost first.
+      #
+      # @returns [Array(Prism::Node)] the ancestors.
+      def prism_ancestors(node)
+        [].tap do |found|
+          current = self.prism_parent(node)
+
+          while current
+            found << current
+            current = self.prism_parent(current)
+          end
+        end
+      end
+
+      # @returns [Array(Prism::Node)] the nodes written directly inside the given node.
+      def prism_children(node)
+        node.compact_child_nodes
+      end
+
+      # Everything written inside the given node, at any depth, outermost first.
+      #
+      # @parameter classes [Array(Class)] the Prism node classes wanted, or none for all of them.
+      # @returns [Array(Prism::Node)] the nodes.
+      def prism_descendants(node, *classes)
+        [].tap do |found|
+          pending = node.compact_child_nodes.dup
+
+          until pending.empty?
+            current = pending.shift
+
+            if classes.empty? or classes.any?{|klass| current.is_a?(klass)}
+              found << current
+            end
+
+            pending.concat(current.compact_child_nodes)
+          end
+        end
+      end
+
+      # Whether the given node contains a heredoc, whose content lives below the line it opens on.
+      def prism_heredoc?(node)
+        [node].concat(self.prism_descendants(node)).any? do |current|
+          case current
+          when ::Prism::StringNode, ::Prism::InterpolatedStringNode,
+               ::Prism::XStringNode, ::Prism::InterpolatedXStringNode
+            current.heredoc?
+          else
+            false
+          end
+        end
+      end
+
+      # The statements of a body, whether it holds one or many.
+      #
+      # @parameter body [Prism::StatementsNode | nil] the body of a method, module, or block.
+      # @returns [Array(Prism::Node)] its statements, which is empty when there is no body.
+      def prism_statements(body)
+        if body.nil?
+          []
+        else
+          body.body
+        end
+      end
+
+      # A Prism location as the range RuboCop reports an offence against.
+      #
+      # @parameter location [Prism::Location] where the offence is.
+      # @returns [Parser::Source::Range] the same place, measured for RuboCop.
+      def prism_range(location)
+        # CHARACTER OFFSETS, NOT `start_offset`. A `Parser::Source::Range` indexes the buffer by character and a Prism location counts bytes, so a range built from the byte pair lands further and further past where it should as the multibyte characters above it accumulate. A corrector handed such a range replaces the wrong text and writes a file which no longer parses.
+        ::Parser::Source::Range.new(
+          processed_source.buffer,
+          location.start_character_offset,
+          location.end_character_offset,
+        )
+      end
+
+      # One range reaching from the start of the first location to the end of the last, for an offence over a run of statements rather than a single node.
+      #
+      # @returns [Parser::Source::Range] the span.
+      def prism_span(first, last)
+        ::Parser::Source::Range.new(
+          processed_source.buffer,
+          first.start_character_offset,
+          last.end_character_offset,
+        )
+      end
+
+      # @returns [Parser::Source::Range] the whole of the given node.
+      def prism_node_range(node)
+        self.prism_range(node.location)
+      end
+
+      # The column a node starts at, counted the way a Ruby String is indexed.
+      #
+      # @returns [Integer] the character column.
+      def prism_column(node)
+        # `Prism::Location#start_column` counts bytes, so indexing a line from `processed_source.lines` with it cuts in the wrong place once anything above or before it on that line is multibyte.
+        node.location.start_character_column
+      end
+
+      # @returns [String] the source of the given node.
+      def prism_source(node)
+        node.location.slice
+      end
+
+      # @returns [Array(Prism::InlineComment)] every comment in the file, in source order.
+      def prism_comments
+        self.prism_result.comments
+      end
+
+      # The run of comment lines written directly above a declaration, which is what documents it.
+      #
+      # @returns [Array(Prism::InlineComment)] the comments, in source order.
+      def prism_leading_comments(node)
+        self.prism_state.fetch(:leading)[node] ||= self.contiguous_above(node)
+      end
+
+      # Every comment a declaration owns, which is the same run: a comment belongs to whatever it is written above.
+      #
+      # @returns [Array(Prism::InlineComment)] the comments, in source order.
+      def prism_owned_comments(node)
+        self.prism_leading_comments(node)
+      end
+
+      private
+
+      # Everything read from the file, discarded when RuboCop moves to the next one.
+      def prism_state
+        source = processed_source
+
+        unless @prism_state and @prism_source.equal?(source)
+          @prism_source = source
+          @prism_state = self.read(source)
+        end
+
+        @prism_state
+      end
+
+      def read(source)
+        result = ::Prism.parse(source.buffer.source)
+
+        nodes = []
+        parents = {}.compare_by_identity
+
+        self.descend(result.value, nil, nodes, parents)
+
+        by_line = {}
+
+        result.comments.each do |comment|
+          by_line[comment.location.start_line] = comment
+        end
+
+        {
+          result: result,
+          nodes: nodes,
+          parents: parents,
+          by_line: by_line,
+          leading: {}.compare_by_identity,
+        }
+      end
+
+      # The tree, recorded flat with the parent of each node, since Prism does not say.
+      def descend(node, parent, nodes, parents)
+        nodes << node
+        parents[node] = parent
+
+        node.compact_child_nodes.each do |child|
+          self.descend(child, node, nodes, parents)
+        end
+      end
+
+      # The run of comment lines ending on the line above the node, stopping at the first gap.
+      def contiguous_above(node)
+        by_line = self.prism_state.fetch(:by_line)
+        found = []
+        line = node.location.start_line - 1
+
+        while comment = by_line[line]
+          found.unshift(comment)
+          line -= 1
+        end
+
+        found
+      end
+    end
+  end
+end

data/cops/use_tap.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Requires `tap` when a method opens by assigning a local variable and closes by
+# returning that same variable:
+#
+#   def require_existing_column!                                    # NO
+#     column = params[:id].to_s
+#     unless connection.columns(@table).any? { |c| c.name == column }
+#       render json: { error: "unknown column" }, status: :not_found
+#     end
+#     column
+#   end
+#
+#   def require_existing_column!                                    # YES
+#     params[:id].to_s.tap do |column|
+#       unless connection.columns(@table).any? { |c| c.name == column }
+#         render json: { error: "unknown column" }, status: :not_found
+#       end
+#     end
+#   end
+#
+# The assign-work-return shape states the return value twice — once as the
+# assignment target, once as a bare mention on the last line — and puts the two
+# far enough apart that the trailing `column` reads as a stray expression.
+# `tap` names the value once, scopes it to the block that works on it, and makes
+# "the value flows through unchanged" structural rather than something you check
+# by comparing the first and last lines.
+#
+# A body that REASSIGNS the variable is left alone: `tap` yields the original
+# object and returns it, so that rewrite would change the result.
+module RuboCop
+  module Cop
+    module Local
+      class UseTap < Base
+        MSG = "Assigning `%<name>s` and returning it at the end is `tap`; " \
+              "write `<expression>.tap do |%<name>s| ... end`."
+
+        # Every way a local can be written to after the opening assignment.
+        REASSIGNMENTS = %i[lvasgn op_asgn or_asgn and_asgn masgn].freeze
+
+        def on_def(node)
+          check(node.body)
+        end
+
+        def on_defs(node)
+          check(node.body)
+        end
+
+        private
+
+          def check(body)
+            if tap_shaped?(body)
+              add_offense(body, message: format(MSG, name: assigned_name(body)))
+            end
+          end
+
+          # First statement assigns a local; last statement is that same local,
+          # read and nothing else.
+          def tap_shaped?(body)
+            body&.begin_type? &&
+              body.children.size >= 2 &&
+              body.children.first.lvasgn_type? &&
+              returns_assigned?(body) &&
+              !reassigned?(body)
+          end
+
+          def assigned_name(body)
+            body.children.first.name
+          end
+
+          def returns_assigned?(body)
+            last = body.children.last
+
+            last.lvar_type? && last.children.first == assigned_name(body)
+          end
+
+          # `tap` yields the object the receiver evaluated to, so a body that
+          # points the name at something else partway through is a different
+          # program and must not be flagged.
+          def reassigned?(body)
+            name = assigned_name(body)
+
+            body.children[1..-2].any? do |statement|
+              statement.each_node(*REASSIGNMENTS).any? do |write|
+                writes_name?(write, name)
+              end
+            end
+          end
+
+          def writes_name?(node, name)
+            if node.masgn_type?
+              node.assignments.any? { |target| target == name }
+            else
+              node.children.first == name
+            end
+          end
+      end
+    end
+  end
+end

data/flake.lock

@@ -8,11 +8,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1790556091,
-        "narHash": "sha256-+kgvg6vuaxjEUUad6pL+pxa3LZFveq3XvWGSZ+Z9gOA=",
+        "lastModified": 1790610895,
+        "narHash": "sha256-sansiZlrb60MrGFzTXNCVVMTU5EsGM6KWvZkA/aNp14=",
         "owner": "n-at-han-k",
         "repo": "flake.nix",
-        "rev": "d023f40398596a5d80bf03e429c678a99b3f259a",
+        "rev": "0f3388742debac3e78751796f4568f441c0dee57",
         "type": "github"
       },
       "original": {

data/flake.nix

@@ -10,34 +10,35 @@
   outputs = { self, nixpkgs, utils, mine }:
     utils.lib.eachDefaultSystem (system:
       let
-        # No mine.overlays.default: it overrides pkg-config, which stdenv
-        # splices, so the overlay rebuilds stdenv and all of nixpkgs from
-        # source. mine.inputs.nixpkgs.follows makes it redundant anyway.
         pkgs = nixpkgs.legacyPackages.${system};
-        ruby = pkgs.ruby_3_4;
-        kubectlWithKubeconfig = pkgs.writeShellScriptBin "kubectl" ''
-          #!${pkgs.bash}/bin/bash
-          KUBECONFIG="$PWD/kubeconfig.yaml" ${pkgs.kubectl}/bin/kubectl "$@"
-        '';
+        lib = mine.lib.${system};
+
+        gems = pkgs.bundlerEnv {
+          name = "kube_cluster-gems";
+          ruby = pkgs.ruby_3_4;
+          gemfile = ./Gemfile;
+          lockfile = ./Gemfile.lock;
+          gemset = ./gemset.nix;
+        };
       in
       {
-        # pkg-config, bundix, libyaml, openssl, overmind, tmux and `bundix -l`
-        # come from mkRubyShell.
-        devShells.default = mine.lib.${system}.mkRubyShell {
+        devShells.default = lib.mkRubyShell {
           buildInputs = [
-            pkgs.trufflehog
-            ruby
-            kubectlWithKubeconfig
+            gems
+            gems.wrappedRuby
+            pkgs.ripgrep # scampi shells out to `rg` to discover __END__ spec sections
           ];
 
-          shellHook = ''
-            export GEM_HOME="$HOME/.gem-${ruby.version}"
-            export GEM_PATH="$GEM_HOME"
-            export PATH="$GEM_HOME/bin:$PATH"
-            export BUNDLE_PATH="$GEM_HOME"
+          shellHook = /* bash */ ''
+            unset RUBYOPT
+            export BUNDLE_FORCE_RUBY_PLATFORM=false
             export BUNDLE_GEMFILE="$PWD/Gemfile"
-            export BUNDLE_BIN="$GEM_HOME/bin"
-            export KUBECONFIG="$PWD/kubeconfig.yaml"
+            export BUNDLE_FROZEN=false
+
+            export LANG="''${LANG:-C.UTF-8}"
+            export LC_ALL="''${LC_ALL:-$LANG}"
+
+            export RUBYLIB="$PWD/lib''${RUBYLIB:+:$RUBYLIB}"
           '';
         };
       }

data/gemset.nix

@@ -10,6 +10,16 @@
     };
     version = "8.1.3";
   };
+  ast = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "10yknjyn0728gjn6b5syynvrvrwm66bhssbxq8mkhshxghaiailm";
+      type = "gem";
+    };
+    version = "2.4.3";
+  };
   async = {
     dependencies = ["console" "fiber-annotation" "io-event" "metrics" "traces"];
     groups = ["default" "maintenance"];
@@ -168,10 +178,10 @@
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1g9zi8c4i7g8zz0c3hxrw6mblrjvgn7akys60clb9si7c1k1gljk";
+      sha256 = "0rng45p4vc3f6nac44cnylwch7rj4zsff3icdz6c7garwpjy3sv1";
       type = "gem";
     };
-    version = "4.1.2";
+    version = "4.1.3";
   };
   build-files = {
     groups = ["default" "maintenance"];
@@ -308,6 +318,27 @@
     };
     version = "1.0.1";
   };
+  gem_kit = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0dx9w041lqzr4jd0m9as0v5v6n3fj2hcg74p2gyswr2y2a6zc5v9";
+      type = "gem";
+    };
+    version = "0.2.0";
+  };
+  gem_kit-release = {
+    dependencies = ["gem_kit" "thor"];
+    groups = ["release"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1cnl3p4y9jfag8q908ih28q3hll21b3ban5j004cra7l58hg3rrq";
+      type = "gem";
+    };
+    version = "0.3.2";
+  };
   hana = {
     groups = ["default"];
     platforms = [];
@@ -411,16 +442,6 @@
     };
     version = "2.5.0";
   };
-  kube_cluster = {
-    dependencies = ["activesupport" "kube_kubectl" "kube_schema"];
-    groups = ["default"];
-    platforms = [];
-    source = {
-      path = ./.;
-      type = "path";
-    };
-    version = "1.8.0";
-  };
   kube_kubectl = {
     dependencies = ["debug" "json_schemer" "rubyshell" "shellwords" "string_builder"];
     groups = ["default"];
@@ -433,15 +454,25 @@
     version = "2.0.9";
   };
   kube_schema = {
-    dependencies = ["json_schemer" "rubyshell"];
+    dependencies = ["gem_kit" "json_schemer" "rubyshell"];
     groups = ["default"];
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1f8nazb6glzxkms0paqsn9x0zihmgj739l2shnwafhzaxgxcqy4z";
+      sha256 = "03nzn7mx1cmkbvbiiyk7qcw2npwhdi1g19i6l5m5p17iz4zlcrj0";
       type = "gem";
     };
-    version = "1.11.0";
+    version = "2.0.0";
+  };
+  language_server-protocol = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1w5p8c2145lmqzr25bxh4ikzjm6k8y1k5lriqqdpw9pq730w1wjy";
+      type = "gem";
+    };
+    version = "3.17.0.6";
   };
   lefthook = {
     groups = ["development"];
@@ -453,6 +484,16 @@
     };
     version = "2.1.10";
   };
+  lint_roller = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "11yc0d84hsnlvx8cpk4cbj6a4dz9pk0r1k29p0n1fz9acddq831c";
+      type = "gem";
+    };
+    version = "1.1.0";
+  };
   localhost = {
     dependencies = ["bake"];
     groups = ["default" "maintenance"];
@@ -621,6 +662,27 @@
     };
     version = "4.0.2";
   };
+  parallel = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0vvs2sar7wnw70j1jc1kv1k23m5grc0ci3bbrcf6mkh18683wnpp";
+      type = "gem";
+    };
+    version = "2.3.0";
+  };
+  parser = {
+    dependencies = ["ast" "racc"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0a4q5h2hcihk79dbr20scgkm56l79qp7fsvfvkxlv8nmapvxg9i1";
+      type = "gem";
+    };
+    version = "3.3.12.0";
+  };
   pp = {
     dependencies = ["prettyprint"];
     groups = ["default" "maintenance"];
@@ -726,6 +788,16 @@
     };
     version = "5.3.1";
   };
+  racc = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0byn0c9nkahsl93y9ln5bysq4j31q8xkf2ws42swighxd4lnjzsa";
+      type = "gem";
+    };
+    version = "1.8.1";
+  };
   rack = {
     groups = ["default" "maintenance"];
     platforms = [];
@@ -747,6 +819,16 @@
     };
     version = "1.4.1";
   };
+  rainbow = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0smwg4mii0fm38pyb5fddbmrdpifwv22zv3d3px2xx497am93503";
+      type = "gem";
+    };
+    version = "3.1.1";
+  };
   rake = {
     groups = ["development"];
     platforms = [];
@@ -784,10 +866,10 @@
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1fwfw26a32rps78920nn29shqg2zmqv72i89j1fap41isshida9m";
+      sha256 = "0jxl6c5cagjz5i5n9jplhdy2izad6wapmwgfhqggb22nqfvvdvas";
       type = "gem";
     };
-    version = "2.12.0";
+    version = "2.13.1";
   };
   reline = {
     dependencies = ["io-console"];
@@ -800,6 +882,38 @@
     };
     version = "0.6.3";
   };
+  rubocop = {
+    dependencies = ["json" "language_server-protocol" "lint_roller" "parallel" "parser" "rainbow" "regexp_parser" "rubocop-ast" "ruby-progressbar" "unicode-display_width"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1q2nih91fjbv6j1qqxfhlc480zyhz94rniyh469vsw1fzd0q1xia";
+      type = "gem";
+    };
+    version = "1.92.0";
+  };
+  rubocop-ast = {
+    dependencies = ["parser" "prism"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1nw84xk6vc2ls8sxqvyhxs2agh4l0jrws85d4bi3x0501lq8ijmr";
+      type = "gem";
+    };
+    version = "1.50.0";
+  };
+  ruby-progressbar = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0cwvyb7j47m7wihpfaq7rc47zwwx9k4v7iqd9s1xch5nm53rrz40";
+      type = "gem";
+    };
+    version = "1.13.0";
+  };
   rubyshell = {
     groups = ["default"];
     platforms = [];
@@ -866,10 +980,10 @@
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0a9c1mdy12y81ck7mcn9f9i2s2wwzjh1nr92ps354q517zq9dkh8";
+      sha256 = "00sdym5q3d9zg7lv47mjamzv67z1lfyd3gz9256v0g9gxl5p7jhj";
       type = "gem";
     };
-    version = "0.2.3";
+    version = "0.3.0";
   };
   string-format = {
     groups = ["default" "maintenance"];
@@ -901,6 +1015,16 @@
     };
     version = "3.2.0";
   };
+  thor = {
+    groups = ["default" "release"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0wsy88vg2mazl039392hqrcwvs5nb9kq8jhhrrclir2px1gybag3";
+      type = "gem";
+    };
+    version = "1.5.0";
+  };
   thread-local = {
     groups = ["default" "maintenance"];
     platforms = [];
@@ -952,6 +1076,27 @@
     };
     version = "2.0.6";
   };
+  unicode-display_width = {
+    dependencies = ["unicode-emoji"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "04xnl0zwpjjvxipd6rdnxkm11pfhbhhi3179yzv51nqi9dmacyjb";
+      type = "gem";
+    };
+    version = "3.3.0";
+  };
+  unicode-emoji = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1kp89lja8ii7l6f0bq5vdxq1p3kxr3a2qmmhdc38qdwh6akjzh0i";
+      type = "gem";
+    };
+    version = "4.3.0";
+  };
   uri = {
     groups = ["default"];
     platforms = [];