kube_kubectl 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8d33ec25c06aef9931a7b340e17de2920f4cdb8675507c74516d0d3d152e8f4
-  data.tar.gz: 2ccfb320c419f49a220781e402b2d146a94436c8376d4945a24cdc09958965ad
+  metadata.gz: 7c1f62f75309c836223f481c105768b6e67fd2bfc4533c80e7aab9116da287b9
+  data.tar.gz: c0c8d859157bd69147c6b0f56b049a1a344a36d1172cbe090ba7a70f4561d2b4
 SHA512:
-  metadata.gz: 7a82e93491a8f911a898b3fd276ac617a37d3d793ca143f27c1a35a6296ff33823e698591a55cf0716fa055a9db13ed5e491431c4f94bc793e6a855a20aeedfa
-  data.tar.gz: 79ccfcba0a85fda3536b74962dc9cb3bf66c3884e927aa820f7da76caeba815998ddeb703128d543d14683358fddf2aeed5a7fddf5f4a649147fadae77fc36cf
+  metadata.gz: 8fbc323f909aa80047d0a125d730703b9908a06f7cfa7dc90002bcdf6c222da123e6c7d8ce55610011357f33ec835b607a10696ddceba0681231d7156becb015
+  data.tar.gz: ee25e1d7f70d8029477143e12a7b05b19cc400b2b7fc6a5cf17def7caffe6a5c3966b6962bf0dd8d690b6eeb97fa27e1d2947f9fa06bfcf652543123e2b446b4

data/data/kubectl-command-tree-v1-minimal.json

@@ -0,0 +1,125 @@
+{
+  "create": {
+    "clusterrole": {},
+    "clusterrolebinding": {},
+    "configmap": {},
+    "cronjob": {},
+    "deployment": {},
+    "ingress": {},
+    "job": {},
+    "namespace": {},
+    "poddisruptionbudget": {},
+    "priorityclass": {},
+    "quota": {},
+    "role": {},
+    "rolebinding": {},
+    "secret": {
+      "docker-registry": {},
+      "generic": {},
+      "tls": {}
+    },
+    "service": {
+      "clusterip": {},
+      "externalname": {},
+      "loadbalancer": {},
+      "nodeport": {}
+    },
+    "serviceaccount": {},
+    "token": {}
+  },
+  "expose": {},
+  "run": {},
+  "set": {
+    "env": {},
+    "image": {},
+    "resources": {},
+    "selector": {},
+    "serviceaccount": {},
+    "subject": {}
+  },
+  "explain": {},
+  "get": {},
+  "edit": {},
+  "delete": {},
+  "rollout": {
+    "history": {},
+    "pause": {},
+    "restart": {},
+    "resume": {},
+    "status": {},
+    "undo": {}
+  },
+  "scale": {},
+  "autoscale": {},
+  "certificate": {
+    "approve": {},
+    "deny": {}
+  },
+  "cluster-info": {
+    "dump": {}
+  },
+  "top": {
+    "node": {},
+    "pod": {}
+  },
+  "cordon": {},
+  "uncordon": {},
+  "drain": {},
+  "taint": {},
+  "describe": {},
+  "logs": {},
+  "attach": {},
+  "exec": {},
+  "port-forward": {},
+  "proxy": {},
+  "cp": {},
+  "auth": {
+    "can-i": {},
+    "reconcile": {},
+    "whoami": {}
+  },
+  "debug": {},
+  "events": {},
+  "diff": {},
+  "apply": {
+    "edit-last-applied": {},
+    "set-last-applied": {},
+    "view-last-applied": {}
+  },
+  "patch": {},
+  "replace": {},
+  "wait": {},
+  "kustomize": {},
+  "label": {},
+  "annotate": {},
+  "completion": {},
+  "alpha": {
+    "kuberc": {
+      "set": {},
+      "view": {}
+    }
+  },
+  "api-resources": {},
+  "api-versions": {},
+  "config": {
+    "current-context": {},
+    "delete-cluster": {},
+    "delete-context": {},
+    "delete-user": {},
+    "get-clusters": {},
+    "get-contexts": {},
+    "get-users": {},
+    "rename-context": {},
+    "set": {},
+    "set-cluster": {},
+    "set-context": {},
+    "set-credentials": {},
+    "unset": {},
+    "use-context": {},
+    "view": {}
+  },
+  "plugin": {
+    "list": {}
+  },
+  "version": {}
+}

