941 lines
31 KiB
Python
Executable File
941 lines
31 KiB
Python
Executable File
#!/usr/bin/env python2
|
|
# -*- coding: utf-8 -*-
|
|
|
|
u"""%(scriptname)s: gérer un TiddlyWiki
|
|
|
|
USAGE
|
|
%(scriptname)s [options] addtext|addfile|remove|list|edit
|
|
|
|
OPTIONS
|
|
-c twrc
|
|
Charger le fichier de configuration twrc au lieu de la valeur par
|
|
défaut (~/.utools/twrc)
|
|
-f twfile.html
|
|
Utiliser twfile.html au lieu de chercher un fichier par défaut dans le
|
|
répertoire courant. Les noms considérés par défaut sont TODO.html,
|
|
project_wiki.html et TiddlyWiki.html"""
|
|
|
|
__all__ = ('Tiddler', 'TiddlyWiki', 'TwCLI')
|
|
|
|
import os, sys, re
|
|
from os import path
|
|
from getopt import getopt
|
|
from time import localtime
|
|
from types import IntType, LongType, StringTypes
|
|
from xml.dom.minidom import parseString
|
|
|
|
from pyutools.config import ShConfigFile
|
|
from pyutools.dates import datef, TW_DATEF
|
|
from pyutools.iso8859 import quote_attr, quote_html, unquote_but_html
|
|
from pyutools import scriptdir, scriptname, dict, isnum, isstr, isseq
|
|
from pyutools import get_stdin_encoding, get_editor_encoding
|
|
from pyutools import ensure_unicode, uprint, enote, eerror, die, get_colored
|
|
from pyutools import edit_template
|
|
|
|
_marker = []
|
|
|
|
TW_PARAM_PATTERN = re.compile(
|
|
r'(?:' +
|
|
r'(?:"((?:(?:\\")|[^"])+)")|' + # "value"
|
|
r"(?:'((?:(?:\\')|[^'])+)')|" + # 'value'
|
|
r'(?:\[\[(.*?)\]\])|' + # [[space separated values]]
|
|
r'(?:(\{\{.*?\}\}))|' + # {{braced values}}
|
|
r'(?:([^"' + "'" + r'\s]\S*))|' + # value
|
|
r'(?:"")|' + # ""
|
|
r"(?:'')" + # ''
|
|
r')'
|
|
)
|
|
def twParseParams(s):
|
|
params = []
|
|
for a, b, c, d, e in TW_PARAM_PATTERN.findall(s):
|
|
value = a or b or c or d or e
|
|
if value: params.append(value)
|
|
return params
|
|
|
|
def twParseTags(s):
|
|
tags = {}
|
|
for tag in twParseParams(s):
|
|
tags[tag] = None
|
|
return tags.keys()
|
|
|
|
TW_BRACED_VALUE = re.compile(r'\{\{.*\}\}$')
|
|
TW_VALUE = re.compile(r'[^"' + "'" + r'\s]\S*$')
|
|
def twFormatTags(tags):
|
|
ss = []
|
|
for tag in tags:
|
|
if TW_BRACED_VALUE.match(tag): ss.append(tag)
|
|
elif TW_VALUE.match(tag): ss.append(tag)
|
|
else: ss.append("[[%s]]" % tag)
|
|
return " ".join(ss)
|
|
|
|
class Tiddler:
|
|
parent = None # Instance de TiddlyWiki parent de ce Tiddler
|
|
title = u''
|
|
modifier = u''
|
|
creation_date = None
|
|
modification_date = None
|
|
tags = None
|
|
attrs = None
|
|
changecount = 0
|
|
text = u''
|
|
modified = False
|
|
|
|
def __init__(self, element=None, parent=None):
|
|
self.creation_date = self.modification_date = datef(TW_DATEF)
|
|
self.tags = []
|
|
self.attrs = {}
|
|
if parent is not None:
|
|
self.parent = parent
|
|
if element is not None:
|
|
self._parseElement(element)
|
|
|
|
ATTRS = ['title', 'modifier', 'modification_date', 'tags', 'creation_date', 'changecount']
|
|
ATTRS1_MAP = {'tiddler': 'title', 'modified': 'modification_date'}
|
|
ATTRS1_REVMAP = {'title': 'tiddler', 'modification_date': 'modified', 'creation_date': None, 'changecount': None}
|
|
ATTRS2_MAP = {'modified': 'modification_date', 'created': 'creation_date'}
|
|
ATTRS2_REVMAP = {'modification_date': 'modified', 'creation_date': 'created'}
|
|
|
|
def __unquote1(self, s):
|
|
s = s.replace('\\n', '\n')
|
|
return s
|
|
def __quote1(self, s):
|
|
s = s.replace('\n', '\\n')
|
|
return s
|
|
|
|
def __parseElement1(self, div, attrs):
|
|
if attrs is not None:
|
|
for i in range(attrs.length):
|
|
name = div.attributes.item(i).name
|
|
value = div.attributes.item(i).value
|
|
name = self.ATTRS1_MAP.get(name, name)
|
|
if name == 'tags': # cas particulier
|
|
value = twParseTags(value)
|
|
if name in self.ATTRS: setattr(self, name, value)
|
|
else: self.attrs[name] = value
|
|
textNode = div.firstChild
|
|
if textNode is not None:
|
|
self.text = self.__unquote1(textNode.data)
|
|
|
|
def __formatElement1(self):
|
|
s = u'<div'
|
|
for name in self.ATTRS:
|
|
value = getattr(self, name)
|
|
name = self.ATTRS1_REVMAP.get(name, name)
|
|
if name is None: continue
|
|
if name == 'tags': value = twFormatTags(value)
|
|
s += ' %s="%s"' % (name, quote_attr(unicode(value)))
|
|
for name, value in self.attrs.items():
|
|
s += ' %s="%s"' % (name, quote_attr(unicode(value)))
|
|
s += '>'
|
|
s += quote_html(self.__quote1(self.text))
|
|
s += '</div>'
|
|
return s
|
|
|
|
def __parseElement2(self, div, attrs):
|
|
if attrs is not None:
|
|
for i in range(attrs.length):
|
|
name = attrs.item(i).name
|
|
value = div.attributes.item(i).value
|
|
name = self.ATTRS2_MAP.get(name, name)
|
|
if name == 'tags': # cas particulier
|
|
value = twParseTags(value)
|
|
if name in self.ATTRS: setattr(self, name, value)
|
|
else: self.attrs[name] = value
|
|
textNode = div.getElementsByTagName('pre')[0].firstChild
|
|
if textNode is not None:
|
|
self.text = textNode.data
|
|
|
|
def __formatElement2(self):
|
|
s = u'<div'
|
|
for name in self.ATTRS:
|
|
value = getattr(self, name)
|
|
name = self.ATTRS2_REVMAP.get(name, name)
|
|
if name is None: continue
|
|
if name == 'tags': value = twFormatTags(value)
|
|
s += ' %s="%s"' % (name, quote_attr(unicode(value)))
|
|
for name, value in self.attrs.items():
|
|
s += ' %s="%s"' % (name, quote_attr(unicode(value)))
|
|
s += '>\n<pre>'
|
|
s += quote_html(self.text)
|
|
s += '</pre>\n</div>'
|
|
return s
|
|
|
|
def _parseElement(self, div, version=None):
|
|
attrs = div.attributes
|
|
if version is None:
|
|
if attrs.getNamedItem('title') is not None: version = 2
|
|
else: version = 1
|
|
if self.parent is not None:
|
|
self.parent.set_version(version)
|
|
if version == 2: return self.__parseElement2(div, attrs)
|
|
elif version == 1: return self.__parseElement1(div, attrs)
|
|
|
|
def _formatElement(self, version=None):
|
|
if version is None and self.parent is not None:
|
|
version = self.parent.get_version()
|
|
if version == 2: return self.__formatElement2()
|
|
elif version == 1: return self.__formatElement1()
|
|
|
|
def is_modified(self):
|
|
return self.modified
|
|
def set_modified(self):
|
|
self.modification_date = datef(TW_DATEF)
|
|
self.changecount = int(self.changecount) + 1
|
|
self.modified = False
|
|
|
|
def get_changecount(self):
|
|
return self.changecount
|
|
def set_changecount(self, changecount):
|
|
if changecount != self.changecount:
|
|
self.changecount = int(changecount)
|
|
self.modified = True
|
|
|
|
def get_title(self):
|
|
return self.title
|
|
def set_title(self, title):
|
|
if title != self.title:
|
|
self.title = ensure_unicode(title)
|
|
self.modified = True
|
|
|
|
def get_modifier(self):
|
|
return self.modifier
|
|
def set_modifier(self, modifier):
|
|
if modifier != self.modifier:
|
|
self.modifier = modifier
|
|
self.modified = True
|
|
|
|
def get_creation_date(self):
|
|
return self.creation_date
|
|
def set_creation_date(self, creation_date):
|
|
if creation_date != self.creation_date:
|
|
self.creation_date = creation_date
|
|
self.modified = True
|
|
|
|
def get_modification_date(self):
|
|
return self.modification_date
|
|
def set_modification_date(self, modification_date):
|
|
if modification_date != self.modification_date:
|
|
self.modification_date = modification_date
|
|
self.modified = True
|
|
|
|
def get_tags(self):
|
|
return self.tags
|
|
def set_tags(self, tags):
|
|
if type(tags) in StringTypes: tags = twParseTags(tags)
|
|
if set(tags) != set(self.tags):
|
|
self.tags = tags
|
|
self.modified = True
|
|
def add_tag(self, tag):
|
|
if tag not in self.tags:
|
|
self.tags.append(tag)
|
|
self.modified = True
|
|
def remove_tag(self, tag):
|
|
if tag in self.tags:
|
|
self.tags.remove(tag)
|
|
self.modified = True
|
|
|
|
def get_attrs(self):
|
|
return self.attrs
|
|
def set_attrs(self, attrs):
|
|
if attrs != self.attrs:
|
|
self.attrs = attrs
|
|
self.modified = True
|
|
|
|
def get_text(self):
|
|
return self.text
|
|
def set_text(self, text):
|
|
if text != self.text:
|
|
self.text = ensure_unicode(text)
|
|
self.modified = True
|
|
|
|
def __repr__(self):#XXX
|
|
s = self.get_title()
|
|
if self.get_tags():
|
|
s += "[%s]" % ",".join(self.get_tags())
|
|
return s
|
|
|
|
class TiddlyWiki:
|
|
DEFAULT_NAMES = ('TODO.html', 'project_wiki.html', 'TiddlyWiki.html')
|
|
DEFAULT_NAME = DEFAULT_NAMES[1]
|
|
|
|
valid = False
|
|
file = pf = dirname = filename = None
|
|
|
|
version = 2
|
|
byname = None
|
|
tiddlers = None
|
|
|
|
def __init__(self, src=None, raise_exception=False, default_names=None):
|
|
self.byname = {}
|
|
self.tiddlers = []
|
|
|
|
if default_names is None:
|
|
default_names = self.DEFAULT_NAMES
|
|
if src is None:
|
|
for name in default_names:
|
|
if path.exists(name):
|
|
src = name
|
|
break
|
|
elif path.isdir(src):
|
|
dir = src
|
|
src = None
|
|
for name in default_names:
|
|
pf = path.join(dir, name)
|
|
if path.exists(pf):
|
|
src = pf
|
|
break
|
|
if src is None:
|
|
if raise_exception:
|
|
raise IOError("Impossible de trouver un TiddlyWiki par défaut")
|
|
self.__update_file(self.DEFAULT_NAME)
|
|
else:
|
|
self.__update_file(src)
|
|
self.load(raise_exception=raise_exception)
|
|
|
|
def __update_file(self, file):
|
|
self.file = file
|
|
self.pf = path.abspath(self.file)
|
|
self.dirname, self.filename = path.split(self.pf)
|
|
|
|
MAGIC_PATTERN = re.compile(r'<!--\nTiddlyWiki')
|
|
START_SAVE_AREA = '<div id="storeArea">'
|
|
END_SAVE_AREA = '<!--POST-STOREAREA-->'
|
|
START_DIV = '<div '
|
|
END_DIV = '</div>'
|
|
|
|
def __load_prefix_and_suffix(self, pf, raise_exception=True):
|
|
try:
|
|
inf = open(pf, 'rb')
|
|
try:
|
|
data = inf.read()
|
|
finally:
|
|
inf.close()
|
|
|
|
## Vérifier qu'il s'agit bien d'un tiddlywiki
|
|
if not self.MAGIC_PATTERN.search(data):
|
|
raise ValueError("Fichier de format incorrect: ce n'est pas un tiddlywiki: %s" % self.file)
|
|
|
|
## Vérifier la présence du storeArea
|
|
# début
|
|
pos = data.find(self.START_SAVE_AREA)
|
|
if pos == -1:
|
|
raise ValueError("%s: Impossible de trouver la zone de stockage" % self.file)
|
|
pos += len(self.START_SAVE_AREA)
|
|
self.prefix = data[:pos]
|
|
data = data[pos:]
|
|
# fin
|
|
pos = 0
|
|
while True:
|
|
poss = data.find(self.START_DIV, pos)
|
|
pose = data.find(self.END_DIV, pos)
|
|
if pose == -1:
|
|
raise ValueError("%s: erreur de format à %i" % (self.file, pos))
|
|
if poss != -1 and poss < pose:
|
|
# <div....</div>
|
|
pos = pose + len(self.END_DIV)
|
|
else:
|
|
# end_save_area
|
|
break
|
|
pos = data.find(self.END_DIV, pos)
|
|
if pos == -1:
|
|
raise ValueError("%s: Impossible de trouver la fin de la zone de stockage" % self.file)
|
|
self.suffix = data[pos:]
|
|
data = data[:pos]
|
|
return True, data
|
|
except:
|
|
if raise_exception: raise
|
|
return False, None
|
|
|
|
def load(self, file=None, raise_exception=True):
|
|
if file is not None: self.__update_file(file)
|
|
|
|
self.valid = False
|
|
data = self.__load_prefix_and_suffix(self.pf, raise_exception)[1]
|
|
|
|
# charger les données
|
|
self.valid = True
|
|
|
|
self.byname = {}
|
|
self.tiddlers = []
|
|
|
|
data = self.START_SAVE_AREA + data + self.END_DIV
|
|
data = unquote_but_html(data, "utf-8") # HACK: nécessaire car minidom
|
|
# ne supporte pas les entities. utf-8 est codé en dur parce qu'on sait que
|
|
# TiddlyWiki enregistre dans ce codec.
|
|
dom = parseString(data)
|
|
for node in dom.documentElement.getElementsByTagName('div'):
|
|
self.add(Tiddler(element=node, parent=self))
|
|
|
|
return True
|
|
|
|
def is_valid(self):
|
|
return self.valid
|
|
|
|
def save(self, file=None, templatefile=None, set_modified=True, raise_exception=True):
|
|
if templatefile is None and self.file is None:
|
|
templatefile = path.join(path.split(__file__)[0], 'empty.html')
|
|
if templatefile is None:
|
|
if not hasattr(self, 'prefix') or not hasattr(self, 'suffix'):
|
|
raise IOError("Etat inconsistant: il faut le préfixe et le suffixe")
|
|
else:
|
|
self.__load_prefix_and_suffix(templatefile, raise_exception)
|
|
|
|
if file is not None: self.__update_file(file)
|
|
tmppf = self.pf + '.tmp'
|
|
|
|
try:
|
|
outf = open(tmppf, 'wb')
|
|
try:
|
|
outf.write(self.prefix)
|
|
for tiddler in self.tiddlers:
|
|
if tiddler.is_modified() and set_modified:
|
|
tiddler.set_modified()
|
|
outf.write(tiddler._formatElement().encode("utf-8"))
|
|
outf.write("\n")
|
|
outf.write(self.suffix)
|
|
finally:
|
|
outf.close()
|
|
os.rename(tmppf, self.pf)
|
|
except:
|
|
if raise_exception: raise
|
|
|
|
def set_version(self, version):
|
|
self.version = version
|
|
def get_version(self):
|
|
return self.version
|
|
|
|
def __len__(self):
|
|
return len(self.tiddlers)
|
|
def has_key(self, title):
|
|
return self.byname.has_key(title)
|
|
def __getitem__(self, indexOrTitle, default=_marker):
|
|
if isnum(indexOrTitle):
|
|
return self.tiddlers[indexOrTitle]
|
|
else:
|
|
if default is _marker: return self.byname[indexOrTitle]
|
|
else: return self.byname.get(indexOrTitle, default)
|
|
get = __getitem__
|
|
def add(self, tiddler):
|
|
if not isinstance(tiddler, Tiddler):
|
|
raise ValueError("value doit être une instance de Tiddler")
|
|
title = tiddler.get_title()
|
|
if title in self.byname:
|
|
del self.tiddlers[self.byname[title]]
|
|
tiddler.parent = self
|
|
self.tiddlers.append(tiddler)
|
|
self.byname[title] = tiddler
|
|
def __delitem__(self, indexOrTitle):
|
|
if isnum(indexOrTitle):
|
|
tiddler = self.tiddlers[indexOrTitle]
|
|
index = indexOrTitle
|
|
else:
|
|
tiddler = self.byname[indexOrTitle]
|
|
index = self.tiddlers.index(tiddler)
|
|
del self.byname[tiddler.get_title()]
|
|
del self.tiddlers[index]
|
|
|
|
def __repr__(self):
|
|
return repr(map(lambda t: t.get_title(), self.tiddlers))
|
|
|
|
################################################################################
|
|
|
|
class TwrcFile(ShConfigFile):
|
|
TWRC = "twrc"
|
|
|
|
def __init__(self, file=None, raise_exception=True):
|
|
if file is None:
|
|
testdir = path.join(scriptdir, "test")
|
|
utoolsrcdir = path.join(path.expanduser("~"), ".utools")
|
|
if path.isdir(testdir): file = path.join(testdir, self.TWRC)
|
|
else: file = path.join(utoolsrcdir, self.TWRC)
|
|
raise_exception = False
|
|
ShConfigFile.__init__(self, file=file, raise_exception=raise_exception)
|
|
|
|
DEFAULT_NAMES = "default_names"
|
|
MODIFIER = "modifier"
|
|
|
|
def __p(self, p, refdir=None):
|
|
if refdir is not None:
|
|
if not path.isdir(refdir): refdir = path.split(refdir)[0]
|
|
p = path.normpath(path.expanduser(p))
|
|
if refdir is not None:
|
|
p = path.join(refdir, p)
|
|
return p
|
|
|
|
COMMA_PATTERN = re.compile(r'\s*,\s*')
|
|
def __vs(self, vs):
|
|
if isstr(vs): vs = self.COMMA_PATTERN.split(vs)
|
|
return tuple(vs)
|
|
def __csv(self, csv):
|
|
if isseq(csv): csv = ','.join(csv)
|
|
return ensure_unicode(csv)
|
|
|
|
def get_default_names(self):
|
|
if self.has_key(self.DEFAULT_NAMES): return self.__vs(self[self.DEFAULT_NAMES])
|
|
else: return TiddlyWiki.DEFAULT_NAMES
|
|
def set_default_names(self, default_names=None):
|
|
if default_names is None:
|
|
if self.has_key(self.DEFAULT_NAMES): del self[self.DEFAULT_NAMES]
|
|
else:
|
|
self[self.DEFAULT_NAMES] = self.__csv(default_names)
|
|
|
|
def get_modifier(self):
|
|
if self.has_key(self.MODIFIER): return self[self.MODIFIER]
|
|
else: return os.environ.get('USER', 'TiddlyWiki.py')
|
|
def set_modifier(self, modifier=None):
|
|
if modifier is None:
|
|
if self.has_key(self.MODIFIER): del self[self.MODIFIER]
|
|
else:
|
|
self[self.MODIFIER] = modifier
|
|
|
|
class TwCLI:
|
|
twrc = None
|
|
|
|
def __newTiddlyWiki(self, file=None):
|
|
return TiddlyWiki(file, default_names=self.twrc.get_default_names(), raise_exception=True)
|
|
|
|
twfile = None
|
|
def __twfile(self):
|
|
if self.twfile is None:
|
|
self.twfile = self.__newTiddlyWiki()
|
|
return self.twfile
|
|
|
|
def __init__(self, twrc=None):
|
|
if not isinstance(twrc, TwrcFile):
|
|
twrc = TwrcFile(twrc)
|
|
self.twrc = twrc
|
|
|
|
CONFOPT = 'c:f:'
|
|
CONFLOPT = ['config=', 'file=']
|
|
|
|
def is_global_option(self, opt, value):
|
|
if opt in ('-c', '--config'):
|
|
self.twrc = TwrcFile(value)
|
|
elif opt in ('-f', '--file'):
|
|
self.twfile = self.__newTiddlyWiki(value)
|
|
else:
|
|
return False
|
|
return True
|
|
|
|
def ADDTEXT(self,
|
|
title=None, text=None,
|
|
modifier=None,
|
|
set_tags=None, add_tags=None, remove_tags=None,
|
|
encoding=None,
|
|
argv=(), scriptname=None,
|
|
**kw):
|
|
u"""%(scriptname)s: Créer ou mettre à jour un tiddler
|
|
|
|
USAGE
|
|
%(scriptname)s [options] title
|
|
|
|
OPTIONS
|
|
-m text
|
|
Si le texte du tiddler est spécifié, on ne lance pas d'éditeur
|
|
-u modifier
|
|
Spécifier le nom de l'utilisateur qui fait la modification. Par défaut,
|
|
il s'agit de $USER
|
|
-t tag
|
|
tag: ajouter un tag, -tag: enlever un tag
|
|
-e encoding
|
|
Spécifier l'encoding du titre et du texte s'il sont spécifiés sur la
|
|
ligne de commande. Par défaut, on considère que les données sont
|
|
encodées en %(default_encoding)s"""
|
|
default_encoding = get_stdin_encoding()
|
|
opts, argv = getopt(argv,
|
|
self.CONFOPT + 'hm:u:t:e:',
|
|
self.CONFLOPT + ['help', 'text=', 'modifier=', 'tag=', 'encoding='])
|
|
for opt, value in opts:
|
|
if self.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-h', '--help'):
|
|
uprint(self.LIST.__doc__ % locals())
|
|
sys.exit(0)
|
|
elif opt in ('-m', '--text'):
|
|
text = value
|
|
elif opt in ('-u', '--modifier'):
|
|
modifier = value
|
|
elif opt in ('-t', '--tag'):
|
|
if value.startswith('-'):
|
|
if remove_tags is None: remove_tags = []
|
|
remove_tags.append(value[1:])
|
|
else:
|
|
if value.startswith('+'): value = value[1:]
|
|
if add_tags is None: add_tags = []
|
|
add_tags.append(value)
|
|
elif opt in ('-e', '--encoding'):
|
|
encoding = value
|
|
|
|
if title is None:
|
|
if not argv:
|
|
raise ValueError("Il faut spécifier un titre pour le nouveau tiddler")
|
|
title = argv[0]
|
|
|
|
edit = False
|
|
if text is None:
|
|
text = ''
|
|
edit = True
|
|
if modifier is None:
|
|
modifier = self.twrc.get_modifier()
|
|
if encoding is None:
|
|
encoding = default_encoding
|
|
title = ensure_unicode(title, encoding)
|
|
text = ensure_unicode(text, encoding)
|
|
|
|
twfile = self.__twfile()
|
|
|
|
new_tiddler = False
|
|
tiddler = twfile.get(title, None)
|
|
if tiddler is None:
|
|
new_tiddler = True
|
|
tiddler = Tiddler()
|
|
twfile.add(tiddler)
|
|
|
|
tiddler.set_title(title)
|
|
tiddler.set_text(text)
|
|
tiddler.set_modifier(modifier)
|
|
if set_tags is not None:
|
|
tiddler.set_tags(set_tags)
|
|
if add_tags is not None:
|
|
for tag in add_tags:
|
|
tiddler.add_tag(tag)
|
|
if remove_tags is not None:
|
|
for tag in remove_tags:
|
|
tiddler.remove_tag(tag)
|
|
|
|
if tiddler.is_modified():
|
|
twfile.save()
|
|
if edit:
|
|
self.EDIT(tiddler=tiddler)
|
|
else:
|
|
if new_tiddler: enote(u"Ajout d'un nouveau tiddler '%s'" % title)
|
|
else: enote(u"Mise à jour du tiddler '%s'" % title)
|
|
|
|
def ADDFILE(self,
|
|
file=None, title=None,
|
|
modifier=None,
|
|
set_tags=None, add_tags=None, remove_tags=None,
|
|
encoding=None,
|
|
argv=(), scriptname=None,
|
|
**kw):
|
|
u"""%(scriptname)s: Créer ou mettre à jour un tiddler à partir d'un fichier
|
|
|
|
USAGE
|
|
%(scriptname)s [options] /path/to/file
|
|
|
|
OPTIONS
|
|
-n title
|
|
Spécifier le titre du tiddler. Par défaut, il s'agit du nom du fichier
|
|
-u modifier
|
|
Spécifier le nom de l'utilisateur qui fait la modification. Par défaut,
|
|
il s'agit de $USER
|
|
-t tag
|
|
Ajouter un tag
|
|
Si le fichier a l'extension .js, on ajoute automatiquement le tag
|
|
systemConfig, sauf si un tag est spécifié
|
|
-e encoding
|
|
Spécifier l'encoding du fichier. Par défaut, on lit en %(default_encoding)s"""
|
|
default_encoding = get_editor_encoding()
|
|
opts, argv = getopt(argv,
|
|
self.CONFOPT + 'hn:u:t:e:',
|
|
self.CONFLOPT + ['help', 'title=', 'modifier=', 'tag=', 'encoding='])
|
|
for opt, value in opts:
|
|
if self.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-h', '--help'):
|
|
uprint(self.LIST.__doc__ % locals())
|
|
sys.exit(0)
|
|
elif opt in ('-n', '--title'):
|
|
title = value
|
|
elif opt in ('-u', '--modifier'):
|
|
modifier = value
|
|
elif opt in ('-t', '--tag'):
|
|
if value.startswith('-'):
|
|
if remove_tags is None: remove_tags = []
|
|
remove_tags.append(value[1:])
|
|
else:
|
|
if value.startswith('+'): value = value[1:]
|
|
if add_tags is None: add_tags = []
|
|
add_tags.append(value)
|
|
elif opt in ('-e', '--encoding'):
|
|
encoding = value
|
|
|
|
if file is None:
|
|
if not argv:
|
|
raise ValueError("Il faut spécifier un fichier à importer")
|
|
file = argv[0]
|
|
if not path.exists(file):
|
|
raise IOError("Fichier inexistant: %s" % file)
|
|
|
|
if title is None:
|
|
title = file
|
|
if modifier is None:
|
|
modifier = os.environ.get('USER', 'TiddlyWiki.py')
|
|
if path.splitext(file)[1] == '.js':
|
|
if set_tags is not None:
|
|
set_tags.append('systemConfig')
|
|
else:
|
|
if add_tags is None: add_tags = []
|
|
add_tags.append('systemConfig')
|
|
if encoding is None:
|
|
encoding = defaut_encoding
|
|
|
|
inf = open(file, 'rb')
|
|
try:
|
|
text = ensure_unicode(inf.read(), encoding)
|
|
finally:
|
|
inf.close()
|
|
|
|
twfile = self.__twfile()
|
|
|
|
new_tiddler = False
|
|
tiddler = twfile.get(title, None)
|
|
if tiddler is None:
|
|
new_tiddler = True
|
|
tiddler = Tiddler()
|
|
twfile.add(tiddler)
|
|
|
|
tiddler.set_title(title)
|
|
tiddler.set_modifier(modifier)
|
|
if set_tags is not None:
|
|
tiddler.set_tags(set_tags)
|
|
if add_tags is not None:
|
|
for tag in add_tags:
|
|
tiddler.add_tag(tag)
|
|
if remove_tags is not None:
|
|
for tag in remove_tags:
|
|
tiddler.remove_tag(tag)
|
|
tiddler.set_text(text)
|
|
|
|
if tiddler.is_modified():
|
|
twfile.save()
|
|
if new_tiddler: enote(u"Ajout d'un nouveau tiddler '%s'" % title)
|
|
else: enote(u"Mise à jour du tiddler '%s'" % title)
|
|
|
|
def REMOVE(self,
|
|
title=None,
|
|
argv=(), scriptname=None,
|
|
**kw):
|
|
u"""%(scriptname)s: Supprimer un tiddler
|
|
|
|
USAGE
|
|
%(scriptname)s title"""
|
|
opts, argv = getopt(argv,
|
|
self.CONFOPT + 'hn:',
|
|
self.CONFLOPT + ['help', 'title='])
|
|
for opt, value in opts:
|
|
if self.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-h', '--help'):
|
|
uprint(self.LIST.__doc__ % locals())
|
|
sys.exit(0)
|
|
elif opt in ('-n', '--title'):
|
|
title = value
|
|
|
|
if title is None:
|
|
if not argv:
|
|
raise ValueError("Il faut spécifier le tiddler à supprimer")
|
|
title = argv[0]
|
|
|
|
twfile = self.__twfile()
|
|
if twfile.has_key(title):
|
|
del twfile[title]
|
|
twfile.save()
|
|
enote(u"Suppression du tiddler '%s'" % title)
|
|
|
|
def LIST(self,
|
|
showtext=False,
|
|
argv=(), scriptname=None,
|
|
**kw):
|
|
u"""%(scriptname)s: Lister les tiddlers
|
|
|
|
USAGE
|
|
%(scriptname)s
|
|
|
|
OPTIONS
|
|
-l Afficher aussi le contenu des tiddlers"""
|
|
opts, argv = getopt(argv,
|
|
self.CONFOPT + 'hl',
|
|
self.CONFLOPT + ['help', 'show-text'])
|
|
for opt, value in opts:
|
|
if self.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-h', '--help'):
|
|
uprint(self.LIST.__doc__ % locals())
|
|
sys.exit(0)
|
|
elif opt in ('-l', '--show-text'):
|
|
showtext = True
|
|
|
|
twfile = self.__twfile()
|
|
if showtext:
|
|
for tiddler in twfile:
|
|
title = get_colored(u'>>> ' + tiddler.get_title(), 'b')
|
|
if tiddler.get_tags():
|
|
title += " [%s]" % ', '.join(map(lambda t: get_colored(tiddler, 'y'), tiddler.get_tags()))
|
|
uprint(title)
|
|
|
|
text = tiddler.get_text()
|
|
if text: uprint(text)
|
|
else:
|
|
for tiddler in twfile:
|
|
uprint(tiddler.get_title())
|
|
|
|
EDIT_TEMPLATE = u"""
|
|
EDIT: ----------------------------------------------------------------
|
|
EDIT: Saisissez ou modifiez le titre et le corps du tiddler.
|
|
EDIT:
|
|
EDIT: - Les lignes commencant par 'EDIT:' seront supprimées automatiquement
|
|
EDIT: - La ligne tags: peut être modifiée si nécessaire.
|
|
EDIT:
|
|
EDIT: ----------------------------------------------------------------"""
|
|
|
|
TAGS_PATTERN = re.compile(r'##\s*tags:\s*')
|
|
|
|
def __nblines(self, s):
|
|
lines = s.split("\n")
|
|
nblines = len(lines)
|
|
if not lines[-1]: nblines -= 1
|
|
return nblines
|
|
|
|
def EDIT(self,
|
|
title=None,
|
|
tiddler=None,
|
|
argv=(), scriptname=None,
|
|
**kw):
|
|
u"""%(scriptname)s: Editer un tiddler
|
|
|
|
USAGE
|
|
%(scriptname)s title"""
|
|
opts, argv = getopt(argv,
|
|
self.CONFOPT + 'h',
|
|
self.CONFLOPT + ['help'])
|
|
for opt, value in opts:
|
|
if self.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-h', '--help'):
|
|
uprint(self.LIST.__doc__ % locals())
|
|
sys.exit(0)
|
|
|
|
twfile = self.__twfile()
|
|
if tiddler is None:
|
|
if title is None:
|
|
if not argv:
|
|
raise ValueError("Il faut spécifier le tiddler à éditer")
|
|
title = argv[0]
|
|
tiddler = twfile.get(title, None)
|
|
if tiddler is None:
|
|
raise ValueError("Tiddler non trouvé: %s" % title)
|
|
|
|
template = u""
|
|
template += u"## tags: %s\n" % twFormatTags(tiddler.get_tags())
|
|
template += u"\n"
|
|
|
|
title = tiddler.get_title()
|
|
template += u"%s\n" % title
|
|
setline = self.__nblines(template)
|
|
setcol = len(title)
|
|
|
|
text = tiddler.get_text()
|
|
if text: template += u"\n%s\n" % text
|
|
|
|
template += self.EDIT_TEMPLATE
|
|
lines = edit_template(template, 'EDIT:', setline, setcol).split('\n')
|
|
|
|
new_tags = []
|
|
parsing_tags = True
|
|
skip_empty = True
|
|
text = []
|
|
for line in lines:
|
|
if skip_empty and not line: continue
|
|
if parsing_tags:
|
|
mot = self.TAGS_PATTERN.match(line)
|
|
if mot is not None:
|
|
new_tags.extend(twParseTags(line[mot.end():]))
|
|
continue
|
|
else:
|
|
parsing_tags = False
|
|
skip_empty = False
|
|
text.append(line)
|
|
text = "\n".join(text)
|
|
pos = text.find('\n\n')
|
|
if pos == -1:
|
|
title = text.replace('\n', ' ')
|
|
text = u''
|
|
else:
|
|
title = text[:pos].replace('\n', ' ')
|
|
text = text[pos + 2:]
|
|
|
|
tiddler.set_tags(new_tags)
|
|
tiddler.set_title(title)
|
|
tiddler.set_text(text)
|
|
|
|
if tiddler.is_modified():
|
|
twfile.save()
|
|
enote(u"Mise à jour du tiddler '%s'" % title)
|
|
|
|
################################################################################
|
|
|
|
if __name__ == '__main__':
|
|
debug = False
|
|
action = None
|
|
argv = sys.argv[1:]
|
|
twCLI = TwCLI()
|
|
|
|
# Essayer de determiner l'action avec le nom du script
|
|
if scriptname in ('twa', ):
|
|
action = 'addtext'
|
|
elif scriptname in ('twf', ):
|
|
action = 'addfile'
|
|
elif scriptname in ('twl', 'twll',):
|
|
if scriptname == 'twll': argv.insert(0, '-l')
|
|
action = 'list'
|
|
elif scriptname in ('twe', ):
|
|
action = 'edit'
|
|
|
|
if action is None:
|
|
opts, argv = getopt(argv,
|
|
TwCLI.CONFOPT + 'hD',
|
|
TwCLI.CONFLOPT + ['help', 'debug'])
|
|
for opt, value in opts:
|
|
if opt in ('-h', '--help'):
|
|
uprint(__doc__ % dict(scriptname=scriptname))
|
|
sys.exit(0)
|
|
elif twCLI.is_global_option(opt, value):
|
|
pass
|
|
elif opt in ('-D', '--debug'):
|
|
debug = True
|
|
|
|
if not argv:
|
|
uprint(__doc__ % dict(scriptname=scriptname))
|
|
sys.exit(0)
|
|
|
|
action, argv = argv[0], argv[1:]
|
|
if action in ('addtext', 'add', 'a'):
|
|
action = 'addtext'
|
|
elif action in ('addfile', 'file', 'f'):
|
|
action = 'addfile'
|
|
elif action in ('remove', 'r'):
|
|
action = 'remove'
|
|
elif action in ('list', 'l', 'll'):
|
|
if action == 'll': argv.insert(0, '-l')
|
|
action = 'list'
|
|
elif action in ('edit', 'e'):
|
|
action = 'edit'
|
|
else:
|
|
eerror("Action inconnue: %s" % action)
|
|
sys.exit(1)
|
|
|
|
if scriptname in ('TiddlyWiki.py', 'tw'):
|
|
# pour l'affichage de l'aide
|
|
scriptname = '%s %s' % (scriptname, action)
|
|
|
|
try:
|
|
apply(getattr(twCLI, action.upper()), (), {'argv': argv, 'scriptname': scriptname})
|
|
except Exception, e:
|
|
if debug:
|
|
eerror(e[0])
|
|
import traceback
|
|
traceback.print_exc()
|
|
else:
|
|
die(e[0])
|