Merge lp:~aturriff/boots/boots-metacommands into lp:boots

[Andreas Turriff]

[Andreas Turriff (aturriff)]

This is the promised metacommand rewrite to use function references rather than strings. It also fixes a logic bug in console.disconnect() and adds a number of FIXMEs as well as two new metacommands to switch lingos and exit the console.

[Max Goodhart (chromakode)]

Merged, thanks. I made a couple code cleanups and tweaks. Check the diff.

review: Approve

[Andreas Turriff (aturriff)]

I think there's now a logic bug in the master list of metacommand names.
As discussed, the union of sets should be unconditional - there should
be a warning of set intersection, however.

~Andreas

On 2/6/2010 2:24 PM, Chromakode wrote:
> Review: Approve
> Merged, thanks. I made a couple code cleanups and tweaks. Check the diff.
>

[Max Goodhart (chromakode)]

Whoops-- good catch. Thanks for looking it over, Andreas.

=== modified file 'src/boots/lib/console.py'
--- src/boots/lib/console.py	2010-02-01 20:46:55 +0000
+++ src/boots/lib/console.py	2010-02-06 20:03:14 +0000
@@ -35,6 +35,7 @@
 from boots.lib.lingos.lisp import lisp
 from boots.lib.lingos import python
 from boots.lib.lingos import sql
+import sys
 
 # Utility function.
 def iterable(obj):
@@ -53,29 +54,55 @@
         self.servers = [api.Server(self.config["host"], self.config["port"],
                                  {"database": self.config["database"]})]
         self.ui = PlainUI(self.config["prompt"])
-        #Instead of an empty set, the set of console metacommands should be
-        #listed here. Also, the metacommand dictionary to be passed into
-        #self.metacommands needs to be set up somewhere.
-        self.metacommands=metacommands.MetaCommands({'\connect' : 'connect', '\disconnect' : 'disconnect'}, self)
+        metadict = {}
+        metadict['\connect'] = self.meta_connect
+        metadict['\disconnect'] = self.meta_disconnect
+        metadict['\lingo'] = self.meta_switchlingo
+        metadict['\quit'] = self.meta_quit
+        self.metacommands=metacommands.MetaCommands(metadict)
         self.metacommandset=set(self.metacommands.commands.keys())
-        #self.ui.metacommands needs to be replaced with a reference to self.ui's metacommand object. We need a definition
-        #for how these variables and methods are named.
         if not self.metacommandset.isdisjoint(set(self.ui.metacommands.commands.keys())):
             # FIXME: Issue warning through the UI using ui.print
-            print('warning, conflicts between metacommands detected')
+            # FIXME: Determine the offending command(s) (set.intersect?)
+            # FIXME: Print offending commands
+            print('warning, conflicts between metacommands detected.')
         self.metacommandset = self.metacommandset | set(self.ui.metacommands.commands.keys())
                 
     def run(self, command, lingo_name="sql"):
         return lingo.get(lingo_name).execute(command)
 
-    def connect(self, host = None, port = None, database = None):
-        if host == None: 
+    def meta_quit(self):
+        # Print a trailing newline.
+        self.ui.present('')
+        self.disconnect(None, None)
+
+        sys.exit(0)
+
+    #FIXME: Is there / can there be a list of available lingos?
+    #If so, we could implement dynaming registration of lingos through this
+    #interface: Register the lingo used in main(), and register lingos
+    #switched to here.
+    def meta_switchlingo(self, lingo = None):
+        if lingo is None:
+            return False
+
+        lingo = str(lingo)
+        self.switchlingo(lingo)
+
+    def switchlingo(self, lingo):
+        self.lingo = lingo
+
+    def meta_connect(self, host = None, port = None, database = None):
+        if host is None: 
             host = self.config["host"]
-        if port == None:
+        if port is None:
             port = self.config["port"]
-        if database == None:
+        if database is None:
             database = self.config["database"]
 
+        self.connect(host, port, database)
+
+    def connect(self, host, port, database):
         server = api.Server(host, port, {"database": database})
         server.connect()
         if server.is_connected:
@@ -85,13 +112,21 @@
             print("Could not connect to", host, port, database)
             return False
 
-    def disconnect(self, host = None, port = None):
+    def meta_disconnect(self, host = None, port = None):
+        if host is not None:
+            host=str(host)
+        if port is not None:
+            port=str(port)
+
+        self.disconnect(host,port)
+
+    def disconnect(self, host, port):
         found = False
         for server in self.servers:
             if not host or server.host == host and not port or server.port == port:
                 server.disconnect()
                 self.servers.remove(server)
-            found = True
+                found = True
         return found
 
     def main(self):
@@ -117,4 +152,4 @@
 
         # Print a trailing newline.
         self.ui.present('')
-        self.disconnect()
+        self.disconnect(None, None)

=== modified file 'src/boots/lib/metacommands/metacommands.py'
--- src/boots/lib/metacommands/metacommands.py	2010-02-01 20:32:54 +0000
+++ src/boots/lib/metacommands/metacommands.py	2010-02-06 20:03:14 +0000
@@ -29,21 +29,37 @@
 # ##### END LICENSE BLOCK #####
 
 def parse(commandstring):
+    """This function wraps str.split() for metacommands
+
+This function takes a string as argument and calls str.split() on that string
+to return a list of substrings, using whitespace as separator. The metacommand
+object uses this list to call a metacommand function and pass parameters.""" 
     return commandstring.split()
 
 class MetaCommands(object):
-    """Class used for handling metacommands."""
+    """Class used for handling metacommands.
+
+The MetaCommands class provides a mapping of command strings to function
+references. Its functions are the constructor, parse() (a function not bound
+to a MetaCommands object) and execute().
+
+The constructor accepts one parameter, a dictionary of string to function
+reference mappings. It stores this parameter in the member variable commands."""
     commands = {}
 
-    def __init__(self, commanddict, inparent):
-        """Constructor for class."""
+    def __init__(self, commanddict):
         self.commands = commanddict
-        self.parent = inparent
 
     def execute(self, commandlist):
-        """Parse and execute a metacommand string."""
+        """Parse and execute a metacommand string.
+
+The execute() function takes a list of strings, with the first being the name
+of the metacommand to be executed and the others being the required parameters.
+It performs a dictionary lookup on the name and calls the function it finds,
+or returns False if no function is found."""
         if len(commandlist) != 0 and commandlist[0] in self.commands:
-            getattr(self.parent, self.commands[commandlist[0]])(*commandlist[1:])
+            self.commands[commandlist[0]](*commandlist[1:])
+            #Do we need to pass metacommand return values back?
             return True
         else:
             return False

=== modified file 'src/boots/lib/ui/plain.py'
--- src/boots/lib/ui/plain.py	2010-02-02 02:48:04 +0000
+++ src/boots/lib/ui/plain.py	2010-02-06 20:03:14 +0000
@@ -35,7 +35,7 @@
 
 class PlainUI(StdinDriver, StdoutPresenter):
     def __init__(self, prompt):
-        self.metacommands = metacommands.MetaCommands({}, self)
+        self.metacommands = metacommands.MetaCommands({})
         self.prompt = prompt
         self.current_widths = None
         self.buffer = []