data/kube_ctl.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.metadata['documentation_uri'] = spec.homepage
   spec.metadata['rubygems_mfa_required'] = 'true'
 
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|data)/}) }
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

data/lib/kube/ctl/command_node.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Kube
+  module Ctl
+    class CommandNode
+      include Enumerable
+
+      BLANK_DATA = { commands: [], resource: nil, args: [], flags: {} }.freeze
+
+      attr_reader :command_data
+
+      def initialize(current_node:, command_data: BLANK_DATA)
+        @current_node = current_node
+        @command_data = command_data
+      end
+
+      def flag(key, value = nil)
+        self.class.new(
+          current_node: @current_node,
+          command_data: @command_data.merge(
+            flags: @command_data[:flags].merge(key.to_s.tr('_', '-') => value)
+          )
+        )
+      end
+
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def to_a
+        QueryBuilder.new(@command_data).to_a
+      end
+
+      def to_s
+        QueryBuilder.new(@command_data).to_s
+      end
+
+      def inspect
+        "#<#{self.class.name} #{self}>"
+      end
+
+      def method_missing(name, *args, &block)
+        segment = name.to_s.tr('_', '-')
+        child   = @current_node.children[segment]
+
+        if child&.command?
+          self.class.new(
+            current_node: child,
+            command_data: @command_data.merge(
+              commands: @command_data[:commands] + [segment],
+              args: @command_data[:args] + args.map(&:to_s)
+            )
+          )
+        elsif child&.resource?
+          self.class.new(
+            current_node: child,
+            command_data: @command_data.merge(
+              resource: (@command_data[:resource] || ResourceSelector.new) + [segment],
+              args: @command_data[:args] + args.map(&:to_s)
+            )
+          )
+        elsif @current_node.resource? || @current_node.children.empty?
+          # Leaf command or already in resource mode — free-form resource segment
+          self.class.new(
+            current_node: TreeNode.new(name: segment, type: :resource),
+            command_data: @command_data.merge(
+              resource: (@command_data[:resource] || ResourceSelector.new) + [segment],
+              args: @command_data[:args] + args.map(&:to_s)
+            )
+          )
+        elsif Enumerable.method_defined?(name)
+          to_a.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        segment = name.to_s.tr('_', '-')
+
+        @current_node.children.key?(segment) ||
+          @current_node.resource? ||
+          @current_node.children.empty? ||
+          Enumerable.method_defined?(name) ||
+          super
+      end
+    end
+  end
+end

data/lib/kube/ctl/instance.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kube
+  module Ctl
+    class Instance
+      GEM_ROOT = File.expand_path('../../..', __dir__)
+
+      COMMAND_TREE = JSON.parse(
+        File.read(File.join(GEM_ROOT, 'data', 'kubectl-command-tree-v1-minimal.json'))
+      )
+
+      ROOT = TreeNode.new(
+        name: 'kubectl',
+        type: :command,
+        children: TreeNode.build(COMMAND_TREE)
+      )
+
+      attr_reader :kubeconfig
+
+      # When kubeconfig is nil, no --kubeconfig flag is passed and
+      # kubectl falls back to its own default (~/.kube/config).
+      def initialize(kubeconfig: ENV['KUBECONFIG'])
+        @kubeconfig = kubeconfig
+      end
+
+      def method_missing(name, *args, &block)
+        root_node.public_send(name, *args, &block)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        root_node.respond_to?(name) || super
+      end
+
+      def inspect
+        "#<#{self.class.name} kubeconfig=#{@kubeconfig.inspect}>"
+      end
+
+      private
+
+      def root_node
+        CommandNode.new(current_node: ROOT, command_data: initial_command_data)
+      end
+
+      def initial_command_data
+        CommandNode::BLANK_DATA.merge(flags: initial_flags)
+      end
+
+      def initial_flags
+        @kubeconfig ? { 'kubeconfig' => @kubeconfig } : {}
+      end
+    end
+  end
+end

