zabcon 0.0.6 → 0.0.327

data/libs/command_tree.rb

@@ -16,133 +16,441 @@
 #along with this program; if not, write to the Free Software
 #Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
+#--
 ##########################################
 # Subversion information
-# $Id: command_tree.rb 272 2011-01-06 21:04:22Z nelsonab $
-# $Revision: 272 $
+# $Id: command_tree.rb 325 2011-09-26 08:57:00Z nelsonab $
+# $Revision: 325 $
 ##########################################
+#++
 
-require 'libs/zdebug'
+require 'singleton'
+require 'libs/lexer'
+require 'zbxapi/zdebug'
 require 'libs/zabcon_exceptions'
+require 'libs/zabcon_globals'
+require 'libs/argument_processor'
 
-class Parser
+class ZabconExecuteBase
+  include ZDebug
+
+  attr_reader :results
+
+  def execute
+    raise "Unitialized base method"
+  end
+
+end
+
+class ZabconExecuteCommand < ZabconExecuteBase
+
+  class NilCommand < Exception
+  end
+
+  #TODO Calling/showing help needs to be streamlined and cleaned up better
+  class Help < Exception
+    attr_reader :obj
+    def initialize(obj)
+      @obj=obj
+    end
+
+    def show_help
+      @obj.help.call
+    end
+  end
+
+  attr_reader :show_params, :options, :help
+
+  #Configure the command item
+  #Also perform the necessary argument processing at this step.
+  def initialize(cmd_obj)
+    raise "cmd_obj must be fo type CommandList::Cmd" if cmd_obj.class!=CommandList::Cmd
+
+    @results=nil
+    @proc=cmd_obj.command_obj.method(:execute)
+    @command_obj=cmd_obj.command_obj
+    begin
+      arg_result=@command_obj.call_arg_processor(cmd_obj.parameters)
+    rescue ParameterError => e
+      e.help_func=cmd_obj.command_obj.help_method
+      raise e
+    end
+    @cmd_params=arg_result.cmd_params
+    @show_params=arg_result.show_params
+    @printing=cmd_obj.command_obj.print?
+    @command_name=cmd_obj.command_obj.command_name
+#    @help=cmd_obj.help
+#    @options=options
+
+  end
+
+  def print?
+    @printing==true
+  end
+
+  def execute
+
+    @results=@command_obj.execute(@cmd_params)
+
+  end
+end
+
+class ZabconExecuteVariable < ZabconExecuteBase
+  def initialize(var)
+    @var=var
+  end
+
+  def assign(val)
+    @results=val
+    GlobalVars.instance[@var]=val
+  end
+
+end
+
+class ZabconExecuteContainer
 
   include ZDebug
 
-  attr_reader :commands
+  attr_reader :show_params, :results, :options
+
+  def initialize(usr_str)
+    @initial_string=usr_str
+    @commands=[]
+    @printing=true
+    commandlist=CommandList.instance
+
+    tokens=Tokenizer.new(usr_str)
+
+    #split_str=usr_str.split2(:split_char=>'=|\s', :include_split=>true)
+    #
+    #unravel=false  #remove any extra space before the first =
+    #split_str2=split_str.map {|item|
+    #  if unravel
+    #    item
+    #  elsif item=="="
+    #    unravel=true
+    #    item
+    #  elsif item.empty?
+    #    nil
+    #  elsif item.scan(/\s/).empty?
+    #    item
+    #  else
+    #    nil
+    #  end
+    #}.delete_if {|i| i.nil?}
+    #
+    #if !split_str2[1].nil? && split_str2[1]=='='
+    #  split_str=split_str2  #use the trimmed version
+    #  var_name=split_str[0].strip
+    #  raise ParseError.new("Variable names cannot contain spaces or invalid characters \"#{var_name}\"",:retry=>true) if !var_name.scan(/[^\w]/).empty?
+    #
+    #  debug(5,:var=>var_name,:msg=>"Creating Variable assignment")
+    #  add(ZabconExecuteVariable.new(var_name))
+    #
+    #  usr_str=split_str[2..split_str.length-1].join.strip
+    #  debug(5,:var=>usr_str,:msg=>"Continuging to parse with")
+    #end
+    #
+    #debug(6,:var=>split_str,:msg=>"Split Str")
+    #debug(6,:var=>split_str2,:msg=>"Split Str2")
+    #debug(6,:var=>usr_str,:msg=>"User Str")
+    pos=tokens.walk(0)
+    if (positions=tokens.assignment?(pos,:return_pos=>true))
+      var_name = tokens[positions[0]].value
+      debug(5,:var=>var_name,:msg=>"Creating Variable assignment")
+      add(ZabconExecuteVariable.new(var_name))
+      tokens=tokens.drop(positions[2]+1)
+    end
+
+    cmd_str=tokens.map{|i| i.value}.join
+    debug(5,:msg=>"Command String",:var=>cmd_str)
+    cmd=commandlist.find_and_parse(cmd_str)
+    add(ZabconExecuteCommand.new(cmd))
 
