gloo-cli 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb5afa063ddf131c135fc6c78b1af9af2f866e683522ef7d0565bbd7d95ac060
-  data.tar.gz: 26afa7e343e9539e942bbf2c78ee8218be70dc3a7a04e542574955452e9a5d84
+  metadata.gz: e85b61ea757d2e59ded7f9271a24394b66bc4ed6da70687257e0a4b8d6f2fcd6
+  data.tar.gz: faf2dcf643d24652a1a11be58232f235308878deb5c99b521d495031a40f2f8f
 SHA512:
-  metadata.gz: 847b73db8362c4bf1e2f153de7a3b6f255dab12bf21e9e5e9bc2bcb930d82a923bfccc2b929ae3344feead48ae2b4c5f333cbc0b336088127a70103549f6e2a6
-  data.tar.gz: b12d891f6255aa0f7ec36780af4af39a0ed1161673b641b5583dcca323530fdbb56424d088db29606f5c01a1ac9afd5e7e5baefd9a3f5937a5c232cf13590761
+  metadata.gz: cc7764a58cd890fe2100f4bd45ebf188d41726d583e0f86f5596ca1e0e958a9153de83a268d6fd14ad6ab78163e953a84bcfbe39aea2a829b2d54079ed3c4423
+  data.tar.gz: cc93483adce46c83815080802cab6fe1cc471a30f22fb52ef6d5a77b6153de27871717a71882c83a7d5ab4eb90cbf7cb3396419ee643b0fc76bd209eb0c47b02

data/lib/command.rb

@@ -0,0 +1,217 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# A CLI command.
+#
+
+class Command < Gloo::Core::Obj
+
+  KEYWORD = 'command'.freeze
+  KEYWORD_SHORT = 'command'.freeze
+  DESCRIPTION = 'description'.freeze
+  ACTION = 'action'.freeze
+  DYNAMIC = 'dynamic'.freeze
+  NODES = 'nodes'.freeze
+
+  CONTEXT = 'context'.freeze
+  OPTIONS = 'options'.freeze
+  OPTIONS_KEY = 'options_key'.freeze
+
+  #
+  # The name of the object type.
+  #
+  def self.typename
+    return KEYWORD
+  end
+
+  #
+  # The short name of the object type.
+  #
+  def self.short_typename
+    return KEYWORD_SHORT
+  end
+
+  # 
+  # Get the description of the command.
+  # 
+  def description
+    o = find_child DESCRIPTION
+    return '' unless o
+
+    return o.value
+  end
+
+  # 
+  # Is this a dynamic command?
+  # It is dynamic if there is a dynamic child.
+  # If so, it has contextual data.
+  # 
+  def dynamic?
+    o = find_child DYNAMIC
+    return true if o
+    return false
+  end
+
+  # 
+  # Get the dynamic key for this command.
+  # 
+  def dynamic_key
+    o = find_child DYNAMIC
+    return o ? o.value : nil
+  end
+
+  def context
+    o = find_child CONTEXT
+    return o ? o : nil
+  end
+
+  #
+  # Get the options key for this command.
+  #
+  def options_key
+    o = find_child OPTIONS_KEY
+    return o ? o.value : nil
+  end
+
+  #
+  # Get the options for this command.
+  #
+  def options
+    arr = []
+    o = find_child OPTIONS
+
+    if o
+      arr = o.children.map { |child| child.value }
+    end
+
+    return arr
+  end
+
+  # 
+  # Get the child nodes for this command.
+  # 
+  def nodes
+    o = find_child NODES
+    return o ? o : nil
+  end
+
+  # 
+  # Run the action script.
+  #
+  def run_action
+    o = find_child ACTION
+    return unless o
+
+    Gloo::Exec::Dispatch.message( @engine, 'run', o )
+  end
+
+  def run_action_with_context( context )
+    o = find_child ACTION
+    return unless o
+
+    ctx = find_child CONTEXT
+    ctx.set_value( context ) if ctx
+    
+    Gloo::Exec::Dispatch.message( @engine, 'run', o )
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Children
+  # ---------------------------------------------------------------------
+
+  #
+  # Does this object have children to add when an object
+  # is created in interactive mode?
+  # This does not apply during obj load, etc.
+  #
+  def add_children_on_create?
+    return true
+  end
+
+  #
+  # Add children to this object.
+  # This is used by containers to add children needed
+  # for default configurations.
+  #
+  def add_default_children
+    fac = @engine.factory
+    fac.create_string NAME, '', self
+    fac.create_string DESCRIPTION, '', self
+    fac.create_script ACTION, '', self
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Messages
+  # ---------------------------------------------------------------------
+
+  #
+  # Get a list of message names that this object receives.
+  #
+  def self.messages
+    return super + [ 'register' ]
+  end
+
+  #
+  # Register the command with the shell.
+  #
+  def msg_register
+    if @params&.token_count&.positive?
+      pn = Gloo::Core::Pn.new( @engine, @params.first )
+      shell = pn.resolve
+      shell.add_command( self, get_command_data )
+
+      # Are there options to add?
+      if options_key
+        shell.set_context( options_key, options )
+      end
+    end
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Helpers
+  # ---------------------------------------------------------------------
+
+  # 
+  # Get the child nodes for this command.
+  # 
+  def get_child_nodes
+    data = nodes.children.map do |child|
+      child.get_command_data
+    end
+
+    return data
+  end
+
+  # 
+  # Get the command data for this command.
+  # 
+  def get_command_data
+    if dynamic?
+      return {
+        name: name,
+        description: description,
+        dynamic: true,
+        obj: pn,
+        method: "cmd_obj_action_with_context",
+        source: dynamic_key
+      }
+    elsif nodes
+      return {
+        name: name,
+        description: description,
+        children: get_child_nodes
+      }
+    else
+      return {
+        name: name,
+        description: description,
+        method: "cmd_obj_action",
+        obj: pn
+      }
+    end
+  end
+
+end