data/lib/kube/ctl/query_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Kube
+  module Ctl
+    class QueryBuilder
+      def initialize(command_data)
+        @commands = command_data[:commands] || []
+        @resource = command_data[:resource]
+        @args     = command_data[:args] || []
+        @flags    = command_data[:flags] || {}
+      end
+
+      def to_s
+        ['kubectl', *@commands, *resource_arg, *@args, *rendered_flags].join(' ')
+      end
+
+      def to_a
+        stdout, _status = Open3.capture2('kubectl', *@commands, *resource_arg, *@args, *rendered_flags)
+        stdout.lines.map(&:chomp)
+      end
+
+      private
+
+      def resource_arg
+        @resource ? [@resource.to_s] : []
+      end
+
+      def rendered_flags
+        @flags.flat_map { |k, v| v.nil? ? ["--#{k}"] : ["--#{k}", v.to_s] }
+      end
+    end
+  end
+end

data/lib/kube/ctl/resource_selector.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kube
+  module Ctl
+    class ResourceSelector < Array
+      def +(other)
+        self.class.new(super)
+      end
+
+      def to_s
+        join('.')
+      end
+
+      def to_regex
+        Regexp.new(map { |s| Regexp.escape(s) }.join('.*\.'))
+      end
+    end
+  end
+end

data/lib/kube/ctl/tree_node.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kube
+  module Ctl
+    class TreeNode
+      # Commands whose leaf children are resource types.
+      # Non-leaf children (those with their own subtree) remain commands.
+      RESOURCE_PARENTS = %w[
+        create
+        create/secret
+        create/service
+        top
+      ].freeze
+
+      attr_reader :name, :type, :children
+
+      def initialize(name:, type:, children: {})
+        @name     = name.freeze
+        @type     = type
+        @children = children.freeze
+      end
+
+      def command?  = type == :command
+      def resource? = type == :resource
+
+      # Recursively build a children hash of TreeNodes from the parsed JSON.
+      # parent_path tracks position in the tree to determine child types.
+      def self.build(hash, parent_path: nil)
+        hash.each_with_object({}) do |(key, subtree), children|
+          name         = key.to_s
+          current_path = [parent_path, name].compact.join('/')
+          leaf         = subtree.empty?
+
+          # Under a resource parent, leaf nodes are resources, non-leaves are commands.
+          # Everywhere else, everything is a command.
+          child_type = if RESOURCE_PARENTS.include?(parent_path.to_s) && leaf
+                         :resource
+                       else
+                         :command
+                       end
+
+          children[name] = new(
+            name: name,
+            type: child_type,
+            children: build(subtree, parent_path: current_path)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kube/ctl/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Ctl
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/kube/ctl.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "ctl/version"
+require_relative 'ctl/version'
+require_relative 'ctl/tree_node'
+require_relative 'ctl/resource_selector'
+require_relative 'ctl/query_builder'
+require_relative 'ctl/command_node'
+require_relative 'ctl/instance'
 
 module Kube
   module Ctl

data/lib/kube.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'kube/ctl'
+
+module Kube
+  def self.ctl(kubeconfig: ENV['KUBECONFIG'])
+    Kube::Ctl::Instance.new(kubeconfig: kubeconfig)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_kubectl
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Nathan K
@@ -77,11 +77,18 @@ files:
 - bin/setup
 - bin/tag-version
 - bin/test
+- data/kubectl-command-tree-v1-minimal.json
 - exe/kube_ctl
 - flake.nix
 - kube_ctl.gemspec
 - kube_ctl.gemspec.erb
+- lib/kube.rb
 - lib/kube/ctl.rb
+- lib/kube/ctl/command_node.rb
+- lib/kube/ctl/instance.rb
+- lib/kube/ctl/query_builder.rb
+- lib/kube/ctl/resource_selector.rb
+- lib/kube/ctl/tree_node.rb
 - lib/kube/ctl/version.rb
 - lib/kube/ctl/version.rb.erb
 homepage: https://github.com/general-intelligence-systems/kube_ctl