Renamed node classes

This scheme makes things less ambiguous.

Author: promovicz

command-interface/bash.dylan

@@ -5,7 +5,7 @@ copyright: see accompanying file LICENSE
 
 /* Add hidden command for bash completion to given root
  */
-define method root-add-bash-completion (root :: <command-root>)
+define method root-add-bash-completion (root :: <root-node>)
  => ();
   let command = build-command
     (root, "bashcomplete",

command-interface/building.dylan

@@ -3,19 +3,19 @@ synopsis: Utilities for constructing CLI node structures.
 author: Ingo Albrecht <prom@berlin.ccc.de>
 copyright: see accompanying file LICENSE
 
-define method build-command (root :: <command-root>, name :: <sequence>,
+define method build-command (root :: <root-node>, name :: <sequence>,
                              #rest node-keys,
-                             #key node-class :: <class> = <command-command>, #all-keys)
- => (cmd :: <command-symbol>);
+                             #key node-class :: <class> = <command-node>, #all-keys)
+ => (cmd :: <symbol-node>);
   local
-    method find-or-make-successor (node :: <command-node>,
+    method find-or-make-successor (node :: <parse-node>,
                                    symbol :: <symbol>,
                                    node-class :: <class>,
                                    node-keys :: <sequence>)
       // find symbol in existing successors
       let found = #f;
       for (s in node-successors(node), until: found)
-        if (instance?(s, <command-symbol>) & (node-symbol(s) == symbol))
+        if (instance?(s, <symbol-node>) & (node-symbol(s) == symbol))
           found := s;
         end if;
       end for;
@@ -35,7 +35,7 @@ define method build-command (root :: <command-root>, name :: <sequence>,
       if (i == size(name) - 1)
         values(node-class, node-keys);
       else
-        values(<command-symbol>, #[]);
+        values(<symbol-node>, #[]);
       end;
     // find or make the node
     cur := find-or-make-successor
@@ -45,24 +45,24 @@ define method build-command (root :: <command-root>, name :: <sequence>,
   cur;
 end method;
 
-define method build-command (root :: <command-root>, name :: <string>,
+define method build-command (root :: <root-node>, name :: <string>,
                              #rest keys, #key, #all-keys)
- => (cmd :: <command-symbol>);
+ => (cmd :: <command-node>);
   apply(build-command, root, list(name), keys);
 end method;
 
-define method build-command (root :: <command-root>, name :: <symbol>,
+define method build-command (root :: <root-node>, name :: <symbol>,
                              #rest keys, #key, #all-keys)
- => (cmd :: <command-symbol>);
+ => (cmd :: <command-node>);
   apply(build-command, root, list(name), keys);
 end method;
 
 
-define function build-parameter (command :: <command-command>, name :: <symbol>,
+define function build-parameter (command :: <command-node>, name :: <symbol>,
                                  #rest keys,
                                  #key syntax :: <symbol> = #"named",
                                  #all-keys)
- => (entry :: <command-node>);
+ => (entry :: <parse-node>);
   select (syntax)
     #"flag" => apply(build-flag-parameter, command, name, keys);
     #"named" => apply(build-named-parameter, command, name, keys);
@@ -71,8 +71,9 @@ define function build-parameter (command :: <command-command>, name :: <symbol>,
   end;
 end;
 
-define function build-flag-parameter (command :: <command-command>, name :: <symbol>,
-                                      #rest keys, #key node-class :: <class> = <command-flag>, #all-keys)
+define function build-flag-parameter (command :: <command-node>, name :: <symbol>,
+                                      #rest keys, #key node-class :: <class> = <flag-node>, #all-keys)
+  => (param :: <flag-node>);
   let param = apply(make, node-class,
                     name:, name,
                     symbol:, name,
@@ -85,9 +86,9 @@ define function build-flag-parameter (command :: <command-command>, name :: <sym
   param;
 end function;
 
-define function build-simple-parameter (command :: <command-command>, name :: <symbol>,
-                                        #rest keys, #key node-class :: <class> = <command-string>, #all-keys)
- => (entry :: <command-node>);
+define function build-simple-parameter (command :: <command-node>, name :: <symbol>,
+                                        #rest keys, #key node-class :: <class> = <string-parameter-node>, #all-keys)
+ => (entry :: <parse-node>);
   let param = apply(make, node-class,
                     name:, name,
                     kind:, #"simple",
@@ -99,9 +100,9 @@ define function build-simple-parameter (command :: <command-command>, name :: <s
   param;
 end function;
 
-define method build-named-parameter (command :: <command-command>, names :: <sequence>,
-                                     #rest keys, #key node-class :: <class> = <command-string>, #all-keys)
- => (param :: <command-node>, symbols :: <sequence>);
+define method build-named-parameter (command :: <command-node>, names :: <sequence>,
+                                     #rest keys, #key node-class :: <class> = <string-parameter-node>, #all-keys)
+ => (param :: <parameter-node>, symbols :: <sequence>);
   let param = apply(make, node-class,
                     name:, element(names, 0),
                     kind:, #"named",
@@ -110,7 +111,7 @@ define method build-named-parameter (command :: <command-command>, names :: <seq
                     keys);
   let syms = #();
   for (name in names)
-    let sym = make(<command-symbol>,
+    let sym = make(<symbol-node>,
                    symbol: as(<symbol>, name),
                    repeatable?: node-repeatable?(param),
                    repeat-marker: param,
@@ -122,8 +123,8 @@ define method build-named-parameter (command :: <command-command>, names :: <seq
   values(param, syms);
 end method;
 
-define method build-named-parameter (command :: <command-command>, name :: <symbol>,
+define method build-named-parameter (command :: <command-node>, name :: <symbol>,
                                      #rest keys, #key, #all-keys)
- => (param :: <command-parameter>, symbols :: <sequence>);
+ => (param :: <parameter-node>, symbols :: <sequence>);
   apply(build-named-parameter, command, list(name), keys);
 end method;

command-interface/command-interface-library.dylan

@@ -80,7 +80,7 @@ define module command-interface
     <command-unknown-error>;
 
   export
-    <command-node>,
+    <parse-node>,
     // getters and setters
     node-hidden?,
     node-repeatable?,
@@ -91,16 +91,16 @@ define module command-interface
     node-complete,
     node-match,
     // subclasses
-    <command-root>,
-    <command-symbol>,
-    <command-command>,
-    <command-wrapper>,
-    <command-parameter>,
-    <command-string>,
-    <command-oneof>,
+    <root-node>,
+    <symbol-node>,
+    <command-node>,
+    <wrapper-node>,
+    <parameter-node>,
+    <string-parameter-node>,
+    <oneof-node>,
     parameter-name,
     parameter-required?,
-    <command-file>;
+    <file-node>;
 
   export
     <tty-command-shell>,

command-interface/completion.dylan

@@ -9,7 +9,7 @@ copyright: see accompanying file LICENSE
  */
 define class <command-completion> (<object>)
   /* node the completion was performed for */
-  constant slot completion-node :: <command-node>,
+  constant slot completion-node :: <parse-node>,
     required-init-keyword: node:;
   /* token used to hint the completion, if provided */
   constant slot completion-token :: false-or(<command-token>) = #f,
@@ -56,7 +56,7 @@ end class;
 /**
  * Construct a completion result
  */
-define function make-completion (node :: <command-node>,
+define function make-completion (node :: <parse-node>,
                                  token :: false-or(<command-token>),
                                  #key exhaustive? :: <boolean> = #f,
                                       complete-options :: <sequence> = #(),

command-interface/help.dylan

@@ -3,10 +3,10 @@ synopsis: Reusable help command.
 author: Ingo Albrecht <prom@berlin.ccc.de>
 copyright: see accompanying file LICENSE
 
-define method root-add-help (root :: <command-root>)
+define method root-add-help (root :: <root-node>)
  => ();
   build-command(root, "help",
-                node-class: <command-wrapper>,
+                node-class: <wrapper-node>,
                 root: root,
                 handler: help-handler);
 end method;
@@ -26,20 +26,18 @@ end method;
 
 define method show-command-help (nodes :: <sequence>, tokens :: <sequence>)
   => ();
-  let cmd :: false-or(<command-command>) = #f;
+  let cmd :: false-or(<command-node>) = #f;
   let cmd-title :: <list> = #();
   let cmd-help :: false-or(<string>) = #f;
 
   for (token in tokens, node in nodes)
-    if (instance?(node, <command-symbol>))
+    if (instance?(node, <command-node>))
       if (~cmd)
+        cmd := node;
         cmd-title := add(cmd-title, as(<string>, node-symbol(node)));
-      end if;
-    end if;
-    if (instance?(node, <command-command>))
-      cmd := node;
-      if (command-help(node))
-        cmd-help := command-help(node);
+        if (command-help(node))
+          cmd-help := command-help(node);
+        end if;
       end if;
     end if;
   end for;

command-interface/macros.dylan

@@ -5,7 +5,7 @@ copyright: see accompanying file LICENSE
 
 define macro command-root-definer
   { define command-root ?:name }
-    => { define constant ?name = make(<command-root>);
+    => { define constant ?name = make(<root-node>);
          begin
            root-add-bash-completion(?name);
            root-add-help(?name);
@@ -26,7 +26,7 @@ define macro command-aux-definer
       (?definitions) (?bindings) (?implementation) (?keywords) (?parameters)
     end }
     => { begin
-           let %root :: <command-root> = ?root;
+           let %root :: <root-node> = ?root;
            let %symbols :: <list> = #(?symbols);
            let %handler = method (%parser :: <command-parser>)
                            => ();

command-interface/main.dylan

@@ -3,7 +3,7 @@ synopsis: Convenience main functions.
 author: Ingo Albrecht <prom@berlin.ccc.de>
 copyright: see accompanying file LICENSE
 
-define function tty-command-shell-main (name :: <string>, arguments :: <vector>, tty :: <tty>, root :: <command-root>)
+define function tty-command-shell-main (name :: <string>, arguments :: <vector>, tty :: <tty>, root :: <root-node>)
   let source = make(<command-vector-source>, strings: arguments);
   let parser = make(<command-parser>, source: source, initial-node: root);