diff options
Diffstat (limited to 'user/purple-plugin-pack/python.patch')
| -rw-r--r-- | user/purple-plugin-pack/python.patch | 1117 |
1 files changed, 1117 insertions, 0 deletions
diff --git a/user/purple-plugin-pack/python.patch b/user/purple-plugin-pack/python.patch new file mode 100644 index 000000000..ad3d00f71 --- /dev/null +++ b/user/purple-plugin-pack/python.patch @@ -0,0 +1,1117 @@ +--- purple-plugin-pack-2.7.0/plugin_pack.py.old 2010-03-29 03:25:57.000000000 +0000 ++++ purple-plugin-pack-2.7.0/plugin_pack.py 2018-11-12 01:03:25.360000000 +0000 +@@ -32,582 +32,561 @@ + Commands: + """ + +-import ConfigParser ++from __future__ import print_function + import getopt + import glob + import os.path +-import string + import sys + +-webpage = 'http://plugins.guifications.org/' +- +-def printerr(msg): +- print >> sys.stderr, msg ++try: ++ import configparser ++except ImportError: ++ import ConfigParser as configparser ++ ++WEBPAGE = 'https://bitbucket.org/rekkanoryo/purple-plugin-pack' ++ ++def printerr(*msg): ++ print(msg, file=sys.stderr) ++ #print(msg) + + class Plugin: +- name = '' +- directory = '' +- type = '' +- depends = [] +- provides = '' +- summary = '' +- description = '' +- authors = [] +- introduced = '' +- notes = '' +- +- def __init__(self, directory, name, parser): +- self.name = name +- +- self.directory = directory +- +- self.type = parser.get(name, 'type') +- self.depends = parser.get(name, 'depends').split() +- self.provides = parser.get(name, 'provides') +- self.summary = parser.get(name, 'summary') +- self.description = parser.get(name, 'description') +- self.authors = parser.get(name, 'authors').split(',') +- self.introduced = parser.get(name, 'introduced') +- +- if parser.has_option(name, 'notes'): +- self.notes = parser.get(name, 'notes') +- +- if self.type != 'default' and self.type != 'incomplete' and self.type != 'abusive': +- printerr('\'%s\' has an unknown type of \'%s\'!' % (self.name, self.type)) +- +- def __str__(self): +- output = 'name: %s\n' % self.name +- output += 'authors: %s\n' % string.join(self.authors, ', ') +- output += 'type: %s\n' % self.type +- output += 'depends: %s\n' % string.join(self.depends, ' ') +- output += 'provides: %s\n' % self.provides +- output += 'directory: %s\n' % self.directory +- output += 'summary: %s\n' % self.summary +- output += 'description: %s\n' % self.description ++ name = '' ++ directory = '' ++ type = '' ++ depends = [] ++ provides = '' ++ summary = '' ++ description = '' ++ authors = [] ++ introduced = '' ++ notes = '' ++ ++ def __init__(self, directory, name, parser): ++ self.name = name ++ ++ self.directory = directory ++ ++ self.type = parser.get(name, 'type') ++ self.depends = parser.get(name, 'depends').split() ++ self.provides = parser.get(name, 'provides') ++ self.summary = parser.get(name, 'summary') ++ self.description = parser.get(name, 'description') ++ self.authors = parser.get(name, 'authors').split(',') ++ self.introduced = parser.get(name, 'introduced') ++ ++ if parser.has_option(name, 'notes'): ++ self.notes = parser.get(name, 'notes') ++ ++ if self.type != 'default' and self.type != 'incomplete' and self.type != 'abusive': ++ printerr('\'%s\' has an unknown type of \'%s\'!' % (self.name, self.type)) ++ ++ def __str__(self): ++ output = 'name: {}\n'.format(self.name) ++ output += 'authors: {}\n'.format(', '.join(self.authors)) ++ output += 'type: {}\n'.format(self.type) ++ output += 'depends: {}\n'.format(' '.join(self.depends)) ++ output += 'provides: {}\n'.format(self.provides) ++ output += 'directory: {}\n'.format(self.directory) ++ output += 'summary: {}\n'.format(self.summary) ++ output += 'description: {}\n'.format(self.description) + +- if self.notes: +- output += 'notes: %s\n' % self.notes ++ if self.notes: ++ output += 'notes: {}\n'.format(self.notes) + +- return output ++ return output + + class PluginPack: +- commands = {} +- plugins = {} ++ commands = {} ++ plugins = {} + +- def load_plugins(self, types, depends): +- if len(types) == 0: +- types = None +- +- if len(depends) == 0: +- depends = None +- +- for file in glob.glob('*/plugins.cfg'): +- parser = ConfigParser.ConfigParser() +- +- try: +- parser.read(file) +- except ConfigParser.ParsingError, msg: +- printerr('Failed to parse \'%s\':\n%s' % (file, msg)) +- continue +- +- for plugin in parser.sections(): +- p = Plugin(os.path.dirname(file), plugin, parser) +- +- # this is kind of hacky, but if we have types, we check to see +- # if the type is in list of types to load. +- if types and not p.type in types: +- continue +- +- # now we check if the give plugins depends match the search +- # depends +- if depends: +- if len(set(depends).intersection(set(p.depends))) == 0: +- continue +- +- self.plugins[p.provides] = p +- +- def list_type(self, type): +- list = [] +- +- for name in self.plugins.keys(): +- plugin = self.plugins[name] +- if plugin.type == type: +- list.append(plugin) +- +- list.sort() +- +- return list +- +- def list_dep(self, dep): +- list = [] +- +- for name in self.plugins.keys(): +- plugin = self.plugins[name] +- +- if dep in plugin.depends: +- list.append(plugin) +- +- list.sort() +- +- return list +- +- def print_names(self, list): +- names = [] +- +- for plugin in list: +- names.append(plugin.name) +- +- print string.join(names, ',') +- +- def default_plugins(self): +- return self.list_type('default') +- +- def abusive_plugins(self): +- return self.list_type('abusive') +- +- def incomplete_plugins(self): +- return self.list_type('incomplete') +- +- def purple_plugins(self): +- return self.list_dep('purple') +- +- def finch_plugins(self): +- return self.list_dep('finch') +- +- def pidgin_plugins(self): +- return self.list_dep('pidgin') +- +- def unique_dirs(self): +- dirs = {} +- for name in self.plugins.keys(): +- dirs[self.plugins[name].directory] = 1 +- +- dirs = dirs.keys() +- dirs.sort() +- +- return dirs +- +- def help(self, args): +- """Displays information about other commands""" +- try: +- cmd = self.commands[args[0]] +- print cmd.__doc__ +- except KeyError: +- print 'command \'%s\' was not found' % args[0] +- except IndexError: +- print '%s' % (self.help.__doc__) +- print +- print 'help usage:' +- print ' help <command>' +- print +- print 'Available commands:' +- +- cmds = self.commands.keys() +- cmds.remove('help') +- cmds.sort() +- print ' %s' % (string.join(cmds, ' ')) +- commands['help'] = help +- +- def dist_dirs(self, args): +- """Displays a list of all plugin directories to included in the distribution""" +- print string.join(self.unique_dirs(), ' ') +- commands['dist_dirs'] = dist_dirs +- +- def build_dirs(self, args): +- """Displays a list of the plugins that can be built""" +- if len(args) != 2: +- printerr('build_dirs expects 2 arguments:') +- printerr('\ta comma separated list of dependencies') +- printerr('\ta comma separated list of plugins to build') +- sys.exit(1) +- +- # store the external depedencies +- externals = args[0].split(',') +- +- deps = {} +- +- # run through the provided dependencies, setting their dependencies to +- # nothing since we know we already have them +- for d in externals: +- deps[d] = [] +- +- # now run through the plugins adding their deps to the dictionary +- for name in self.plugins.keys(): +- plugin = self.plugins[name] +- +- deps[plugin.provides] = plugin.depends +- +- # run through the requested plugins and store their plugin instance in check +- check = [] +- for provides in args[1].split(','): +- try: +- if provides == 'all': +- defaults = [] +- for p in self.default_plugins(): +- defaults.append(p.provides) +- +- check += defaults +- +- continue +- +- plugin = self.plugins[provides] +- check.append(plugin.provides) +- except KeyError: +- continue +- +- # convert our list of plugins to check into a set to remove dupes +- #check = set(check) +- +- # create our list of plugins to build +- build = [] +- +- # now define a function to check our deps +- def has_deps(provides): +- # don't add anything to build more than once +- if provides in build: +- return True +- +- try: +- dep_list = deps[provides] +- except KeyError: +- return False +- +- # now check the dependencies +- for dep in dep_list: +- if '|' in dep: +- count = 0 +- for d in dep.split('|'): +- if has_deps(d): +- count += 1 +- +- if count == 0: +- return False +- else: +- if not has_deps(dep): +- return False +- +- # make sure the provides isn't an external +- if not provides in externals: +- build.append(provides) +- +- # everything checks out! +- return True +- +- # check all the plugins we were told to for their dependencies +- for c in check: +- has_deps(c) +- +- # now create a list of all directories to build +- output = [] +- +- for provides in build: +- plugin = self.plugins[provides] +- +- output.append(plugin.directory) +- +- output.sort() +- +- print "%s" % (string.join(output, ',')) +- commands['build_dirs'] = build_dirs +- +- def list_plugins(self, args): +- """Displays a list similiar to 'dpkg -l' about the plugin pack""" +- +- data = {} +- +- # create an array for the widths, we initialize it to the lengths of +- # the title strings. We ignore summary, since that one shouldn't +- # matter. +- widths = [4, 8, 0] +- +- for p in self.plugins.keys(): +- plugin = self.plugins[p] +- +- if plugin.type == 'abusive': +- type = 'a' +- elif plugin.type == 'incomplete': +- type = 'i' +- else: +- type = 'd' +- +- if 'finch' in plugin.depends: +- ui = 'f' +- elif 'pidgin' in plugin.depends: +- ui = 'p' +- elif 'purple' in plugin.depends: +- ui = 'r' +- else: +- ui = 'u' +- +- widths[0] = max(widths[0], len(plugin.name)) +- widths[1] = max(widths[1], len(plugin.provides)) +- widths[2] = max(widths[2], len(plugin.summary)) +- +- data[plugin.provides] = [type, ui, plugin.name, plugin.provides, plugin.summary] +- +- print 'Type=Default/Incomplete/Abusive' +- print '| UI=Finch/Pidgin/puRple/Unknown' +- print '|/ Name%s Provides%s Summary' % (' ' * (widths[0] - 4), ' ' * (widths[1] - 8)) +- print '++-%s-%s-%s' % ('=' * (widths[0]), '=' * (widths[1]), '=' * (widths[2])) +- +- # create the format var +- fmt = '%%s%%s %%-%ds %%-%ds %%s' % (widths[0], widths[1]) #, widths[2]) +- +- # now loop through the list again, with everything formatted +- list = data.keys() +- list.sort() +- +- for p in list: +- d = data[p] +- print fmt % (d[0], d[1], d[2], d[3], d[4]) +- commands['list'] = list_plugins +- +- def config_file(self, args): +- """Outputs the contents for the file to be m4_include()'d from configure""" +- uniqdirs = self.unique_dirs() +- +- # add our --with-plugins option +- print 'AC_ARG_WITH(plugins,' +- print ' AC_HELP_STRING([--with-plugins], [what plugins to build]),' +- print ' ,with_plugins=all)' +- print 'if test -z $with_plugins ; then' +- print '\twith_plugins=all' +- print 'fi' +- +- # determine and add our output files +- print 'PP_DIST_DIRS="%s"' % (string.join(uniqdirs, ' ')) +- print 'AC_SUBST(PP_DIST_DIRS)' +- print +- print 'AC_CONFIG_FILES([' +- for dir in uniqdirs: +- print '\t%s/Makefile' % (dir) +- print '])' +- print +- +- # setup a second call to determine the plugins to be built +- print 'PP_BUILD=`$PYTHON $srcdir/plugin_pack.py build_dirs $DEPENDENCIES $with_plugins`' +- print +- print 'PP_BUILD_DIRS=`echo $PP_BUILD | sed \'s/,/\ /g\'`' +- print 'AC_SUBST(PP_BUILD_DIRS)' +- print +- print 'PP_PURPLE_BUILD="$PYTHON $srcdir/plugin_pack.py -p show_names $PP_BUILD"' +- print 'PP_PIDGIN_BUILD="$PYTHON $srcdir/plugin_pack.py -P show_names $PP_BUILD"' +- print 'PP_FINCH_BUILD="$PYTHON $srcdir/plugin_pack.py -f show_names $PP_BUILD"' +- commands['config_file'] = config_file +- +- def dependency_graph(self, args): +- """Outputs a graphviz script showing plugin dependencies""" +- def node_label(plugin): +- node = plugin.provides.replace('-', '_') +- label = plugin.name +- +- return node, label +- +- def print_plugins(list): +- for plugin in list: +- node, label = node_label(plugin) +- +- print '\t%s[label="%s"];' % (node, label) +- +- print 'digraph {' +- print '\tlabel="Dependency Graph";' +- print '\tlabelloc="t";' +- print '\tsplines=TRUE;' +- print '\toverlap=FALSE;' +- print +- print '\tnode[fontname="sans", fontsize="8", style="filled"];' +- print +- +- # run through the default plugins +- print '\t/* default plugins */' +- print '\tnode[fillcolor="palegreen",shape="tab"];' +- print_plugins(self.default_plugins()) +- print +- +- # run through the incomplete plugins +- print '\t/* incomplete plugins */' +- print '\tnode[fillcolor="lightyellow1",shape="note"];' +- print_plugins(self.incomplete_plugins()) +- print +- +- # run through the abusive plugins +- print '\t/* abusive plugins */' +- print '\tnode[fillcolor="lightpink",shape="octagon"];' +- print_plugins(self.abusive_plugins()) +- print +- +- # run through again, this time showing the relations +- print '\t/* dependencies' +- print '\t * exteranl ones that don\'t have nodes get colored to the following' +- print '\t */' +- print '\tnode[fillcolor="powderblue", shape="egg"];' +- +- for name in self.plugins.keys(): +- plugin = self.plugins[name] +- +- node, label = node_label(plugin) +- +- for dep in plugin.depends: +- dep = dep.replace('-', '_') +- print '\t%s -> %s;' % (node, dep) +- +- print '}' +- commands['dependency_graph'] = dependency_graph +- +- def debian_description(self, args): +- """Outputs the description for the Debian packages""" +- print 'Description: %d useful plugins for Pidgin, Finch, and Purple' % len(self.plugins) +- print ' The Plugin Pack is a collection of many simple-yet-useful plugins for Pidgin,' +- print ' Finch, and Purple. You will find a summary of each plugin below. For more' +- print ' about an individual plugin, please see %s' % webpage +- print ' .' +- print ' Note: not all %d of these plugins are currently usable' % len(self.plugins) +- +- list = self.plugins.keys() +- list.sort() +- for key in list: +- plugin = self.plugins[key] +- print ' .' +- print ' %s: %s' % (plugin.name, plugin.summary) +- +- print ' .' +- print ' .' +- print ' Homepage: %s' % webpage +- commands['debian_description'] = debian_description +- +- def show_names(self, args): +- """Displays the names of the given comma separated list of provides""" +- +- if len(args) == 0 or len(args[0]) == 0: +- printerr('show_names expects a comma separated list of provides') +- sys.exit(1) +- +- provides = args[0].split(',') +- if len(provides) == 0: +- print "none" +- +- line = " " +- +- for provide in provides: +- if not provide in self.plugins: +- continue +- +- name = self.plugins[provide].name +- +- if len(line) + len(name) + 2 > 75: +- print line.rstrip(',') +- line = ' ' +- +- line += ' %s,' % name +- +- if len(line) > 1: +- print line.rstrip(',') +- commands['show_names'] = show_names +- +- def info(self, args): +- """Displays all information about the given plugins""" +- for p in args: +- try: +- print self.plugins[p].__str__().strip() +- except KeyError: +- print 'Failed to find a plugin that provides \'%s\'' % (p) +- +- print +- commands['info'] = info +- +- def stats(self, args): +- """Displays stats about the plugin pack""" +- counts = {} +- +- counts['total'] = len(self.plugins) +- counts['default'] = len(self.default_plugins()) +- counts['incomplete'] = len(self.incomplete_plugins()) +- counts['abusive'] = len(self.abusive_plugins()) +- counts['purple'] = len(self.purple_plugins()) +- counts['finch'] = len(self.finch_plugins()) +- counts['pidgin'] = len(self.pidgin_plugins()) +- +- def value(val): +- return "%3d (%6.2f%%)" % (val, (float(val) / float(counts['total'])) * 100.0) +- +- print "Purple Plugin Pack Stats" +- print "" +- print "%d plugins in total" % (counts['total']) +- print +- print "Status:" +- print " complete: %s" % (value(counts['default'])) +- print " incomplete: %s" % (value(counts['incomplete'])) +- print " abusive: %s" % (value(counts['abusive'])) +- print "" +- print "Type:" +- print " purple: %s" % (value(counts['purple'])) +- print " finch: %s" % (value(counts['finch'])) +- print " pidgin: %s" % (value(counts['pidgin'])) +- commands['stats'] = stats ++ def load_plugins(self, types, depends): ++ if len(types) == 0: ++ types = None ++ ++ if len(depends) == 0: ++ depends = None ++ ++ for file in glob.glob('*/plugins.cfg'): ++ parser = configparser.ConfigParser() ++ ++ try: ++ parser.read(file) ++ except configparser.ParsingError as msg: ++ printerr('Failed to parse \'%s\':\n%s' % (file, msg)) ++ continue ++ ++ for plugin in parser.sections(): ++ p = Plugin(os.path.dirname(file), plugin, parser) ++ ++ # this is kind of hacky, but if we have types, we check to see ++ # if the type is in list of types to load. ++ if types and not p.type in types: ++ continue ++ ++ # now we check if the give plugins depends match the search ++ # depends ++ if depends: ++ if len(set(depends).intersection(set(p.depends))) == 0: ++ continue ++ ++ self.plugins[p.provides] = p ++ ++ def list_type(self, type): ++ list = [] ++ ++ for name in self.plugins.keys(): ++ plugin = self.plugins[name] ++ if plugin.type == type: ++ list.append(plugin) ++ ++ return list ++ ++ def list_dep(self, dep): ++ list = [] ++ ++ for name in self.plugins.keys(): ++ plugin = self.plugins[name] ++ ++ if dep in plugin.depends: ++ list.append(plugin) ++ ++ return list ++ ++ def print_names(self, list): ++ names = [] ++ ++ for plugin in list: ++ names.append(plugin.name) ++ ++ print(','.join(names)) ++ ++ def default_plugins(self): ++ return self.list_type('default') ++ ++ def abusive_plugins(self): ++ return self.list_type('abusive') ++ ++ def incomplete_plugins(self): ++ return self.list_type('incomplete') ++ ++ def purple_plugins(self): ++ return self.list_dep('purple') ++ ++ def finch_plugins(self): ++ return self.list_dep('finch') ++ ++ def pidgin_plugins(self): ++ return self.list_dep('pidgin') ++ ++ def unique_dirs(self): ++ dirs = {} ++ for name in self.plugins.keys(): ++ dirs[self.plugins[name].directory] = 1 ++ ++ dirs = sorted(dirs.keys()) ++ ++ return dirs ++ ++ def help(self, args): ++ """Displays information about other commands""" ++ try: ++ cmd = self.commands[args[0]] ++ print(cmd.__doc__) ++ except KeyError: ++ print('command \'{}\' was not found'.format(args[0])) ++ except IndexError: ++ print('{}'.format(self.help.__doc__)) ++ print('\nhelp usage:\n help <command>\n\nAvailable commands:') ++ ++ cmds = self.commands.keys() ++ cmds.remove('help') ++ cmds.sort() ++ print(' {}'.format(' '.join(cmds))) ++ commands['help'] = help ++ ++ def dist_dirs(self, args): ++ """Displays a list of all plugin directories to included in the distribution""" ++ print(' '.join(self.unique_dirs())) ++ commands['dist_dirs'] = dist_dirs ++ ++ def build_dirs(self, args): ++ """Displays a list of the plugins that can be built""" ++ if len(args) != 2: ++ printerr('build_dirs expects 2 arguments:') ++ printerr('\ta comma separated list of dependencies') ++ printerr('\ta comma separated list of plugins to build') ++ sys.exit(1) ++ ++ # store the external depedencies ++ externals = args[0].split(',') ++ ++ deps = {} ++ ++ # run through the provided dependencies, setting their dependencies to ++ # nothing since we know we already have them ++ for d in externals: ++ deps[d] = [] ++ ++ # now run through the plugins adding their deps to the dictionary ++ for name in self.plugins.keys(): ++ plugin = self.plugins[name] ++ ++ deps[plugin.provides] = plugin.depends ++ ++ # run through the requested plugins and store their plugin instance in check ++ check = [] ++ for provides in args[1].split(','): ++ try: ++ if provides == 'all': ++ defaults = [] ++ for p in self.default_plugins(): ++ defaults.append(p.provides) ++ ++ check += defaults ++ ++ continue ++ ++ plugin = self.plugins[provides] ++ check.append(plugin.provides) ++ except KeyError: ++ continue ++ ++ # convert our list of plugins to check into a set to remove dupes ++ #check = set(check) ++ ++ # create our list of plugins to build ++ build = [] ++ ++ # now define a function to check our deps ++ def has_deps(provides): ++ # don't add anything to build more than once ++ if provides in build: ++ return True ++ ++ try: ++ dep_list = deps[provides] ++ except KeyError: ++ return False ++ ++ # now check the dependencies ++ for dep in dep_list: ++ if '|' in dep: ++ count = 0 ++ for d in dep.split('|'): ++ if has_deps(d): ++ count += 1 ++ ++ if count == 0: ++ return False ++ else: ++ if not has_deps(dep): ++ return False ++ ++ # make sure the provides isn't an external ++ if not provides in externals: ++ build.append(provides) ++ ++ # everything checks out! ++ return True ++ ++ # check all the plugins we were told to for their dependencies ++ for c in check: ++ has_deps(c) ++ ++ # now create a list of all directories to build ++ output = [] ++ ++ for provides in build: ++ plugin = self.plugins[provides] ++ ++ output.append(plugin.directory) ++ ++ output.sort() ++ ++ print("{}".format(','.join(output))) ++ commands['build_dirs'] = build_dirs ++ ++ def list_plugins(self, args): ++ """Displays a list similiar to 'dpkg -l' about the plugin pack""" ++ ++ data = {} ++ ++ # create an array for the widths, we initialize it to the lengths of ++ # the title strings. We ignore summary, since that one shouldn't ++ # matter. ++ widths = [4, 8, 0] ++ ++ for p in self.plugins.keys(): ++ plugin = self.plugins[p] ++ ++ if plugin.type == 'abusive': ++ type = 'a' ++ elif plugin.type == 'incomplete': ++ type = 'i' ++ else: ++ type = 'd' ++ ++ if 'finch' in plugin.depends: ++ ui = 'f' ++ elif 'pidgin' in plugin.depends: ++ ui = 'p' ++ elif 'purple' in plugin.depends: ++ ui = 'r' ++ else: ++ ui = 'u' ++ ++ widths[0] = max(widths[0], len(plugin.name)) ++ widths[1] = max(widths[1], len(plugin.provides)) ++ widths[2] = max(widths[2], len(plugin.summary)) ++ ++ data[plugin.provides] = [type, ui, plugin.name, plugin.provides, plugin.summary] ++ ++ print('Type=Default/Incomplete/Abusive') ++ print('| UI=Finch/Pidgin/puRple/Unknown') ++ print('|/ Name{} Provides{} Summary'.format(' ' * (widths[0] - 4), ' ' * (widths[1] - 8))) ++ print('++-{}-{}-{}'.format('=' * (widths[0]), '=' * (widths[1]), '=' * (widths[2]))) ++ ++ # create the format var ++ fmt = '{}{} {:<' + str(widths[0]) + '} {:<' + str(widths[1]) + '} {}' ++ ++ # now loop through the list again, with everything formatted ++ list = data.keys() ++ ++ for p in list: ++ d = data[p] ++ print(fmt.format(d[0], d[1], d[2], d[3], d[4])) ++ commands['list'] = list_plugins ++ ++ def config_file(self, args): ++ """Outputs the contents for the file to be m4_include()'d from configure""" ++ uniqdirs = self.unique_dirs() ++ dirs = '' ++ ++ for d in uniqdirs: ++ dirs = dirs + ' ' + d ++ ++ # add our --with-plugins option ++ print('{}\n{}\n{}\n{}\n{}\n{}'.format('AC_ARG_WITH(plugins,', ++ ' AC_HELP_STRING([--with-plugins], [what plugins to build]),', ++ ' ,with_plugins=all)', 'if test -z $with_plugins ; then', ++ '\twith_plugins=all', 'fi')) ++ ++ # determine and add our output files ++ print('{}\n{}\n\n{}'.format( ++ 'PP_DIST_DIRS="{}"'.format(dirs), ++ 'AC_SUBST(PP_DIST_DIRS)', 'AC_CONFIG_FILES([')) ++ for dir in uniqdirs: ++ print('\t{}/Makefile'.format(dir)) ++ print('])\n') ++ ++ # setup a second call to determine the plugins to be built ++ print('{}\n\n{}\n{}\n\n{}\n{}\n{}'.format( ++ 'PP_BUILD=`$PYTHON $srcdir/plugin_pack.py build_dirs $DEPENDENCIES $with_plugins`', ++ 'PP_BUILD_DIRS=`echo $PP_BUILD | sed \'s/,/\ /g\'`', ++ 'AC_SUBST(PP_BUILD_DIRS)', ++ 'PP_PURPLE_BUILD="$PYTHON $srcdir/plugin_pack.py -p show_names $PP_BUILD"', ++ 'PP_PIDGIN_BUILD="$PYTHON $srcdir/plugin_pack.py -P show_names $PP_BUILD"', ++ 'PP_FINCH_BUILD="$PYTHON $srcdir/plugin_pack.py -f show_names $PP_BUILD"')) ++ commands['config_file'] = config_file ++ ++ def dependency_graph(self, args): ++ """Outputs a graphviz script showing plugin dependencies""" ++ def node_label(plugin): ++ node = plugin.provides.replace('-', '_') ++ label = plugin.name ++ ++ return node, label ++ ++ def print_plugins(list): ++ for plugin in list: ++ node, label = node_label(plugin) ++ ++ print('\t{}[label="{}"];'.format(node, label)) ++ ++ print('{}\n{}\n{}\n{}\n{}\n\n{}\n'.format('digraph {', ++ '\tlabel="Dependency Graph";', '\tlabelloc="t";', '\tsplines=TRUE;', ++ '\toverlap=FALSE;', ++ '\tnode[fontname="sans", fontsize="8", style="filled"];')) ++ ++ # run through the default plugins ++ print('{}\n{}'.format('\t/* default plugins */', ++ '\tnode[fillcolor="palegreen",shape="tab"];')) ++ print_plugins(self.default_plugins()) ++ print('') ++ ++ # run through the incomplete plugins ++ print('{}\n{}'.format('\t/* incomplete plugins */', ++ '\tnode[fillcolor="lightyellow1",shape="note"];')) ++ print_plugins(self.incomplete_plugins()) ++ print('') ++ ++ # run through the abusive plugins ++ print('{}\n{}'.format('\t/* abusive plugins */', ++ '\tnode[fillcolor="lightpink",shape="octagon"];')) ++ print_plugins(self.abusive_plugins()) ++ print('') ++ ++ # run through again, this time showing the relations ++ print('{}\n{}\n{}\n{}'.format('\t/* dependencies', ++ '\t * external ones that don\'t have nodes get colored to the following', ++ '\t */', '\tnode[fillcolor="powderblue", shape="egg"];')) ++ ++ for name in self.plugins.keys(): ++ plugin = self.plugins[name] ++ ++ node, label = node_label(plugin) ++ ++ for dep in plugin.depends: ++ dep = dep.replace('-', '_') ++ print('\t() -> {};'.format(node, dep)) ++ ++ print('}') ++ commands['dependency_graph'] = dependency_graph ++ ++ def debian_description(self, args): ++ """Outputs the description for the Debian packages""" ++ print('Description: %d useful plugins for Pidgin, Finch, and Purple'.format(len(self.plugins))) ++ print(' The Plugin Pack is a collection of many simple-yet-useful plugins for Pidgin,') ++ print(' Finch, and Purple. You will find a summary of each plugin below. For more') ++ print(' about an individual plugin, please see {}\n .'.format(WEBPAGE)) ++ print(' Note: not all {} of these plugins are currently usable'.format(len(self.plugins))) ++ ++ list = self.plugins.keys() ++ list.sort() ++ for key in list: ++ plugin = self.plugins[key] ++ print(' .') ++ print(' {}: {}'.format(plugin.name, plugin.summary)) ++ ++ print(' .\n .\n Homepage: {}'.format(WEBPAGE)) ++ commands['debian_description'] = debian_description ++ ++ def show_names(self, args): ++ """Displays the names of the given comma separated list of provides""" ++ ++ if len(args) == 0 or len(args[0]) == 0: ++ printerr('show_names expects a comma separated list of provides') ++ sys.exit(1) ++ ++ provides = args[0].split(',') ++ if len(provides) == 0: ++ print("none") ++ ++ line = " " ++ ++ for provide in provides: ++ if not provide in self.plugins: ++ continue ++ ++ name = self.plugins[provide].name ++ ++ if len(line) + len(name) + 2 > 75: ++ print(line.rstrip(',')) ++ line = ' ' ++ ++ line += ' {},'.format(name) ++ ++ if len(line) > 1: ++ print(line.rstrip(',')) ++ commands['show_names'] = show_names ++ ++ def info(self, args): ++ """Displays all information about the given plugins""" ++ for p in args: ++ try: ++ print(self.plugins[p].__str__().strip() + '\n') ++ except KeyError: ++ print('Failed to find a plugin that provides \'{}\'\n'.format(p)) ++ commands['info'] = info ++ ++ def stats(self, args): ++ """Displays stats about the plugin pack""" ++ counts = {} ++ ++ counts['total'] = len(self.plugins) ++ counts['default'] = len(self.default_plugins()) ++ counts['incomplete'] = len(self.incomplete_plugins()) ++ counts['abusive'] = len(self.abusive_plugins()) ++ counts['purple'] = len(self.purple_plugins()) ++ counts['finch'] = len(self.finch_plugins()) ++ counts['pidgin'] = len(self.pidgin_plugins()) ++ ++ def value(val): ++ return "%3d ({:6}%f)".format(val, (float(val) / float(counts['total'])) * 100.0) ++ ++ print('{}\n\n{}\n\n{}\n{}\n{}\n{}\n\n{}\n{}\n{}\n{}'.format( ++ "Purple Plugin Pack Stats", "{} plugins in total".format(counts['total']), ++ "Status:", " complete: {}".format(value(counts['default'])), ++ " incomplete: {}".format(value(counts['incomplete'])), ++ " abusive: {}".format(value(counts['abusive'])), "Type:", ++ " purple: {}".format(value(counts['purple'])), ++ " finch: {}".format(value(counts['finch'])), ++ " pidgin: {}".format(value(counts['pidgin'])))) ++ commands['stats'] = stats + + def show_usage(pp, exitcode): +- print __doc__ ++ print(__doc__) + +- cmds = pp.commands.keys() +- cmds.sort() +- +- for cmd in cmds: +- print " %-20s %s" % (cmd, pp.commands[cmd].__doc__) ++ cmds = pp.commands.keys() ++ cmds.sort() ++ ++ for cmd in cmds: ++ print(" {:<-20} {}".format(cmd, pp.commands[cmd].__doc__)) + +- print "" ++ print("") + +- sys.exit(exitcode) ++ sys.exit(exitcode) + + def main(): +- # create our main instance +- pp = PluginPack() ++ # create our main instance ++ pp = PluginPack() + +- types = [] +- depends = [] ++ types = [] ++ depends = [] + +- try: +- shortopts = 'adfiPp' ++ try: ++ shortopts = 'adfiPp' + +- opts, args = getopt.getopt(sys.argv[1:], shortopts) +- except getopt.error, msg: +- print msg +- show_usage(pp, 1) +- +- for o, a in opts: +- if o == '-a': +- types.append('abusive') +- elif o == '-d': +- types.append('default') +- elif o == '-i': +- types.append('incomplete') +- elif o == '-f': +- depends.append('finch') +- elif o == '-P': +- depends.append('pidgin') +- elif o == '-p': +- depends.append('purple') +- +- # load the plugins that have been requested, if both lists are empty, all +- # plugins are loaded +- pp.load_plugins(types, depends) +- +- if(len(args) == 0): +- show_usage(pp, 1) +- +- cmd = args[0] +- args = args[1:] +- +- try: +- pp.commands[cmd](pp, args) +- except KeyError: +- printerr('\'%s\' command not found' % (cmd)) ++ opts, args = getopt.getopt(sys.argv[1:], shortopts) ++ except getopt.error as msg: ++ print(msg) ++ show_usage(pp, 1) ++ ++ for o, a in opts: ++ if o == '-a': ++ types.append('abusive') ++ elif o == '-d': ++ types.append('default') ++ elif o == '-i': ++ types.append('incomplete') ++ elif o == '-f': ++ depends.append('finch') ++ elif o == '-P': ++ depends.append('pidgin') ++ elif o == '-p': ++ depends.append('purple') ++ ++ # load the plugins that have been requested, if both lists are empty, all ++ # plugins are loaded ++ pp.load_plugins(types, depends) ++ ++ if(len(args) == 0): ++ show_usage(pp, 1) ++ ++ cmd = args[0] ++ args = args[1:] ++ ++ try: ++ pp.commands[cmd](pp, args) ++ except KeyError: ++ printerr('\'{}\' command not found'.format(cmd)) + + if __name__ == '__main__': +- # this is a work around when we're called for a directory that isn't the +- # directory that this file is in. This happens during distcheck, as well +- # as a few other cases that most people won't use ;) +- if os.path.dirname(__file__) != '': +- os.chdir(os.path.dirname(__file__)) ++ # this is a work around when we're called for a directory that isn't the ++ # directory that this file is in. This happens during distcheck, as well ++ # as a few other cases that most people won't use ;) ++ if os.path.dirname(__file__) != '': ++ os.chdir(os.path.dirname(__file__)) + +- main() ++ main() + |