CliLua.lua

-- Copyright (c) 2026 MathV2023

--  Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:

--  The above copyright notice and this permission notice shall be included in
-- all copies or substantial portions of the Software.

--  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-- THE SOFTWARE.

local string = require("string")

local Cli = {
   name = "CliLua",
   description = "Nothing here.",
   error_header = "\x1b[31m CliLua:",
   default_command = "help"
}
Cli.__index = Cli
Cli.__NAME = "CliLua"
Cli.__VERSION = "1.0.0"


local split = function(str)
   local _table = {} 
   for part in string.gmatch(str, "%S+") do
      _table[#_table+1] = part
   end
   return _table
end

local print_error = function(msg)
   print(msg.."\x1b[0m")
end


function Cli:new(cli_name, description, error_header, default_command)
   local obj = setmetatable({}, self)

   obj.name = cli_name or self.name
   obj.description = description or self.description
   obj.error_header = error_header or ("\x1b[31m" .. obj.name .. ":")
   obj.commands = {}

   obj.default_command = (type(default_command) == "string") and default_command or "help"

   if default_command == "" then
      obj.default_command = "help"
   end
   
   obj:register_help()

   return obj
end

function Cli:new_command(command_name, parameters_str, description, callback)
   local parameters = {}

   if (type(callback) ~= "function") then
      print_error(self.error_header.." The 'callback' argument of 'Cli:new_command()' is not of type function.")
      return
   end
   
   if type(parameters_str) == "string" then
      for key, value in ipairs(split(parameters_str)) do
         local first_char = value:sub(1, 1)
         local last_char = value:sub(-1)
         local param_name = value:sub(2, -2)

         if (first_char == "[" and last_char == "]") then
            parameters[key] = {
               param_name,
               required = false
            }
         elseif (first_char == "<" and last_char == ">") then
            parameters[key] = {
               param_name,
               required = true
            }
         else
            print_error(self.error_header.."Parameter '"..value.."' must be wrapped in '[]' (optional) or '<>' (required).")
            return
         end
      end
   end

   self.commands[command_name] = {
      description = description,
      parameters = parameters,
      body = callback
   }
end

function Cli:register_help()
   self:new_command("help", "[command]", "Assistance in finding information on how commands work.", function(args, instance)
      if instance.commands[args.command] then
         print(instance.name)
         print("\t"..args.command.." -> "..instance.commands[args.command].description)
      else
         print(instance.name.."\n\t"..instance.description)
         for key, values in pairs(instance.commands) do
            print("\t"..key.." -> "..values.description)
         end
      end
   end)
end

function Cli:run(arg_list)
   local command_name = arg_list[1] or ""
   local parsed_params = {}
   
   if self.commands[command_name] then
      local commands = self.commands[command_name]

      if commands.parameters then
         for i=1, #commands.parameters do
            local value = arg_list[i+1]

            if (commands.parameters[i].required and value == nil) then
               print_error(self.error_header.." The parameter <"..commands.parameters[i][1].."> is required.")
               return
            end

            parsed_params[commands.parameters[i][1]] = value or ""
         end

         commands.body(parsed_params, self)
      end
   elseif (command_name == "") then
      local command = self.commands[self.default_command]

      if command then
         command.body({""}, self)
      end

      return
   else
      print_error(self.error_header.." The command `"..command_name.."` does not exist in the program.")
      return
   end
end


return Cli