data/lib/command_node.rb

@@ -0,0 +1,24 @@
+# 
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# A command node.
+# Represents a command in the command tree.
+#
+class CommandNode
+
+  attr_reader :name, :description, :method, :obj
+
+  def initialize( name, description: "", method: nil, obj: nil, &children_block )
+    @name = name
+    @description = description
+    @method = method
+    @obj = obj
+    @children_block = children_block
+  end
+
+  def children( context )
+    return [] unless @children_block
+    @children_block.call( context )
+  end
+end

data/lib/gloo-cli.rb

@@ -9,6 +9,11 @@ require 'menu'
 require 'menu_item'
 require 'prompt'
 require 'select'
+require 'shell'
+require 'shell_runner'
+require 'shell_context'
+require 'command_node'
+require 'command'
 
 # 
 # Registers the extension.
@@ -25,6 +30,8 @@ class CliInit < Gloo::Plugin::Base
       callback.register_obj( MenuItem )
       callback.register_obj( Prompt )
       callback.register_obj( Select )
+      callback.register_obj( Shell )
+      callback.register_obj( Command )
     end
 
 end

data/lib/shell.rb

@@ -0,0 +1,192 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# A CLI shell.
+#
+
+class Shell < Gloo::Core::Obj
+
+  KEYWORD = 'shell'.freeze
+  KEYWORD_SHORT = 'shell'.freeze
+  PROMPT = 'prompt'.freeze
+  DEFAULT_ACTION = 'default_action'.freeze
+  INCLUDE_QUIT = 'include_quit'.freeze
+
+  #
+  # The name of the object type.
+  #
+  def self.typename
+    return KEYWORD
+  end
+
+  #
+  # The short name of the object type.
+  #
+  def self.short_typename
+    return KEYWORD_SHORT
+  end
+
+  #
+  # Get the value of the prompt child object.
+  # Returns nil if there is none.
+  #
+  def prompt
+    o = find_child PROMPT
+    return '' unless o
+
+    return o.value
+  end
+
+  # 
+  # Get the value of the include_quit child object.
+  # Returns false if there is none.
+  #
+  def include_quit?
+    o = find_child INCLUDE_QUIT
+    return o.value if o
+    return false
+  end
+  
+  
+  # ---------------------------------------------------------------------
+  #    Children
+  # ---------------------------------------------------------------------
+
+  #
+  # Does this object have children to add when an object
+  # is created in interactive mode?
+  # This does not apply during obj load, etc.
+  #
+  def add_children_on_create?
+    return true
+  end
+
+  #
+  # Add children to this object.
+  # This is used by containers to add children needed
+  # for default configurations.
+  #
+  def add_default_children
+    fac = @engine.factory
+    fac.create_string PROMPT, '> ', self
+    fac.create_script DEFAULT_ACTION, '', self
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Messages
+  # ---------------------------------------------------------------------
+
+  #
+  # Get a list of message names that this object receives.
+  #
+  def self.messages
+    return super + [ 'start', 'stop' ]
+  end
+
+  # 
+  # Get the shell runner or initialize it if it doesn't exist.
+  #
+  def get_runner
+    return @runner ||= ShellRunner.new( @engine, self )
+  end
+  
+  #
+  # Start the shell.
+  #
+  def msg_start
+    runner = get_runner
+
+    # add_test_commands
+    add_quit_command
+
+    runner.start
+  end
+
+  #
+  # Stop the shell.
+  #
+  def msg_stop
+    @runner.stop if @runner
+  end
+
+  #
+  # Add a command to the shell.
+  #
+  def add_command obj, command_data
+    runner = get_runner
+    runner.add_command_node( command_data )
+  end
+
+  
+  # ---------------------------------------------------------------------
+  #    Context
+  # ---------------------------------------------------------------------
+
+  def set_context key, value
+    @runner.set_context( key, value )
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Commands
+  # ---------------------------------------------------------------------
+
+  #
+  # Quit the shell.
+  #
+  def add_quit_command
+    return unless include_quit?
+    
+    @runner.add_command_node({
+      name: "quit",
+      description: "Quit the application", 
+      method: "cmd_quit"
+    })
+  end
+
+  # def add_test_commands
+  #   @runner.add_command_node({
+  #     name: "add",
+  #     description: "add a project",
+  #     method: "cmd_add"
+  #   })
+
+  #   @runner.add_command_node({
+  #     name: "show",
+  #     description: "show a resource",
+  #     children: [
+  #       {
+  #         name: "project",
+  #         description: "show a project",
+  #         dynamic: true,
+  #         source: "projects"
+  #       },
+  #       {
+  #         name: "task",
+  #         description: "show a task",
+  #         dynamic: true,
+  #         source: "tasks"
+  #       }
+  #     ]
+  #   })
+
+  #   @runner.add_command_node({
+  #     name: "list",
+  #     description: "list resources",
+  #     children: [
+  #       {
+  #         name: "projects",
+  #         description: "list projects",
+  #         method: "cmd_projects"
+  #       },
+  #       {
+  #         name: "tasks",
+  #         description: "list tasks",
+  #         method: "cmd_tasks"
+  #       }
+  #     ]
+  #   })
+  # end
+
+end

