Breaks everything up into seperate files.

I had a problem where having Module in the local namespace was not the same as having Module in the non local namespace (via an import).  Somehow breaking it down this way seemed simpler.

1 files changed, 2 insertions, 211 deletions

diff --git a/devshell.py b/devshell.py
index 05bf215..786ec41 100755
--- a/devshell.py
+++ b/devshell.py
@@ -31,218 +31,9 @@
 # - audit <project> (flawfinder/rats/etc)
 
 import os
-import re
-import stat
-import gzip
-import email
-import urllib2
-import logging
-import commands
 
-from glob import glob
-from os.path import expanduser, exists, join, dirname, isdir
-from mailbox import UnixMailbox
-from datetime import datetime, timedelta
-
-__version__ = '0.0.1'
-__description__ = 'A shell for hacking on the Fedora project'
-
-FEDORA_DIR = join(expanduser('~'), 'code', 'fedora')
-DEVSHELL_DIR = join(expanduser('~'), '.devshell')
-
-stack = []
-prompt = ['\033[34;1mfedora\033[0m']
-modules = {}
-header = lambda x: "%s %s %s" % ('=' * 2, x, '=' * (76 - len(x)))
-log = logging.getLogger(__name__)
-
-class Module:
-    """ Our parent class for all command modules """
-    pass
-
-def load_modules():
-    global modules
-    from inspect import isclass
-    log.debug("Loading modules")
-    for f in os.listdir(os.path.abspath('modules')):
-        module_name, ext = os.path.splitext(f)
-        if ext == '.py':
-            exec "from modules import %s as module" % module_name
-            for item in dir(module):
-                obj = getattr(module, item)
-                if item[0] != '_' and isclass(obj):
-                    modules[item.lower()] = obj
-                    log.info(" * %s" % item)
-            del module
-
-def print_docstrings(module=None):
-    """
-    Print out the docstrings for all methods in the specified module.
-    If no module is specified, then display docstrings for all modules.
-    """
-    def _print_docstrings(name, module):
-        log.info(header(name))
-        for prop in filter(lambda x: x[0] != '_', dir(module)):
-            if callable(getattr(module, prop)) and hasattr(module, '__doc__') \
-               and getattr(module, prop).__doc__:
-                log.info("   |- [%s] %s" % (prop,
-                         getattr(module, prop).__doc__.strip()))
-    if not module:
-        for name, module in modules.items():
-            _print_docstrings(name, module)
-    else:
-        _print_docstrings(str(module.__class__).split('.')[-1], module)
-
-def shell():
-    global stack, prompt
-    while True:
-        try:
-            data = raw_input('/'.join(prompt) + '> ')
-        except (EOFError, KeyboardInterrupt):
-            print
-            break
-        if not data: continue
-        if data in ('quit', 'exit'): break
-        keyword = data.split()[0]
-        args = data.split()[1:]
-    
-        # Show the docstrings to all methods for all loaded modules
-        if keyword == 'help':
-            print_docstrings()
-    
-        # Go up a module in our stack
-        elif keyword in ('up', 'cd..', 'cd ..'):
-            stack = stack[:-1]
-            prompt = prompt[:-1]
-    
-        # Show the docstrings for all methods in our current module
-        elif keyword in ('ls', 'help', '?'):
-            if len(stack):
-                print_docstrings(stack[-1])
-            else:
-                print_docstrings()
-    
-        # Flush our module stack
-        elif keyword == 'cd':
-            stack = []
-            prompt = ['\033[34;1mfedora\033[0m']
-    
-        # iPython.  Never leave home without it.
-        elif keyword in ('py', 'python'):
-            os.system("ipython -noconfirm_exit")
-        else:
-            #figure out if there is a top
-            if len(stack):
-                top = stack[-1]
-            else:
-                top = None
-            output, top, params = do_command(data.split(), top)
-            stack += [top]
-            prompt += [top.__class__.__name__] + params
-
-class ModuleError(Exception):
-    def __init__(self, reason, error):
-        self.reason = reason
-        self.error = error
-
-def load_module(name, data=[]):
-#    stack = []
-#    prompt = []
-    top = None
-    try:
-        log.debug("Loading %s.__init__(%s)" % (name, data))
-        top = modules[name](*data)
-#        stack += [top]
-#        prompt += [name] + data
-    except TypeError, e:
-        log.debug('got type error')
-        log.error("%s: %s" % (name, e))
-        raise ModuleError('probably bad call to __init__' , e)
-    return top
-    
-
-def do_command(data, top=None):
-
-    # Do some intelligent handling of unknown input.
-    # For the given input 'foo bar', we first check if we have the
-    # module 'foo' loaded, then we push it on the top of our module
-    # stack and check if it has the 'bar' attribute.  If so, we call
-    # it with any remaining arguments
-    from collections import deque
-    data = deque(data)
-    log.debug(data)
-    params = []
-    
-    module = None
-    while len(data):
-        if not top:
-            log.debug('not top')
-            mod = data.popleft()
-            try:
-                module = modules[mod]
-            except KeyError, e:
-                log.error('%s is not a known module' % e.message)
-                return None, None, None
-            log.debug('mod is %s' % mod)
-            params = []
-            while len(data):
-                log.debug('params so far %s' % params)
-                log.debug('inner loop %s' % data)
-                param = data.popleft()
-                if hasattr(module, param):
-                    data.appendleft(param)
-                    break
-                params += [param]
-            try:
-                top = module = load_module(mod, params)
-                mod_params = params
-                loaded_module = True
-            except ModuleError, e:
-                log.debug(e.reason)
-                break
-        else:
-            log.debug('is top')
-            params = []
-            log.debug('params so far %s' % params)
-            param = data.popleft()
-            if hasattr(top, param):
-                log.debug("next property %s found in %s" % (param, top))
-                top = getattr(top, param)
-            else:
-                log.debug("adding argument: %s" % param)
-                params += [param]
-    output = None
-    if len(params):
-        output = top(*params)
-    
-    if module:
-        return output, module, mod_params
-    else:
-        return output, None, None
-
-def setup_options():
-    from optparse import OptionParser
-    parser = OptionParser(usage="%prog [options]",
-                          version="%s %s" % ('%prog', __version__),
-                          description=__description__)
-    parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
-                      help='Display verbose debugging output')
-    return parser.parse_args()
-
-def setup_logger(opts):
-    global log
-    # Setup our logger
-    sh = logging.StreamHandler()
-    if opts.verbose:
-        log.setLevel(logging.DEBUG)
-        sh.setLevel(logging.DEBUG)
-        format = logging.Formatter("[%(levelname)s] %(message)s")
-    else:
-        log.setLevel(logging.INFO)
-        sh.setLevel(logging.INFO)
-        format = logging.Formatter("%(message)s")
-    sh.setFormatter(format)
-    log.addHandler(sh)
+from base.base import load_modules, shell, setup_logger, setup_options, log
+from base.vars import FEDORA_DIR
 
 def main():
     (opts, args) = setup_options()