-  def initialize(default_argument_processor)
-    @commands=NewCommandTree.new
-    @default_argument_processor=default_argument_processor
   end
 
-  def strip_comments(str)
-    str.lstrip!
-    str.chomp!
-    if str =~ /^ ## .*/ then
-      str = ""
-    elsif str =~ /(.+) ## .*/ then
-      str = Regexp.last_match(1)
-    else
-      str
+  def print?
+    @printing==true   #Ensure we get a boolean ;-)
+  end
+
+  def add(obj)
+    raise "Expected ZabconExecuteCommand Class" if
+        obj.class!=ZabconExecuteCommand &&
+        obj.class!=ZabconExecuteVariable
+    @commands<<obj
+    if obj.class==ZabconExecuteCommand
+      @printing=@printing & obj.print?
+      @show_params=obj.show_params
+      @options=obj.options
+    end
+
+  end
+
+  def execute
+    stack=[]
+    ptr=0
+    while ptr<@commands.length
+      case @commands[ptr].class.to_s
+        when "ZabconExecuteCommand"
+          @commands[ptr].execute
+          @results=@commands[ptr].results
+        when "ZabconExecuteVariable"
+          stack<<ptr
+      end
+      ptr+=1
+    end
+
+    while !stack.empty?
+      ptr=stack.pop
+      @commands[ptr].assign(@results)
     end
   end
 
-  def search(str)
-    debug(7,str,"Searching")
+end
+
+
+#Command is the main class used to define commands in Zabcon which are then
+#inserted into the global singleton class CommandList
+class Command
+  attr_reader :str, :aliases, :argument_processor, :flags
+  attr_reader :required_args, :valid_args
+  attr_reader :help_tag, :path
 
-    str=strip_comments(str)
+  include ArgumentProcessor
+
+  #Class containing processed arguments to be passed to the command
+  class Arguments
+    class ParameterError < Exception
+    end
 
+    attr_accessor :cmd_params
+    attr_reader :show_params
 
-#    cmd_node=@commands.search(nodes)  # a side effect of the function is that it also manipulates nodes
-     cmd_node=@commands.get_command(str)
-    debug(7,cmd_node,"search result")
-    return cmd_node[:command],cmd_node[:parameters]
+    def initialize(args, flags)
+      if args.class==String
+        @cmd_params=args
+        @show_params=nil
+      else
+        raise "Unknown Argument Object type: #{args.class}" if args.class!=Array && args.class!=Hash
+
+        @cmd_params=args
+        @show_params = {}
+        if args.class!=Array && (args["show"] || flags[:default_cols])
+          show=args["show"] || flags[:default_cols]
+          @show_params={:show=>show}
+          @cmd_params.delete("show") if args["show"]
+          @cmd_params.merge!({"extendoutput"=>true})
+        end
+      end
+    end
 
