later

#!/usr/bin/env python

import os
import sys
import getpass
import imp
from uuid import uuid4
from glob import iglob
from datetime import datetime
from tempfile import mkstemp

_SCRIPT_DIR = "/".join(sys.argv[0].split("/")[:-1]) 
_PLUGINS_DIR = _SCRIPT_DIR + "/plugins"
_CONFIG_FILE_NAME = "config"
_DATA_DIR = ".later"

_CONFIG={
	"default_piority": 2,
	"username": "ongspxm"
}

def error(msg):
	print "Error:", msg
	exit(2)

class Hooks(object):
	def __getitem__(self, key):
		return self.__dict__[key]
	def __setitem__(self, key, value):
		self.__dict__[key] = value
	def get(self, key, default=None):
		return self.__dict__.get(key, default)

_HOOKS=Hooks()
def hooked(fun):
	"""Decorator: make function available via _HOOKS"""
	_HOOKS[fun.__name__] = fun

def find_config():
	"""Find config file starting from current directory upwards."""
	current = os.path.abspath(os.path.curdir)
	trash = None
	while len(current) > 1:
		data = os.path.join(current, _DATA_DIR)
		config = os.path.join(data, _CONFIG_FILE_NAME)
		if os.path.isdir(data) and os.path.isfile(config):
			return config
		current, trash = os.path.split(current)
	return os.path.join(_SCRIPT_DIR, _CONFIG_FILE_NAME)

@hooked
def guess_username():
	# try user login name
	return getpass.getuser()

def load_plugins():
	load_dir_plugins(_CONFIG.get("data_dir"))
	load_dir_plugins(_PLUGINS_DIR)

def load_dir_plugins(parentDir):
	if not parentDir: return

	for path in iglob(os.path.join(parentDir, "*.py")):
		name = os.path.basename(path)[:-3]
		mod = imp.load_source("plugin:"+name, path)
		mod.plugin_init(_HOOKS)

def load_config():
	"""Load config from file"""
	global _CONFIG
	
	path = find_config()
	if path and os.path.isfile(path):
		for line in open(path):
			i = line.find(": ")
			if i<0: continue

			_CONFIG[line[:i]] = line[i+2:-1]
		_CONFIG["data_dir"] = os.path.dirname(path)
	load_plugins()
	
	if not _CONFIG.get("username", None):
		_CONFIG["username"] = _HOOKS.guess_username()

def store_config(path):
	"""Store config to file"""
	fh = open(path, 'w')
	for key,val in _CONFIG.items():
		if key == "data_dir": continue
		fh.write("%s: %s\n" % (key,val))
	fh.close()

_PROPERTY_CHARS="abcdefghijklmnopqrstuvwxyz_"
def is_property_line(line):
	for i,c in enumerate(line):
		if not c in _PROPERTY_CHARS:
			if i > 0 and c == ":":
				return True
			else:
				return False
	return False
			
def load_lfile(path):
	fh = open(path)
	props = dict()
	line = fh.readline()
	while is_property_line(line):
		i = line.index(":")
		props[line[:i]] = line[i+1:].strip()
		line = fh.readline()
	msg = ""
	while line:
		msg += line
		line = fh.readline()
	return msg.strip(), props

def store_lfile(path, msg, props):
	fh = open(path, 'w')
	for key,val in props.items():
		if not val: continue
		fh.write("%s: %s\n" % (key,val))
	fh.write("\n")
	fh.write(msg)
	fh.write("\n")
	fh.close()

def serialize_datetime(dt):
	return dt.strftime("%Y-%m-%dT%H:%M:%S%z")

