| # -*- 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() |