+    def show_params=(value)
+      raise ParameterError.new("Show argument must be of type Array") if !vaue.is_a?(Array)
+      @show_params=value
+    end
   end
 
+  class LoginRequired < Exception
+  end
 
-  # Returns nil if the command is incomplete or unknown
-  # If the command is known the associated argument processor is also called and it's results are returned as part
-  # of the return hash
-  # the return hash consists of:
-  # :proc - the name of the procedure which will execute the associated command
-  # :api_params - parameters to pass to the API call
-  # :show_params - parameters to pass to the print routines
-  # :helpproc - help procedure associated with the command
-  # The argument processor function is passed a string of the arguments after the command, along with the
-  # array of valid arguments and the help function associated with the command.
-  # If the argument processor has an error it should call the help function and return nil.  In which case this function
-  # will return nil
-  def parse(str,user_vars=nil)
-    debug(7,str,"Parsing")
-#    options=
-    debug(7,user_vars,"User Variables")
+  class ParameterError < Exception
+  end
 
-    result=@commands.get_command(str)
+  class ArgumentError < Exception
+  end
 
-    cmd=result[:command]
+  class LoopError < Exception
+  end
 
-    if cmd.nil? or cmd[:commandproc].nil? then
-      raise ParseError.new("Parse error, incomplete/unknown command: #{str}",:retry=>true)
+  def initialize(path)
+    raise "Path must be an array" if path.class!=Array
+    @path=path
+    @cmd_method=nil
+    @valid_args=[]
+    @aliases=[]
+    @flags={}
+    @result_type=nil
+
+    #TODO Can the argument processor stuff be cleaned up?
+    @argument_processor=method(:default_processor)
+    @help_tag=nil
+    @depreciated=nil
+  end
+
+  def command_name
+    @path.join(" ")
+  end
+
+  def print?
+    if @flags.nil?
+      false
     else
-      # The call here to the argument process requires one argument as it's a lambda block which is setup when the
-      # command node is created
-      debug(6,result[:parameters],"calling argument processor")
-      args=cmd[:argument_processor].call(result[:parameters],user_vars)
-      debug(6,args,"received from argument processor")
-      retval = args.nil? ? nil : {:proc=>cmd[:commandproc], :helpproc=>cmd[:helpproc], :options=>cmd[:options]}.merge(args)
-      return retval
+      @flags[:print_output]==true
     end
   end
 
-  def complete(str,loggedin=false)
-    nodes = str.split
-    cmd_node=@commands
-    i=0
-    while i<nodes.length
-      tmp=cmd_node.search(nodes[i])
-      break if tmp.nil?
-      cmd_node=tmp
-      i+=1
+  def set_method(&cmd_method)
+    @cmd_method=cmd_method
+  end
+
+  #Adds an alias name for the current command
+  def add_alias(name)
+    @aliases<<name.split2
+  end
+
+  #How many alias' are there?
+  def alias_total
+    @aliases.length
+  end
+
+  def generate_alias(index)
+    raise "Index out of bounds 0 >= i < N, i=#{index} N=#{alias_total}" if index<0 || index>=alias_total
+    new_alias=self.dup
+    new_alias.instance_variable_set("@path",@aliases[index])
+    new_alias.instance_variable_set("@aliases",[])
+    new_alias
+  end
+
+  #accepts an array of valid arguments
+  def set_valid_args(args)
+    @valid_args=args
+  end
+
+  def default_show(cols)
+    raise "Cols must be an array" if cols.class!=Array
+    @flags[:default_cols]=cols
+  end
+
+  def depreciated(str)
+    @depreciated=str
+  end
+
+  def arg_processor(&block)
+    @argument_processor=block
+  end
+
+  def set_arg_processor(method)
+    @argument_processor=method
+  end
+
+  def set_help_tag(sym)
+    @help_tag=sym
+  end
+
+  #--
+  #TODO Complete type casting section and add error checking
+  #++
+  #Valid flags:
+  # :login_required  - command requires a valid login
+  # :print_output  - the output of the command will be passed to the print processor
+  # :array_params  - Only process the parameters as an array
+  def set_flag(flag)
+    case flag.class.to_s
+      when "Symbol"
+        flag={flag=>true}
     end
 