class Issue:
	def __init__(self, guid=None, properties=dict(), message="Something is rotten ..."):
		self.properties = dict(
				status="reported",
				#priority=_CONFIG["default_priority"],
				responsible="nobody",
				created=serialize_datetime(datetime.utcnow()),
				reporter=_CONFIG['username'])
		for k,v in properties.items():
			self.properties[k] = v
		self.msg = message
		self.guid = guid or str(uuid4())
	def shortString(self):
		"""One line representation"""
		i = self.msg.find("\n")
		if i < 0:
			i = None
		string = self.msg[:i]
		status = self.properties.get("status", "?")
		return " %s  %-50s %s"%(self.guid[:8], string, status) 
	def longString(self):
		"""Multi line representation"""
		string = "%s\n" % (self.guid)
		for k,v in self.properties.items():
			string += "%s: %s\n" % (k,v)
		string += "\n" + self.msg
		return string

# explicitly not @hooked, since backend specific
def be_gen_path(guid):
	return os.path.join(_CONFIG.get("data_dir", ""), guid + ".issue")

@hooked
def be_all_guids():
	for path in iglob(be_gen_path("*")):
		yield os.path.basename(path)[:-6]

@hooked
def be_complete_guid(halfguid):
	if len(halfguid) == 36:
		return halfguid # already complete
	found = None
	for guid in _HOOKS.be_all_guids():
		if guid.startswith(halfguid):
			if found:
				print "The guid part is ambiguous:"
				print guid, "or"
				print found, "?"
				return
			else:
				found = guid
	return found

@hooked
def be_store_issue(issue):
	issue.properties["modified"] = serialize_datetime(datetime.utcnow())
	store_lfile(be_gen_path(issue.guid), issue.msg, issue.properties)

@hooked
def be_load_issue(guid):
	assert len(guid) == 36
	path = be_gen_path(guid)
	m, p = load_lfile(path)
	return Issue(guid, p, m)

@hooked
def be_delete_issue(guid):
	assert len(guid) == 36
	path = be_gen_path(guid)
	os.remove(path)

@hooked
def be_get_data_dir():
	return _CONFIG.get("data_dir", "")

# explicitly not @hooked, since now plugins available at this point
def cmd_init(args):
	"""Create a new data directory for issues in the current dir."""
	try:
		os.mkdir(_DATA_DIR)
	except OSError, e:
		error("Could not create data directory: " + str(e))
	store_config(os.path.join(_DATA_DIR, _CONFIG_FILE_NAME))

@hooked
def cmd_add(args):
	"""Quickly add a new issue by specifying only a message."""
	issue = Issue()
	issue.msg = args.pop(0)
	_HOOKS.be_store_issue(issue)
	print "issue stored as", issue.guid

def gen_matcher(args):
	"""Generate an issue matcher from command line arguments"""
	if not args:
		def open_matcher(issue):
			"""Default: only list non closed issues"""
			return issue.properties["status"] != "closed"
		return open_matcher
	elif len(args) > 1:
		parts = [gen_matcher([arg]) for arg in args]
		def matcher_and(issue):
			"""Every sub matcher must return True"""
			for p in parts:
				if not p(issue):
					return False
			return True
		return matcher_and
	else:
		assert len(args) == 1
		pattern = args[0]
		if "!=" in pattern:
			key, value = pattern.split("!=")
			def except_matcher(issue):
				return issue.properties.get(key, value) != value
			return except_matcher
		elif "=" in pattern:
			key, value = pattern.split("=")
			def matcher(issue):
				return issue.properties.get(key, None) == value
			return matcher
	error("Can not parse pattern: " + " ".join(args))

@hooked
def cmd_list(args):
	"""By default lists all issues, which are not closed.
Search terms can be given, then only issues where all search terms match the issue properties.

Examples:
- `list status=closed` shows all issues with status closed.
- `list reporter!=beza1e1 status=confirmed` shows all confirmed issues not reported by beza1e1.
- `list bugs` shows issues beginning with "bug:"
	"""
	
	issues = (_HOOKS.be_load_issue(guid) for guid in _HOOKS.be_all_guids())

	# Filtering for bugs
	if args.count('bugs'):
		issues = (iss for iss in issues if iss.msg[:3]=="bug")
		args.remove('bugs')

	matcher = gen_matcher(args)
	for issue in issues:
		# if args specified search in properties,
		# otherwise list all issues not closed.
		if matcher(issue):
			print issue.shortString()

