HGKeeper

#!/usr/bin/python

# plugin_pack.py - Helper script for obtaining info about the plugin pack

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.

"""Usage: plugin_pack.py [OPTION...] command

Flags:

-a Load abusive plugins

-d Load default plugins

-i Load incomplate plugins

-f Load finch plugins

-p Load purple plugins

-P Load pidgin plugins

Commands:

"""

import ConfigParser

import getopt

import glob

import os.path

import string

import sys

webpage = 'http://plugins.guifications.org/'

def printerr(msg):

print >> sys.stderr, 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

if self.notes:

output += 'notes: %s\n' % self.notes

return output

class PluginPack:

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 'help usage:'

print ' help <command>'

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 'AC_CONFIG_FILES(['

for dir in uniqdirs:

print '\t%s/Makefile' % (dir)

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 'PP_BUILD_DIRS=`echo $PP_BUILD | sed \'s/,/\ /g\'`'

print 'AC_SUBST(PP_BUILD_DIRS)'

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 '\tnode[fontname="sans", fontsize="8", style="filled"];'

# run through the default plugins

print '\t/* default plugins */'

print '\tnode[fillcolor="palegreen",shape="tab"];'

print_plugins(self.default_plugins())

# run through the incomplete plugins

print '\t/* incomplete plugins */'

print '\tnode[fillcolor="lightyellow1",shape="note"];'

print_plugins(self.incomplete_plugins())

# run through the abusive plugins

print '\t/* abusive plugins */'

print '\tnode[fillcolor="lightpink",shape="octagon"];'

print_plugins(self.abusive_plugins())

# 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 ' 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)

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 "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 show_usage(pp, exitcode):

print __doc__

cmds = pp.commands.keys()

cmds.sort()

for cmd in cmds:

print " %-20s %s" % (cmd, pp.commands[cmd].__doc__)

print ""

sys.exit(exitcode)

def main():

# create our main instance

pp = PluginPack()

types = []

depends = []

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))

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__))

main()

pidgin/purple-plugin-pack