-    if cmd_node.commandproc.nil? then
-      # roll up the list of available commands.
-      commands = cmd_node.children.collect {|node| node.command}
+    @flags.merge!(flag)
+  end
+
+  def call_arg_processor(parameters)
+    def set_show_args(args)
+      @arguments.show_params=args
+    end
 
-      # don't include the current node if the command is empty
-      if cmd_node.command!="" then commands += [cmd_node.command] end
-      return commands
+    @arguments=Arguments.new("",@flags)
+    result=@argument_processor.call(parameters,@valid_args,@flags)
+    return result if result.is_a?(Arguments)
+    if !result.is_a?(String) && !result.is_a?(Hash) && !result.is_a?(Array)
+      raise ("Arugment processor for \"#{command_name}\" returned invalid parameters: class: #{result.class}, #{result}")
     else
-      puts "complete"
-      return nil
+      @arguments.cmd_params=result
+      arguments=@arguments
+      return arguments
     end
   end
 
-  def insert(insert_path,commandproc,arguments=[],helpproc=nil,argument_processor=nil,*options)
-    debug(10,{"insert_path"=>insert_path, "commandproc"=>commandproc, "arguments"=> arguments, "helpproc"=>helpproc, "argument_processor"=>argument_processor, "options"=>options})
-#   insert_path_arr=[""]+insert_path.split   # we must pre-load our array with a blank node at the front
-#    p insert_path_arr
+  #Sets the symbold describing the result type.  May be used by the print processor
+  # as a hint for printing the output.
+  def result_type(type)
+    @result_type=type
+  end
+
+  def execute(parameters)
+    def set_result_message(msg)
+      @response.message=msg
+    end
+
+    def set_result_type(type)
+      @response.type=type
+    end
+
+#    def output(params)
+#      @response.data<<params
+#    end
+
+    raise LoopError.new("Loop detected, Command.execute called more than 3 times") if caller.grep(caller[0]).length>3
+    @response=Response.new
+    @response.type=@result_type if !@result_type.nil?
+
+    puts @depreciated if !@depreciated.nil?
+    if !@flags.nil? && @flags[:login_required] && !server.connected?
+      raise LoginRequired.new("\"#{@command_name}\" requires an active login")
+    end
+
+    @response.data=@cmd_method.call(parameters)
+
+    retval=@response  #ensure @result is empty for our next use
+    @response=nil
 
-    # If the parameter "argument_processor" is nil use the default argument processor
-    arg_processor = argument_processor.nil? ? @default_argument_processor : argument_processor
-    @commands.insert(insert_path,commandproc,arguments,helpproc,arg_processor,options)
+    retval
   end
 
-end
+  private
 
-#{"add"=>{:node=>proc, "host"=>{:node=>proc,"group"=>{:node=>proc}}},"delete"=>...}
+  def parameter_error(msg)
+    raise ParameterError.new(msg)
+  end
 
-class NewCommandTree
+  def server
+    ZabbixServer.instance
+  end
+
+  def global_vars
+    GlobalVars.instance
+  end
+end
+
+class CommandList
   include ZDebug
+  include Singleton
+
+   class InvalidCommand < Exception
+    def initialize(str)
+      @str=str
+    end
+
+    def message
+      "Unknown or Invalid Command: #{@str}"
+    end
+  end
+
+  class Cmd
+    attr_reader :command_obj, :parameters
+
+    def initialize(command_obj,parameters)
+      @command_obj=command_obj
+      @parameters=parameters
+    end
+  end  #End Cmd sub class
 
   def initialize
-    @tree = {}
+    @cmd_tree={}
   end
 