data/lib/shell_context.rb

@@ -0,0 +1,108 @@
+# 
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# A shell context.
+# Data associated with the shell session.
+#
+class ShellContext
+
+  attr_accessor :done
+
+  # 
+  # Initialize the shell context
+  # 
+  def initialize
+    @done = false
+    @properties = {}
+  end
+
+  # 
+  # Get a property value
+  # 
+  # @param key [Symbol] The property key
+  # @return [Object] The property value
+  # 
+  def get( key )
+    key = key.to_sym
+    return @properties[key] if @properties.key?(key)
+    
+    # If the property doesn't exist, return an empty array
+    return []
+  end
+
+  # 
+  # Set a property value
+  # 
+  # @param key [Symbol] The property key
+  # @param value [Object] The property value
+  # 
+  def set( key, value )
+    @properties[key.to_sym] = value
+  end
+
+  # 
+  # Add an item to a property list
+  # 
+  # @param key [Symbol] The property key
+  # @param item [Object] The item to add
+  # 
+  def add_to_list( key, item )
+    key = key.to_sym
+    list = get(key)
+    
+    # Ensure we have an array to work with
+    list = [] unless list.is_a?(Array)
+    
+    # Add the item and store the updated list
+    list << item
+    set(key, list)
+    
+    list
+  end
+
+  # 
+  # Check if a property exists
+  # 
+  # @param key [Symbol] The property key
+  # @return [Boolean] True if property exists
+  # 
+  def has?( key )
+    @properties.key?( key.to_sym )
+  end
+
+  # 
+  # Get all property keys
+  # 
+  # @return [Array<Symbol>] All property keys
+  # 
+  def keys
+    @properties.keys
+  end
+
+  # 
+  # Dynamic method access to properties
+  # 
+  def method_missing( method_name, *args, &block )
+    if method_name.to_s.end_with?('=')
+      # Setter method: projects=, tasks=, etc.
+      key = method_name.to_s.chomp('=').to_sym
+      set(key, args.first)
+    else
+      # Getter method: projects, tasks, etc.
+      key = method_name.to_sym
+      get(key)
+    end
+  end
+
+  # 
+  # Respond to missing methods for property access
+  # 
+  def respond_to_missing?( method_name, include_private = false )
+    key = method_name.to_s.chomp('=').to_sym
+    has?(key) || super
+  end
+
+  private
+
+end