@hooked
def cmd_edit(args):
	"""Edit a specific issue.
If none specified a new issue is generated (like add does.)"""
	try:
		guid = _HOOKS.be_complete_guid(args[0])
		if not guid:
			return
	except IndexError:
		guid = None
	editor = os.getenv("EDITOR")
	if not editor:
		error("no $EDITOR environment variable")
	issue = _HOOKS.be_load_issue(guid)
	fh, filename = mkstemp(".issue")
	store_lfile(filename, issue.msg, issue.properties)
	cmd = "%s %s" % (editor, filename)
	os.system(cmd)
	m,p = load_lfile(filename)
	issue = Issue(issue.guid, p, m)
	_HOOKS.be_store_issue(issue) # updates modified properties
	if not guid: # generated a new issue
		print "Issue stored as", issue.guid

@hooked
def cmd_show(args):
	"""Show a specific issue."""
	if not args:
		error("need guid argument")
	guid = _HOOKS.be_complete_guid(args[0])
	if not guid:
		return
	issue = _HOOKS.be_load_issue(guid)
	print issue.longString()

@hooked
def set_status(guid, status):
	"""Change status of a specific issue"""
	guid = _HOOKS.be_complete_guid(guid)
	if not guid:
		return
	issue = _HOOKS.be_load_issue(guid)
	issue.properties["status"] = status
	_HOOKS.be_store_issue(issue)

@hooked
def cmd_close(args):
	"""Set status of a specific issue to 'closed'"""
	if not args:
		error("need guid argument")
	_HOOKS.set_status(args[0], "closed")

@hooked
def cmd_confirm(args):
	"""Set status of a specific issue to 'confirmed'"""
	if not args:
		error("need guid argument")
	_HOOKS.set_status(args[0], "confirmed")

@hooked
def cmd_assign(args):
	"""Assign an issue to someone"""
	if not args or len(args) < 2:
		error("need guid and assignee")
	guid = _HOOKS.be_complete_guid(args[0])
	issue = _HOOKS.be_load_issue(guid)
	
	issue.properties["responsible"] = " ".join(args[1:])
	_HOOKS.be_store_issue(issue)

_USAGE = """\
A command-line issue tracker for a lazy developer.
Usage is "%s <cmd> ...", where <cmd> is one of
								
init						create dir in current directory
add "msg"					report new issue with title "msg"
edit <guid>					edit issue with the given guid
close <guid>				set status to closed
confirm <guid>				set status to confirmed
assign <guid> <developer>	set responsible to developer
list						show all issues in short
show <guid>					show issue <guid> completely
help <cmd>					shows documentation for <cmd>

PLUGINS
=======

schedule					calculates/show deadlines
htmlreport					generate html report
delete <guid>				delete issue <guid>
delete-closed				delete all closed issues
list-subdirs				show issue list of subdirs
revision					manage revisions
""" % (sys.argv[0])

@hooked
def cmd_help(args=[]):
	"""Provides general usage and help for every command."""
	if len(args) == 0:
		print _USAGE
		return
	fun = _HOOKS.get("cmd_" + args[0], None)
	if not fun:
		print "Can not help you with that. Typo?"
		return
	# print docstring as help for a specific command
	print fun.__doc__

def main():
	if len(sys.argv) <= 1:
		print _USAGE
		return

	if sys.argv[1] == "init":
		cmd_init(sys.argv[2:])
		return
	load_config()

	# e.g. "add" leads to calling "cmd_add"
	fun = _HOOKS.get("cmd_" + sys.argv[1], None)
	if not fun: 
		return _HOOKS.cmd_help()
	print
	
	fun(sys.argv[2:])

if __name__ == "__main__":
	main()