-  def insert(insert_path,commandproc,arguments,helpproc,argument_processor,options)
-    tree_node=@tree
+  def insert(insert_path, cmd_obj)
+    raise "Insert_path must be an array" if insert_path.class!=Array
+    tree_node=@cmd_tree
     path_length=insert_path.length-1
     insert_path.each_index do |index|
       if tree_node[insert_path[index]].nil?
@@ -150,241 +458,133 @@ class NewCommandTree
           tree_node[insert_path[index]]={}
           tree_node=tree_node[insert_path[index]]
         else
-          local_arg_processor=lambda do |params,user_vars|
-  	        if argument_processor.nil?
-	            nil
-	          else
-	            argument_processor.call(helpproc,arguments,params,user_vars,options)  # We pass the list of valid arguments to
-	         end
-          end
-          if options.nil?
-  	        local_options=nil
-	        else
-	          local_options = Hash[*options.collect { |v|
-	            [v, true]
-	          }.flatten]
-	        end
-          tree_node[insert_path[index]]={:node=>
-            {:commandproc=>commandproc, :arguments=>arguments, :helpproc=>helpproc,
-             :argument_processor=>local_arg_processor,:options=>local_options}}
+          tree_node[insert_path[index]]={:node=>cmd_obj}
         end
       else
         tree_node=tree_node[insert_path[index]]
       end
     end
+
+    (0..(cmd_obj.alias_total-1)).each {|i|
+      insert(cmd_obj.aliases[i],cmd_obj.generate_alias(i))} if cmd_obj.alias_total>0
   end
 
-  #get_command(String)
-  #returns a Hash with two items: :command and :parameters
-  #:command is a hash denoting all of the components of a the command when it was inserted
-  #:parameters is the remainder of the String passed in.
-  #
-  #example:
-  #  get_command("get host show=all")
-  #  {:command=>{hash created from insert}, :parameters=>"show=all"}
-  #
-  #  get_command("get host test           test2")
-  #  {:command=>{hash created from insert}, :parameters=>"test           test2"
-    def get_command(str)
-    str_array=str.downcase.split  #ensure all comparisons are done in lower case
-    str_items=str_array.length
-
-    cur_node=@tree
+  def get(path)
+    path=setup_path(path)
+
+    cur_node=@cmd_tree
     count=0
 
-    str_array.collect do |item|
+    path.collect do |item|
       break if cur_node[item].nil?
       count+=1
 
       cur_node=cur_node[item]
     end
 