data/lib/shell_runner.rb

@@ -0,0 +1,243 @@
+# 
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# A shell runner.
+#
+require "readline"
+
+class ShellRunner
+
+  DEFAULT_PROMPT = " -> "
+  # 
+  # Initialize the shell runner
+  # 
+  # @param obj [Object] The shell obj.
+  # 
+  def initialize( engine, obj )
+    @engine = engine
+    @obj = obj
+    @context = ShellContext.new
+    @root = CommandNode.new( nil )
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Shell, control, start and stop
+  # ---------------------------------------------------------------------
+  
+  # 
+  # Start the shell.
+  # 
+  def start
+    repl
+  end
+
+  # 
+  # Flag the shell as done, next time through the loop it will stop
+  # 
+  def stop
+    @context.done = true
+  end
+  
+  # 
+  # Get the prompt string
+  # 
+  def prompt
+    p = @obj.prompt 
+    return p ? p + ' ' : DEFAULT_PROMPT
+  end
+
+  # 
+  # Quit the shell.
+  # 
+  def cmd_quit( obj, context )
+    puts "Quitting…"
+    context.done = true
+  end
+
+  # 
+  # Run an action on an object.
+  # 
+  def cmd_obj_action( obj, context )
+    pn = Gloo::Core::Pn.new( @engine, obj )
+    command = pn.resolve
+    if command
+      command.run_action
+    end
+  end
+
+  def cmd_obj_action_with_context( cmd_node, parent_node = nil )    
+    if parent_node
+      pn = Gloo::Core::Pn.new( @engine, parent_node.obj )
+      command = pn.resolve
+      if command
+        command.run_action_with_context( cmd_node.name )
+      end
+    end
+
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Context
+  # ---------------------------------------------------------------------
+
+  # 
+  # Set a context list.
+  # 
+  def set_context key, value_list
+    @context.set( key, value_list )
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    Tree building
+  # ---------------------------------------------------------------------
+
+  # 
+  # Execute a command.
+  # 
+  def execute_command( command_node, args, parent_node = nil )
+    if command_node.respond_to?( :method ) && command_node.method
+      send( command_node.method, command_node.obj, @context )
+    else
+      if command_node.name && command_node.name != "" && !command_node.description.empty?
+        puts "#{command_node.description}: #{command_node.name}"
+      elsif command_node.name
+        # puts "Showing: #{command_node.name}"
+        cmd_obj_action_with_context( command_node, parent_node )
+      end
+    end
+  end
+
+
+  # 
+  # Build a command node from data.
+  # 
+  def build_node_from_data( data )
+    if data[:dynamic]
+      CommandNode.new(data[:name], description: data[:description], obj: data[:obj]) do |ctx|
+        ctx.send(data[:source]).map do |item|
+          CommandNode.new(item)
+        end
+      end
+    elsif data[:children]
+      CommandNode.new(data[:name], description: data[:description], method: data[:method], obj: data[:obj]) do |ctx|
+        data[:children].map { |child_data| build_node_from_data(child_data) }
+      end
+    else
+      CommandNode.new(data[:name], description: data[:description], method: data[:method], obj: data[:obj])
+    end
+  end
+
+  # 
+  # Add a command node to the root dynamically
+  # 
+  # @param command_data [Hash] The command data hash
+  # 
+  # Add a single command dynamically
+  # 
+  def add_command_node( command_data)
+    node = build_node_from_data(command_data)
+    
+    # Get existing children block or create new one
+    existing_block = @root.instance_variable_get(:@children_block)
+    
+    if existing_block
+      # Store existing nodes and add new one
+      existing_nodes = existing_block.call(@context)
+      all_nodes = existing_nodes + [node]
+      @root.instance_variable_set(:@children_block, proc { |ctx| all_nodes })
+    else
+      # Create new children block with just this node
+      @root.instance_variable_set(:@children_block, proc { |ctx| [node] })
+    end
+    
+    node
+  end
+
+
+  # ---------------------------------------------------------------------
+  #    REPL
+  # ---------------------------------------------------------------------
+
+  # 
+  # Traverse the command tree to find the matching node
+  # 
+  # @param node [CommandNode] The current node
+  # @param tokens [Array<String>] The tokens to traverse
+  # 
+  # @return [Hash] Hash with :node and :parent keys
+  # 
+  def traverse( node, tokens )
+    current = node
+    parent = nil
+
+    tokens.each do |token|
+      children = current.children( @context )
+      match = children.find { |c| c.name == token }
+      return { node: nil, parent: nil } unless match
+      
+      parent = current
+      current = match
+    end
+
+    { node: current, parent: parent }
+  end
+
+  # 
+  # Setup readline completion
+  # 
+  def setup_completion
+    Readline.completion_append_character = " "
+    Readline.basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("
+
+    Readline.completion_proc = proc do |input|
+      buffer = Readline.line_buffer
+      tokens = buffer.split(" ")
+
+      tokens << "" if buffer.end_with?(" ")
+
+      result = traverse( @root, tokens[0..-2] )
+      current = result[:node]
+      options = current.children( @context ).map( &:name )
+
+      matches = options.grep(/^#{Regexp.escape(input)}/)
+
+      if matches.length > 1
+        puts
+        current.children( @context ).each do |child|
+          if matches.include?( child.name )
+            puts "#{child.name.ljust(15)} #{child.description}"
+          end
+        end
+        print "#{prompt}#{buffer}"
+      end
+
+      matches
+    end
+  end
+
+
+  # 
+  # Run the REPL loop.
+  # 
+  def repl
+    setup_completion
+
+    while ( ! @context.done && (line = Readline.readline(prompt, true)) )
+      tokens = line.strip.split(" ")
+      next if tokens.empty?
+
+      result = traverse( @root, tokens )
+
+      if result[:node]
+        execute_command( result[:node], tokens, result[:parent] )
+      else
+        puts "Unknown command"
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gloo-cli
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: '1.2'
 platform: ruby
 authors:
 - Eric Crane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-22 00:00:00.000000000 Z
+date: 2026-04-12 00:00:00.000000000 Z
 dependencies: []
 description: Adds CLI support to Gloo.
 email:
@@ -19,11 +19,16 @@ extra_rdoc_files: []
 files:
 - lib/cli_colorize.rb
 - lib/cli_confirm.rb
+- lib/command.rb
+- lib/command_node.rb
 - lib/gloo-cli.rb
 - lib/menu.rb
 - lib/menu_item.rb
 - lib/prompt.rb
 - lib/select.rb
+- lib/shell.rb
+- lib/shell_context.rb
+- lib/shell_runner.rb
 homepage: https://gloo.ecrane.us/
 licenses:
 - MIT