Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/python/zshcomp.py

Index: third_party/twisted_8_1/twisted/python/zshcomp.py
diff --git a/third_party/twisted_8_1/twisted/python/zshcomp.py b/third_party/twisted_8_1/twisted/python/zshcomp.py
deleted file mode 100644
index 4910cfd59f456e6ac1202443317c3d6c5a9eadcf..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/python/zshcomp.py
+++ /dev/null
@@ -1,780 +0,0 @@
-# -*- test-case-name: twisted.test.test_zshcomp -*-
-# Copyright (c) 2006 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-"""
-Rebuild the completion functions for the currently active version of Twisted::
-    $ python zshcomp.py -i
-
-This module implements a zsh code generator which generates completion code for
-commands that use twisted.python.usage. This is the stuff that makes pressing
-Tab at the command line work.
-
-Maintainer: Eric Mangold
-
-To build completion functions for your own commands, and not Twisted commands,
-then just do something like this::
-
-    o = mymodule.MyOptions()
-    f = file('_mycommand', 'w')
-    Builder("mycommand", o, f).write()
-
-Then all you have to do is place the generated file somewhere in your
-C{$fpath}, and restart zsh. Note the "site-functions" directory in your
-C{$fpath} where you may install 3rd-party completion functions (like the one
-you're building). Call C{siteFunctionsPath} to locate this directory
-programmatically.
-
-SPECIAL CLASS VARIABLES. You may set these on your usage.Options subclass::
-
-    zsh_altArgDescr
-    zsh_multiUse
-    zsh_mutuallyExclusive
-    zsh_actions
-    zsh_actionDescr
-    zsh_extras
-
-Here is what they mean (with examples)::
-
-    zsh_altArgDescr = {"foo":"use this description for foo instead"}
-        A dict mapping long option names to alternate descriptions.  When this
-        variable is present, the descriptions contained here will override
-        those descriptions provided in the optFlags and optParameters
-        variables.
-
-    zsh_multiUse = ["foo", "bar"]
-        A sequence containing those long option names which may appear on the
-        command line more than once. By default, options will only be completed
-        one time.
-
-    zsh_mutuallyExclusive = [("foo", "bar"), ("bar", "baz")]
-        A sequence of sequences, with each sub-sequence containing those long
-        option names that are mutually exclusive. That is, those options that
-        cannot appear on the command line together.
-
-    zsh_actions = {"foo":'_files -g "*.foo"', "bar":"(one two three)",
-            "colors":"_values -s , 'colors to use' red green blue"}
-        A dict mapping long option names to Zsh "actions". These actions
-        define what will be completed as the argument to the given option.  By
-        default, all files/dirs will be completed if no action is given.
-
-        Callables may instead be given for the values in this dict. The
-        callable should accept no arguments, and return a string that will be
-        used as the zsh "action" in the same way as the literal strings in the
-        examples above.
-
-        As you can see in the example above. The "foo" option will have files
-        that end in .foo completed when the user presses Tab. The "bar"
-        option will have either of the strings "one", "two", or "three"
-        completed when the user presses Tab.
-
-        "colors" will allow multiple arguments to be completed, seperated by
-        commas. The possible arguments are red, green, and blue. Examples::
-
-            my_command --foo some-file.foo --colors=red,green
-            my_command --colors=green
-            my_command --colors=green,blue
-
-        Actions may take many forms, and it is beyond the scope of this
-        document to illustrate them all. Please refer to the documention for
-        the Zsh _arguments function. zshcomp is basically a front-end to Zsh's
-        _arguments completion function.
-
-        That documentation is available on the zsh web site at this URL:
-        U{http://zsh.sunsite.dk/Doc/Release/zsh_19.html#SEC124}
-
-    zsh_actionDescr = {"logfile":"log file name", "random":"random seed"}
-        A dict mapping long option names to a description for the corresponding
-        zsh "action". These descriptions are show above the generated matches
-        when the user is doing completions for this option.
-
-        Normally Zsh does not show these descriptions unless you have
-        "verbose" completion turned on. Turn on verbosity with this in your
-        ~/.zshrc::
-
-            zstyle ':completion:*' verbose yes
-            zstyle ':completion:*:descriptions' format '%B%d%b'
-
-    zsh_extras = [":file to read from:action", ":file to write to:action"]
-        A sequence of extra arguments that will be passed verbatim to Zsh's
-        _arguments completion function. The _arguments function does all the
-        hard work of doing command line completions. You can see how zshcomp
-        invokes the _arguments call by looking at the generated completion
-        files that this module creates.
-
-   *** NOTE ***
-
-        You will need to use this variable to describe completions for normal
-        command line arguments. That is, those arguments that are not
-        associated with an option. That is, the arguments that are given to the
-        parseArgs method of your usage.Options subclass.
-
-        In the example above, the 1st non-option argument will be described as
-        "file to read from" and completion options will be generated in
-        accordance with the "action". (See above about zsh "actions") The
-        2nd non-option argument will be described as "file to write to" and
-        the action will be interpreted likewise.
-
-        Things you can put here are all documented under the _arguments
-        function here: U{http://zsh.sunsite.dk/Doc/Release/zsh_19.html#SEC124}
-
-Zsh Notes:
-
-To enable advanced completion add something like this to your ~/.zshrc::
-
-    autoload -U compinit
-    compinit
-
-For some extra verbosity, and general niceness add these lines too::
-
-    zstyle ':completion:*' verbose yes
-    zstyle ':completion:*:descriptions' format '%B%d%b'
-    zstyle ':completion:*:messages' format '%d'
-    zstyle ':completion:*:warnings' format 'No matches for: %d'
-
-Have fun!
-"""
-import itertools, sys, commands, os.path
-
-from twisted.python import reflect, util, usage
-from twisted.scripts.mktap import IServiceMaker
-
-class MyOptions(usage.Options):
-    """
-    Options for this file
-    """
-    longdesc = ""
-    synopsis = "Usage: python zshcomp.py [--install | -i] | <output directory>"
-    optFlags = [["install", "i",
-                 'Output files to the "installation" directory ' \
-                 '(twisted/python/zsh in the currently active ' \
-                 'Twisted package)']]
-    optParameters = [["directory", "d", None,
-                      "Output files to this directory"]]
-    def postOptions(self):
-        if self['install'] and self['directory']:
-            raise usage.UsageError, "Can't have --install and " \
-                                    "--directory at the same time"
-        if not self['install'] and not self['directory']:
-            raise usage.UsageError, "Not enough arguments"
-        if self['directory'] and not os.path.isdir(self['directory']):
-            raise usage.UsageError, "%s is not a directory" % self['directory']
-
-class Builder:
-    def __init__(self, cmd_name, options, file):
-        """
-        @type cmd_name: C{str}
-        @param cmd_name: The name of the command
-
-        @type options: C{twisted.usage.Options}
-        @param options: The C{twisted.usage.Options} instance defined for
-                        this command
-
-        @type file: C{file}
-        @param file: The C{file} to write the completion function to
-        """
-
-        self.cmd_name = cmd_name
-        self.options = options
-        self.file = file
-
-    def write(self):
-        """
-        Write the completion function to the file given to __init__
-        @return: C{None}
-        """
-        # by default, we just write out a single call to _arguments
-        self.file.write('#compdef %s\n' % (self.cmd_name,))
-        gen = ArgumentsGenerator(self.cmd_name, self.options, self.file)
-        gen.write()
-
-class SubcommandBuilder(Builder):
-    """
-    Use this builder for commands that have sub-commands. twisted.python.usage
-    has the notion of sub-commands that are defined using an entirely seperate
-    Options class.
-    """
-    interface = None
-    subcmdLabel = None
-
-    def write(self):
-        """
-        Write the completion function to the file given to __init__
-        @return: C{None}
-        """
-        self.file.write('#compdef %s\n' % (self.cmd_name,))
-        self.file.write('local _zsh_subcmds_array\n_zsh_subcmds_array=(\n')
-        from twisted import plugin as newplugin
-        plugins = newplugin.getPlugins(self.interface)
-
-        for p in plugins:
-            self.file.write('"%s:%s"\n' % (p.tapname, p.description))
-        self.file.write(")\n\n")
-
-        self.options.__class__.zsh_extras = ['*::subcmd:->subcmd']
-        gen = ArgumentsGenerator(self.cmd_name, self.options, self.file)
-        gen.write()
-
-        self.file.write("""if (( CURRENT == 1 )); then
-  _describe "%s" _zsh_subcmds_array && ret=0
-fi
-(( ret )) || return 0
-
-service="$words[1]"
-
-case $service in\n""" % (self.subcmdLabel,))
-
-        plugins = newplugin.getPlugins(self.interface)
-        for p in plugins:
-            self.file.write(p.tapname + ")\n")
-            gen = ArgumentsGenerator(p.tapname, p.options(), self.file)
-            gen.write()
-            self.file.write(";;\n")
-        self.file.write("*) _message \"don't know how to" \
-                        " complete $service\";;\nesac")
-
-class MktapBuilder(SubcommandBuilder):
-    """
-    Builder for the mktap command
-    """
-    interface = IServiceMaker
-    subcmdLabel = 'tap to build'
-
-class TwistdBuilder(SubcommandBuilder):
-    """
-    Builder for the twistd command
-    """
-    interface = IServiceMaker
-    subcmdLabel = 'service to run'
-
-class ArgumentsGenerator:
-    """
-    Generate a call to the zsh _arguments completion function
-    based on data in a usage.Options subclass
-    """
-    def __init__(self, cmd_name, options, file):
-        """
-        @type cmd_name: C{str}
-        @param cmd_name: The name of the command
-
-        @type options: C{twisted.usage.Options}
-        @param options: The C{twisted.usage.Options} instance defined
-                        for this command
-
-        @type file: C{file}
-        @param file: The C{file} to write the completion function to
-        """
-        self.cmd_name = cmd_name
-        self.options = options
-        self.file = file
-
-        self.altArgDescr = {}
-        self.actionDescr = {}
-        self.multiUse = []
-        self.mutuallyExclusive = []
-        self.actions = {}
-        self.extras = []
-
-        aCL = reflect.accumulateClassList
-        aCD = reflect.accumulateClassDict
-
-        aCD(options.__class__, 'zsh_altArgDescr', self.altArgDescr)
-        aCD(options.__class__, 'zsh_actionDescr', self.actionDescr)
-        aCL(options.__class__, 'zsh_multiUse', self.multiUse)
-        aCL(options.__class__, 'zsh_mutuallyExclusive',
-            self.mutuallyExclusive)
-        aCD(options.__class__, 'zsh_actions', self.actions)
-        aCL(options.__class__, 'zsh_extras', self.extras)
-
-        optFlags = []
-        optParams = []
-
-        aCL(options.__class__, 'optFlags', optFlags)
-        aCL(options.__class__, 'optParameters', optParams)
-
-        for i, optList in enumerate(optFlags):
-            if len(optList) != 3:
-                optFlags[i] = util.padTo(3, optList)
-
-        for i, optList in enumerate(optParams):
-            if len(optList) != 4:
-                optParams[i] = util.padTo(4, optList)
-
-
-        self.optFlags = optFlags
-        self.optParams = optParams
-
-        optParams_d = {}
-        for optList in optParams:
-            optParams_d[optList[0]] = optList[1:]
-        self.optParams_d = optParams_d
-
-        optFlags_d = {}
-        for optList in optFlags:
-            optFlags_d[optList[0]] = optList[1:]
-        self.optFlags_d = optFlags_d
-
-        optAll_d = {}
-        optAll_d.update(optParams_d)
-        optAll_d.update(optFlags_d)
-        self.optAll_d = optAll_d
-
-        self.addAdditionalOptions()
-
-        # makes sure none of the zsh_ data structures reference option
-        # names that don't exist. (great for catching typos)
-        self.verifyZshNames()
-
-        self.excludes = self.makeExcludesDict()
-
-    def write(self):
-        """
-        Write the zsh completion code to the file given to __init__
-        @return: C{None}
-        """
-        self.writeHeader()
-        self.writeExtras()
-        self.writeOptions()
-        self.writeFooter()
-
-    def writeHeader(self):
-        """
-        This is the start of the code that calls _arguments
-        @return: C{None}
-        """
-        self.file.write('_arguments -s -A "-*" \\\n')
-
-    def writeOptions(self):
-        """
-        Write out zsh code for each option in this command
-        @return: C{None}
-        """
-        optNames = self.optAll_d.keys()
-        optNames.sort()
-        for long in optNames:
-            self.writeOpt(long)
-
-    def writeExtras(self):
-        """
-        Write out the "extras" list. These are just passed verbatim to the
-        _arguments call
-        @return: C{None}
-        """
-        for s in self.extras:
-            self.file.write(escape(s))
-            self.file.write(' \\\n')
-
-    def writeFooter(self):
-        """
-        Write the last bit of code that finishes the call to _arguments
-        @return: C{None}
-        """
-        self.file.write('&& return 0\n')
-
-    def verifyZshNames(self):
-        """
-        Ensure that none of the names given in zsh_* variables are typoed
-        @return: C{None}
-        @raise ValueError: Raised if unknown option names have been given in
-                           zsh_* variables
-        """
-        def err(name):
-            raise ValueError, "Unknown option name \"%s\" found while\n" \
-                "examining zsh_ attributes for the %s command" % (
-                    name, self.cmd_name)
-
-        for name in itertools.chain(self.altArgDescr, self.actionDescr,
-        self.actions, self.multiUse):
-            if name not in self.optAll_d:
-                err(name)
-
-        for seq in self.mutuallyExclusive:
-            for name in seq:
-                if name not in self.optAll_d:
-                    err(name)
-
-    def excludeStr(self, long, buildShort=False):
-        """
-        Generate an "exclusion string" for the given option
-
-        @type long: C{str}
-        @param long: The long name of the option
-                     (i.e. "verbose" instead of "v")
-
-        @type buildShort: C{bool}
-        @param buildShort: May be True to indicate we're building an excludes
-                           string for the short option that correspondes to
-                           the given long opt
-
-        @return: The generated C{str}
-        """
-        if long in self.excludes:
-            exclusions = self.excludes[long][:]
-        else:
-            exclusions = []
-
-        # if long isn't a multiUse option (can't appear on the cmd line more
-        # than once), then we have to exclude the short option if we're
-        # building for the long option, and vice versa.
-        if long not in self.multiUse:
-            if buildShort is False:
-                short = self.getShortOption(long)
-                if short is not None:
-                    exclusions.append(short)
-            else:
-                exclusions.append(long)
-
-        if not exclusions:
-            return ''
-
-        strings = []
-        for optName in exclusions:
-            if len(optName) == 1:
-                # short option
-                strings.append("-" + optName)
-            else:
-                strings.append("--" + optName)
-        return "(%s)" % " ".join(strings)
-
-    def makeExcludesDict(self):
-        """
-        @return: A C{dict} that maps each option name appearing in
-        self.mutuallyExclusive to a list of those option names that
-        is it mutually exclusive with (can't appear on the cmd line with)
-        """
-
-        #create a mapping of long option name -> single character name
-        longToShort = {}
-        for optList in itertools.chain(self.optParams, self.optFlags):
-            try:
-                if optList[1] != None:
-                    longToShort[optList[0]] = optList[1]
-            except IndexError:
-                pass
-
-        excludes = {}
-        for lst in self.mutuallyExclusive:
-            for i, long in enumerate(lst):
-                tmp = []
-                tmp.extend(lst[:i])
-                tmp.extend(lst[i+1:])
-                for name in tmp[:]:
-                    if name in longToShort:
-                        tmp.append(longToShort[name])
-
-                if long in excludes:
-                    excludes[long].extend(tmp)
-                else:
-                    excludes[long] = tmp
-        return excludes
-
-    def writeOpt(self, long):
-        """
-        Write out the zsh code for the given argument. This is just part of the
-        one big call to _arguments
-
-        @type long: C{str}
-        @param long: The long name of the option
-                     (i.e. "verbose" instead of "v")
-
-        @return: C{None}
-        """
-        if long in self.optFlags_d:
-            # It's a flag option. Not one that takes a parameter.
-            long_field = "--%s" % long
-        else:
-            long_field = "--%s=" % long
-
-        short = self.getShortOption(long)
-        if short != None:
-            short_field = "-" + short
-        else:
-            short_field = ''
-
-        descr = self.getDescription(long)
-        descr_field = descr.replace("[", "\[")
-        descr_field = descr_field.replace("]", "\]")
-        descr_field = '[%s]' % descr_field
-
-        if long in self.actionDescr:
-            actionDescr_field = self.actionDescr[long]
-        else:
-            actionDescr_field = descr
-
-        action_field = self.getAction(long)
-        if long in self.multiUse:
-            multi_field = '*'
-        else:
-            multi_field = ''
-
-        longExclusions_field = self.excludeStr(long)
-
-        if short:
-            #we have to write an extra line for the short option if we have one
-            shortExclusions_field = self.excludeStr(long, buildShort=True)
-            self.file.write(escape('%s%s%s%s%s' % (shortExclusions_field,
-                multi_field, short_field, descr_field, action_field)))
-            self.file.write(' \\\n')
-
-        self.file.write(escape('%s%s%s%s%s' % (longExclusions_field,
-            multi_field, long_field, descr_field, action_field)))
-        self.file.write(' \\\n')
-
-    def getAction(self, long):
-        """
-        Return a zsh "action" string for the given argument
-        @return: C{str}
-        """
-        if long in self.actions:
-            if callable(self.actions[long]):
-                action = self.actions[long]()
-            else:
-                action = self.actions[long]
-            return ":%s:%s" % (self.getActionDescr(long), action)
-        if long in self.optParams_d:
-            return ':%s:_files' % self.getActionDescr(long)
-        return ''
-
-    def getActionDescr(self, long):
-        """
-        Return the description to be used when this argument is completed
-        @return: C{str}
-        """
-        if long in self.actionDescr:
-            return self.actionDescr[long]
-        else:
-            return long
-
-    def getDescription(self, long):
-        """
-        Return the description to be used for this argument
-        @return: C{str}
-        """
-        #check if we have an alternate descr for this arg, and if so use it
-        if long in self.altArgDescr:
-            return self.altArgDescr[long]
-
-        #otherwise we have to get it from the optFlags or optParams
-        try:
-            descr = self.optFlags_d[long][1]
-        except KeyError:
-            try:
-                descr = self.optParams_d[long][2]
-            except KeyError:
-                descr = None
-
-        if descr is not None:
-            return descr
-
-        # lets try to get it from the opt_foo method doc string if there is one
-        longMangled = long.replace('-', '_') # this is what t.p.usage does
-        obj = getattr(self.options, 'opt_%s' % longMangled, None)
-        if obj:
-            descr = descrFromDoc(obj)
-            if descr is not None:
-                return descr
-
-        return long # we really ought to have a good description to use
-
-    def getShortOption(self, long):
-        """
-        Return the short option letter or None
-        @return: C{str} or C{None}
-        """
-        optList = self.optAll_d[long]
-        try:
-            return optList[0] or None
-        except IndexError:
-            pass
-
-    def addAdditionalOptions(self):
-        """
-        Add additional options to the optFlags and optParams lists.
-        These will be defined by 'opt_foo' methods of the Options subclass
-        @return: C{None}
-        """
-        methodsDict = {}
-        reflect.accumulateMethods(self.options, methodsDict, 'opt_')
-        methodToShort = {}
-        for name in methodsDict.copy():
-            if len(name) == 1:
-                methodToShort[methodsDict[name]] = name
-                del methodsDict[name]
-
-        for methodName, methodObj in methodsDict.items():
-            long = methodName.replace('_', '-') # t.p.usage does this
-            # if this option is already defined by the optFlags or
-            # optParameters then we don't want to override that data
-            if long in self.optAll_d:
-                continue
-
-            descr = self.getDescription(long)
-
-            short = None
-            if methodObj in methodToShort:
-                short = methodToShort[methodObj]
-
-            reqArgs = methodObj.im_func.func_code.co_argcount
-            if reqArgs == 2:
-                self.optParams.append([long, short, None, descr])
-                self.optParams_d[long] = [short, None, descr]
-                self.optAll_d[long] = [short, None, descr]
-            elif reqArgs == 1:
-                self.optFlags.append([long, short, descr])
-                self.optFlags_d[long] = [short, descr]
-                self.optAll_d[long] = [short, None, descr]
-            else:
-                raise TypeError, '%r has wrong number ' \
-                                 'of arguments' % (methodObj,)
-
-def descrFromDoc(obj):
-    """
-    Generate an appropriate description from docstring of the given object
-    """
-    if obj.__doc__ is None:
-        return None
-
-    lines = obj.__doc__.split("\n")
-    descr = None
-    try:
-        if lines[0] != "" and not lines[0].isspace():
-            descr = lines[0].lstrip()
-        # skip first line if it's blank
-        elif lines[1] != "" and not lines[1].isspace():
-            descr = lines[1].lstrip()
-    except IndexError:
-        pass
-    return descr
-
-def firstLine(s):
-    """
-    Return the first line of the given string
-    """
-    try:
-        i = s.index('\n')
-        return s[:i]
-    except ValueError:
-        return s
-
-def escape(str):
-    """
-    Shell escape the given string
-    """
-    return commands.mkarg(str)[1:]
-
-def siteFunctionsPath():
-    """
-    Return the path to the system-wide site-functions directory or
-    C{None} if it cannot be determined
-    """
-    try:
-        cmd = "zsh -f -c 'echo ${(M)fpath:#/*/site-functions}'"
-        output = commands.getoutput(cmd)
-        if os.path.isdir(output):
-            return output
-    except:
-        pass
-
-generateFor = [('conch', 'twisted.conch.scripts.conch', 'ClientOptions'),
-               ('mktap', 'twisted.scripts.mktap', 'FirstPassOptions'),
-               ('trial', 'twisted.scripts.trial', 'Options'),
-               ('cftp', 'twisted.conch.scripts.cftp', 'ClientOptions'),
-               ('tapconvert', 'twisted.scripts.tapconvert', 'ConvertOptions'),
-               ('twistd', 'twisted.scripts.twistd', 'ServerOptions'),
-               ('ckeygen', 'twisted.conch.scripts.ckeygen', 'GeneralOptions'),
-               ('lore', 'twisted.lore.scripts.lore', 'Options'),
-               ('pyhtmlizer', 'twisted.scripts.htmlizer', 'Options'),
-               ('tap2deb', 'twisted.scripts.tap2deb', 'MyOptions'),
-               ('tkconch', 'twisted.conch.scripts.tkconch', 'GeneralOptions'),
-               ('manhole', 'twisted.scripts.manhole', 'MyOptions'),
-               ('tap2rpm', 'twisted.scripts.tap2rpm', 'MyOptions'),
-               ('websetroot', None, None),
-               ('tkmktap', None, None),
-               ]
-# NOTE: the commands using None above are no longer included in Twisted.
-# However due to limitations in zsh's completion system the version of
-# _twisted_zsh_stub shipped with zsh contains a static list of Twisted's
-# commands. It will display errors if completion functions for these missing
-# commands are not found :( So we just include dummy (empty) completion
-# function files
-
-specialBuilders = {'mktap'  : MktapBuilder,
-                   'twistd' : TwistdBuilder}
-
-def makeCompFunctionFiles(out_path, generateFor=generateFor,
-                          specialBuilders=specialBuilders):
-    """
-    Generate completion function files in the given directory for all
-    twisted commands
-
-    @type out_path: C{str}
-    @param out_path: The path to the directory to generate completion function
-                     fils in
-
-    @param generateFor: Sequence in the form of the 'generateFor' top-level
-                        variable as defined in this module. Indicates what
-                        commands to build completion files for.
-
-    @param specialBuilders: Sequence in the form of the 'specialBuilders'
-                            top-level variable as defined in this module.
-                            Indicates what commands require a special
-                            Builder class.
-
-    @return: C{list} of 2-tuples of the form (cmd_name, error) indicating
-             commands that we skipped building completions for. cmd_name
-             is the name of the skipped command, and error is the Exception
-             that was raised when trying to import the script module.
-             Commands are usually skipped due to a missing dependency,
-             e.g. Tkinter.
-    """
-    skips = []
-    for cmd_name, module_name, class_name in generateFor:
-        if module_name is None:
-            # create empty file
-            f = _openCmdFile(out_path, cmd_name)
-            f.close()
-            continue
-        try:
-            m = __import__('%s' % (module_name,), None, None, (class_name))
-            f = _openCmdFile(out_path, cmd_name)
-            o = getattr(m, class_name)() # instantiate Options class
-
-            if cmd_name in specialBuilders:
-                b = specialBuilders[cmd_name](cmd_name, o, f)
-                b.write()
-            else:
-                b = Builder(cmd_name, o, f)
-                b.write()
-        except Exception, e:
-            skips.append( (cmd_name, e) )
-            continue
-    return skips
-
-def _openCmdFile(out_path, cmd_name):
-    return file(os.path.join(out_path, '_'+cmd_name), 'w')
-
-def run():
-    options = MyOptions()
-    try:
-        options.parseOptions(sys.argv[1:])
-    except usage.UsageError, e:
-        print e
-        print options.getUsage()
-        sys.exit(2)
-
-    if options['install']:
-        import twisted
-        dir = os.path.join(os.path.dirname(twisted.__file__), "python", "zsh")
-        skips = makeCompFunctionFiles(dir)
-    else:
-        skips = makeCompFunctionFiles(options['directory'])
-
-    for cmd_name, error in skips:
-        sys.stderr.write("zshcomp: Skipped building for %s. Script module " \
-                         "could not be imported:\n" % (cmd_name,))
-        sys.stderr.write(str(error)+'\n')
-    if skips:
-        sys.exit(3)
-
-if __name__ == '__main__':
-    run()