-    cmd= cur_node.nil? ? nil : cur_node[:node]
-
-    #remove preceding items found so we can return the remainder
-    #as the parameters
-    count.times do |i|
-      str=str.gsub(/^#{str_array[i]}/,"")
-      str=str.gsub(/^\s*/,"")
-    end
-
-    {:command=>cmd,:parameters=>str}
+    cmd=cur_node.nil? ? nil : cur_node[:node]
   end
 
-end
-  def search(search_path)
-      debug(10,search_path,"search_path")
-    return retval if results.empty?  # no more children to search, return retval which may be self or nil, see logic above
-        debug(10)
+  def find_and_parse(str)
 
-        return results[0].search(search_path)
-        debug(10,"Not digging deeper")
+    tokens=Tokenizer.new(str)
+    token_items=tokens.length
 
-        return self if search_path[0]==@command
+    cur_node=@cmd_tree
+    pos=tokens.walk(0)
 
-      end
-
-  def insert(insert_path,command,commandproc,arguments,helpproc,argument_processor,options)
-      do_insert(insert_path,command,commandproc,arguments,helpproc,argument_processor,options,0)
-      end
-
-  # Insert path is the path to insert the item into the tree
-  # Insert path is passed in as an array of names which associate with pre-existing nodes
-  # The function will recursively insert the command and will remove the top of the input path stack at each level until it
-  # finds the appropraite level.  If the appropriate level is never found an exception is raised.
-  def do_insert(insert_path,command,commandproc,arguments,helpproc,argument_processor,options,depth)
-      debug(11,{"insert_path"=>insert_path, "command"=>command, "commandproc"=>commandproc, "arguments"=> arguments,
-                  "helpproc"=>helpproc, "verify_func"=>argument_processor, "depth"=>depth})
-        debug(11,@command,"self.command")
-#    debug(11,@children.map {|child| child.command},"children")
-
-      if insert_path[0]==@command then
-          debug(11,"Found node")
-            if insert_path.length==1 then
-                debug(11,command,"inserting")
-                  @children << CommandTree.new(command,commandproc,depth+1,arguments,helpproc,argument_processor,options)
-                else
-                    debug(11,"Not found walking tree")
-                      insert_path.shift
-                      if !@children.empty? then
-                          @children.each { |node| node.do_insert(insert_path,command,commandproc,arguments,helpproc,argument_processor,options,depth+1)}
-                          else
-                              raise(Command_Tree_Exception,"Unable to find insert point in Command Tree")
-                              end
-                    end
-          end
-  end
-
-=begin
-class CommandTree
-
-  include ZDebug
-
-  attr_reader :command, :commandproc, :children, :arguments, :helpproc, :depth, :argument_processor, :options
-
-  # Arguments hash takes the form of {"name"=>{:type=>Class, :optional=>true/false}}
-  # If type is nil then the argument takes no options
-  def initialize(command,commandproc,depth,arguments,helpproc,argument_processor,options)
-    debug(10,{"command"=>command, "commandproc"=>commandproc, "arguments"=> arguments,"helpproc"=>helpproc,
-              "verify_func"=>argument_processor, "depth"=>depth, "options"=>options})
-    @command=command
-    @commandproc=commandproc
-    @children=[]
-    @arguments=arguments
-    @helpproc=helpproc
-    @depth=depth
-    # verify functions are special.
-    # We pass them the list of valid arguments first and then the parameters which need to be verified
-    # This will allow for either unique or generalized verification functions
-    # The verify function can safely be called with objects with no verify function as nil checking is performed in the
-    # lambda
-    # If no verify function was setup we return true
-    @argument_processor=lambda do |params,user_vars|
-      if argument_processor.nil?
-        nil
-      else
-        argument_processor.call(@helpproc,@arguments,params,user_vars,options)  # We pass the list of valid arguments to
-      end
-    end
-    if options.nil?
-      @options=nil
-    else
-      @options = Hash[*options.collect { |v|
-        [v, true]
-      }.flatten]
+    while !tokens.end?(pos)
+      item=tokens[pos].value
+      break if cur_node[item].nil?
+      cur_node=cur_node[item]
+      pos=tokens.walk(pos+1)
     end
-    debug(10,self.inspect,"Initialization complete")
-  end
 
-  def inspect
-    r_str ="#<#{self.class.to_s}:0x#{self.object_id.to_s(16)} @command=#{@command.inspect}, @commandproc=#{@commandproc.inspect}, "
-    r_str+="@helpproc=#{@helpproc.inspect}, @argument_processor=#{@argument_processor.inspect}, @arguments=#{@arguments.inspect}, "
-    r_str+="@options=#{@options.inspect}, "
-    r_str+="@depth=#{@depth}, @children="
-    if @children.empty?
-      r_str+= "[]"
-    else
-      children=@children.map {|child| child.command }
-      r_str+= children.inspect
-    end
-    r_str+=">"
-    r_str
-  end
+    #tokens.each do |item|
+    #  if item.empty? || !item.scan(/^\s*$/).empty?
+    #    count+=1
+    #  else
+    #    break if cur_node[item].nil?
+    #    count+=1
+    #    cur_node=cur_node[item]
+    #  end
+    #end
 
-  # search will search check to see if the parameter command is found in the current node
-  # or the immediate children nodes.  It does not search the tree beyond one level.
-  # The loggedin argument is used to differentiate searching for commands which require a valid
-  # login or not.  If loggedin is false it will return commands which do not require a valid login.
-  debug(10,self,"self",300)
+    raise InvalidCommand.new(str) if cur_node.nil? || !cur_node[:node]
 
-  return nil if search_path.nil?
-  return nil if search_path.empty?
+    cmd=cur_node[:node]
+    #params=str_array[count..str_array.length].join.strip
 
-  retval=nil
+    debug(6,:msg=>"Tokens", :var=>tokens)
+    debug(6,:msg=>"Pos", :var=>pos)
+    debug(6,:msg=>"Parsed", :var=>tokens.parse)
+    params = tokens.drop(pos+1).join
 
-  retval=self if search_path[0]==@command
+    debug(6,:msg=>"Parameters", :var=>params)
 
+    Cmd.new(cmd,params)
+  end
 
-  search_path.shift
-  debug(10,search_path, "shifted search path")
+  def get_command_list(tree=nil)
+    def get_subtree(tree)
+      tmp=tree.dup
+      path=nil
+      if !tmp[:node].nil?
+        path=tree[:node].path.join(" ")
+        tmp.delete(:node)
+      end
+      tree=tmp
 
-  return retval if search_path.length==0
+      if tree.empty?
+        return path if !path.nil?
+        return nil
+      end
+      results=tree.keys.sort.map {|key|
+        get_subtree(tree[key])
+      }
+      [path,results]
+    end
 
-#    p search_path
-#    p @children.map {|child| child.command}
-  debug(10,@children.map{|child| child.command},"Current children")
+    get_subtree(@cmd_tree).flatten.compact.sort
+  end
 
-  results=@children.map {|child| child.command==search_path[0] ? child : nil }
-  results.compact!
-  debug(10,results,"Children search results",200)
+  private
 
+  def setup_path(path)
+    if path.class==Array
+      path
+    elsif path.class==String
+      path.split2
+    else
+      raise "Path must be Array or string"
+    end
+  end
 end
-=end
-
-
-if __FILE__ == $0
-
-  require 'pp'
-  require 'argument_processor'
 
-  arg_processor=ArgumentProcessor.new()
-  commands=Parser.new(arg_processoor.method(:default))
-  commands.set_debug_level(6)
-
-
-  def test_parse(cmd)
-    puts "\ntesting \"#{cmd}\""
-    retval=commands.parse(cmd)
-    puts "result:"
-    return retval
+#Base module for instantiating Zabcon commands.
+module ZabconCommand
+  #Method used to add commands to the Zabcon command processor
+  #path is the command path such as "get host group"
+  #A block must also be passed, this block will be executed against the
+  # Command object to to define the command and then inserted into the
+  # global CommandList singleton.
+  def self.add_command (path, &block)
+    path=
+        if path.class==Array
+          path
+        elsif path.class==String
+          path.split2(:trim_empty=>true)
+        else
+          raise "Path must be Array or string"
+        end
+    cmd=Command.new(path)
+    cmd.instance_eval(&block)
+    raise "Help tag required for \"#{path.join(" ")}\", and must be of type symbol.  Use the symbol :none for no help" if cmd.help_tag.class!=Symbol
+    CommandList.instance.insert(path,cmd)
   end
-  commands.set_debug_level(0)
-  commands.insert "", "help", lambda { puts "This  is a generic help stub" }
-  puts
-  commands.insert "", "get", nil
-  puts
-  commands.insert "get", "host", :gethost, {"show"=>{:type=>nil,:optional=>true}}
-  commands.set_debug_level(0)
-  puts
-  commands.insert "get", "user", :getuser
-  puts
-  commands.insert "get user", "group", :getusergroup
-  puts
-
-  pp commands
-
-  commands.set_debug_level(0)
-
-  test_parse("get user")
-  test_parse("get user show=all arg1 arg2")
-  test_parse("get user show=\"id, one, two, three\" arg1 arg2")
-  test_parse("get user group show=all arg1")
-  test_parse("set value")
-  test_parse("help")[:proc].call
 
+end
 
-  p commands.complete("hel")
-  p commands.complete("help")
-  p commands.complete("get user all")
+if __FILE__ == $0
 
 end