#!/usr/bin/python

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

# Copyright (C) 2008 Gary Kramlich <grim@reaperworld.com>

#

# 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

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