def _process_tiddler_revisions(self, feed, tiddler, link, do_revisions):
try:
from tiddlywebplugins.differ import compare_tiddlers
except ImportError:
self._add_item(feed, tiddler, link, tiddler.title,
'unable to diff without tiddlywebplugins.differ')
try:
depth = int(do_revisions)
except ValueError:
depth = 1
store = self.environ['tiddlyweb.store']
revision_ids = store.list_tiddler_revisions(tiddler)
while depth >= 0:
try:
rev_older = Tiddler(tiddler.title, tiddler.bag)
rev_older.revision = revision_ids[depth + 1]
rev_older = store.get(rev_older)
except IndexError:
depth -= 1
continue
rev_current = Tiddler(tiddler.title, tiddler.bag)
rev_current.revision = revision_ids[depth]
rev_current = store.get(rev_current)
if binary_tiddler(tiddler):
self._add_item(feed, tiddler, link, tiddler.title,
'Binary Content')
else:
title = '%s comparing version %s to %s' % (tiddler.title,
rev_older.revision, rev_current.revision)
self._add_item(feed, rev_current, link, title,
'<pre>' + compare_tiddlers(rev_older, rev_current)
+ '</pre>')
depth -= 1
def index_tiddler(tiddler, schema, writer):
"""
Index the given tiddler with the given schema using
the provided writer.
The schema dict is read to find attributes and fields
on the tiddler.
"""
if binary_tiddler(tiddler):
return
LOGGER.debug('whoosher: indexing tiddler: %s:%s', tiddler.bag,
tiddler.title)
data = {}
for key in schema:
try:
try:
value = getattr(tiddler, key)
except AttributeError:
value = tiddler.fields[key]
try:
data[key] = unicode(value.lower())
except AttributeError:
value = ','.join(value)
data[key] = unicode(value.lower())
except (KeyError, TypeError) as exc:
pass
except UnicodeDecodeError as exc:
pass
data['id'] = _tiddler_id(tiddler)
writer.update_document(**data)
def _add_tiddler_to_feed(self, feed, tiddler):
do_revisions = self.environ.get('tiddlyweb.query', {}).get(
'depth', [None])[0]
if not do_revisions:
if binary_tiddler(tiddler):
# XXX: ought to be enclosures?
if tiddler.type.startswith('image/'):
description = ('\n<img src="%s" />\n'
% tiddler_url(self.environ, tiddler))
else:
description = ('\n<a href="%s">%s</a>\n'
% (tiddler_url(self.environ, tiddler),
tiddler.title))
elif (renderable(tiddler, self.environ)):
try:
description = render_wikitext(tiddler, self.environ)
except KeyError:
description = 'Tiddler cannot be rendered.'
else:
description = '<pre>' + tiddler.text + '</pre>'
self._add_item(feed, tiddler, tiddler_url(self.environ, tiddler),
tiddler.title, description)
else:
self._process_tiddler_revisions(feed, tiddler,
tiddler_url(self.environ, tiddler), do_revisions)
def as_tiddler(self, tiddler, input_string):
"""
Transform a text representation of a :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>` into a tiddler object.
"""
try:
header, text = input_string.split('\n\n', 1)
tiddler.text = text.rstrip()
headers = header.split('\n')
for field, value in [x.split(': ', 1) for x in headers]:
if value == '':
continue
if hasattr(tiddler, field):
setattr(tiddler, field, value)
else:
tiddler.fields[field] = value.replace('\\n', '\n')
except ValueError as exc:
raise TiddlerFormatError('bad headers in tiddler: %s, %s' %
(tiddler.title, exc))
# In some strange situations tiddler.tags will not
# be a string here, so will still have its default
# value of [], which we want to keep.
if isinstance(tiddler.tags, basestring):
tag_string = tiddler.tags
if tag_string:
tiddler.tags = self.as_tags(tag_string)
# If this is a binary tiddler, clean up.
if binary_tiddler(tiddler):
tiddler.text = b64decode(tiddler.text.lstrip().rstrip())
return tiddler
def tiddler_get(self, tiddler):
tid = self._tid_for_tiddler(tiddler)
if not tid:
raise NoTiddlerError('unable to load %s:%s'
% (tiddler.bag, tiddler.title))
if tiddler.revision:
current_rvid = tiddler.revision
else:
current_rvid = self.redis.lindex('tid:%s:revisions' % tid, -1)
base_rvid = self.redis.lindex('tid:%s:revisions' % tid, 0)
tiddler.creator = self.redis.uget('rvid:%s:modifier' % base_rvid)
tiddler.created = self.redis.uget('rvid:%s:modified' % base_rvid)
tiddler.modifier = self.redis.uget('rvid:%s:modifier' % current_rvid)
if not tiddler.modifier:
raise NoTiddlerError('unable to load %s:%s@%s'
% (tiddler.bag, tiddler.title, current_rvid))
tiddler.modified = self.redis.uget('rvid:%s:modified' % current_rvid)
tiddler.type = self.redis.uget('rvid:%s:type' % current_rvid)
tiddler.tags = list(self.redis.smembers('rvid:%s:tags' % current_rvid))
tiddler.fields = self.redis.hgetall('rvid:%s:fields' % current_rvid)
if binary_tiddler(tiddler):
tiddler.text = self.redis.get('rvid:%s:text' % current_rvid)
else:
tiddler.text = self.redis.uget('rvid:%s:text' % current_rvid)
tiddler.revision = current_rvid
return tiddler
def as_tiddler(self, tiddler, input_string):
"""
Turn a ``JSON`` dictionary into a :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>`. Any keys in the ``JSON``
which are not recognized will be ignored.
"""
try:
dict_from_input = simplejson.loads(input_string)
except simplejson.JSONDecodeError as exc:
raise TiddlerFormatError(
'unable to make json into tiddler: %s, %s'
% (tiddler.title, exc))
accepted_keys = ['created', 'modified', 'modifier', 'tags', 'fields',
'text', 'type']
for key, value in dict_from_input.items():
if value is not None and key in accepted_keys:
setattr(tiddler, key, value)
if binary_tiddler(tiddler):
try:
tiddler.text = b64decode(tiddler.text)
except (TypeError, ValueError) as exc:
raise TiddlerFormatError(
'unable to decode expected base64 input in %s: %s'
% (tiddler.title, exc))
return tiddler
def _tiddler_dict(self, tiddler, fat=False, render=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ['text', 'store']
wanted_keys = [
attribute for attribute in tiddler.slots
if attribute not in unwanted_keys
]
wanted_info = {}
for attribute in wanted_keys:
wanted_info[attribute] = getattr(tiddler, attribute, None)
wanted_info['permissions'] = self._tiddler_permissions(tiddler)
wanted_info['uri'] = tiddler_url(self.environ, tiddler)
if fat:
if tiddler.text:
if binary_tiddler(tiddler):
wanted_info['text'] = b64encode(tiddler.text)
else:
wanted_info['text'] = tiddler.text
else:
wanted_info['text'] = ''
if render and renderable(tiddler, self.environ):
wanted_info['render'] = render_wikitext(tiddler, self.environ)
return wanted_info
def as_tiddler(self, tiddler, input_string):
"""
Turn a ``JSON`` dictionary into a :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>`. Any keys in the ``JSON``
which are not recognized will be ignored.
"""
try:
dict_from_input = simplejson.loads(input_string)
except simplejson.JSONDecodeError as exc:
raise TiddlerFormatError(
'unable to make json into tiddler: %s, %s' %
(tiddler.title, exc))
accepted_keys = [
'created', 'modified', 'modifier', 'tags', 'fields', 'text', 'type'
]
for key, value in dict_from_input.items():
if value is not None and key in accepted_keys:
setattr(tiddler, key, value)
if binary_tiddler(tiddler):
try:
tiddler.text = b64decode(tiddler.text)
except (TypeError, ValueError) as exc:
raise TiddlerFormatError(
'unable to decode expected base64 input in %s: %s' %
(tiddler.title, exc))
return tiddler
def tiddler_put(self, tiddler):
if binary_tiddler(tiddler):
try:
self.binary_store.tiddler_put(tiddler)
except NoBagError:
self.binary_store.bag_put(Bag(tiddler.bag))
self.binary_store.tiddler_put(tiddler)
tiddler.text = ''
self.core_store.tiddler_put(tiddler)
def tiddler_put(self, tiddler):
if binary_tiddler(tiddler):
try:
self.binary_store.tiddler_put(tiddler)
except NoBagError:
self.binary_store.bag_put(Bag(tiddler.bag))
self.binary_store.tiddler_put(tiddler)
tiddler.text = ''
self.core_store.tiddler_put(tiddler)
def _store_tiddler(self, tiddler):
if binary_tiddler(tiddler):
tiddler.text = unicode(b64encode(tiddler.text))
try:
stiddler = self.session.query(sTiddler.id).filter(
and_(sTiddler.title == tiddler.title,
sTiddler.bag == tiddler.bag)).one()
new_tiddler = False
except NoResultFound:
stiddler = sTiddler(tiddler.title, tiddler.bag)
self.session.add(stiddler)
new_tiddler = True
self.session.flush()
srevision = sRevision()
srevision.type = tiddler.type
srevision.modified = tiddler.modified
srevision.modifier = tiddler.modifier
srevision.tiddler_id = stiddler.id
self.session.add(srevision)
self.session.flush()
text_insert = (sText.__table__.insert()
.values(text=tiddler.text, revision_number=srevision.number))
self.session.execute(text_insert)
for tag in set(tiddler.tags):
stag = sTag(tag)
stag.revision_number = srevision.number
self.session.add(stag)
for field in tiddler.fields:
if not field.startswith('server.'):
sfield = sField(field, tiddler.fields[field])
sfield.revision_number = srevision.number
self.session.add(sfield)
self.session.flush()
current_revision = sCurrentRevision()
current_revision.tiddler_id = stiddler.id
current_revision.current_id = srevision.number
self.session.merge(current_revision)
if new_tiddler:
first_revision = sFirstRevision()
first_revision.tiddler_id = stiddler.id
first_revision.first_id = srevision.number
self.session.merge(first_revision)
return srevision.number
def tiddler_as(self, tiddler):
"""
Represent a tiddler as a text string: headers, blank line, text.
"""
if not tiddler.text:
tiddler.text = ''
if binary_tiddler(tiddler):
tiddler.text = b64encode(tiddler.text)
return ('modifier: %s\ncreated: %s\nmodified: %s\ntype: '
'%s\ntags: %s%s\n%s\n' %
(tiddler.modifier, tiddler.created, tiddler.modified,
tiddler.type, self.tags_as(tiddler.tags).replace(
'\n', '\\n'), self.fields_as(tiddler), tiddler.text))
def tiddler_as(self, tiddler):
"""
Represent a tiddler as a text string: headers, blank line, text.
"""
if not tiddler.text:
tiddler.text = ''
if binary_tiddler(tiddler):
tiddler.text = b64encode(tiddler.text)
return ('modifier: %s\ncreated: %s\nmodified: %s\ntype: '
'%s\ntags: %s%s\n%s\n' %
(tiddler.modifier, tiddler.created, tiddler.modified,
tiddler.type,
self.tags_as(tiddler.tags).replace('\n', '\\n'),
self.fields_as(tiddler), tiddler.text))
def _tiddler_as_div(self, tiddler):
"""
Read in the tiddler from a div.
"""
recipe_name = ''
if tiddler.recipe:
recipe_name = tiddler.recipe
try:
host = server_base_url(self.environ)
except KeyError:
host = ''
host = '%s' % host
if binary_tiddler(tiddler):
tiddler_output = self._binary_tiddler(tiddler)
else:
tiddler_output = tiddler.text
if tiddler.type == 'None' or not tiddler.type:
tiddler.type = ''
return ('<div title="%s" server.title="%s" server.page.revision="%s" '
'server.etag="%s" '
'modifier="%s" creator="%s" server.workspace="bags/%s" '
'server.type="tiddlyweb" server.host="%s" '
'server.recipe="%s" server.bag="%s" server.permissions="%s" '
'server.content-type="%s" '
'modified="%s" created="%s" tags="%s" %s>\n'
'<pre>%s</pre>\n</div>\n' %
(escape_attribute_value(tiddler.title),
escape_attribute_value(tiddler.title),
tiddler.revision,
escape_attribute_value(tiddler_etag(
self.environ, tiddler)),
escape_attribute_value(tiddler.modifier),
escape_attribute_value(tiddler.creator),
escape_attribute_value(tiddler.bag),
host,
escape_attribute_value(recipe_name),
escape_attribute_value(tiddler.bag),
self._tiddler_permissions(tiddler),
tiddler.type,
tiddler.modified,
tiddler.created,
escape_attribute_value(self.tags_as(tiddler.tags)),
self._tiddler_fields(tiddler.fields),
html_encode(tiddler_output)))
def _lazy_eligible(self, tiddler):
if binary_tiddler(tiddler):
return True
for bag in BAGS:
if bag == tiddler.bag:
return False
for tag in TAGS:
if tag in tiddler.tags:
return False
for fragment in FRAGMENTS:
if fragment in tiddler.title:
return False
special_titles = self.environ['tiddlyweb.config'].get(
'lazy.titles', [])
if tiddler.title in special_titles + ACTIVE_TITLES + MARKUPS.keys():
return False
return True
def _tiddler_dict(self, tiddler, fat=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ["text", "store"]
wanted_keys = [attribute for attribute in tiddler.slots if attribute not in unwanted_keys]
wanted_info = {}
for attribute in wanted_keys:
wanted_info[attribute] = getattr(tiddler, attribute, None)
wanted_info["permissions"] = self._tiddler_permissions(tiddler)
if fat:
if binary_tiddler(tiddler):
wanted_info["text"] = b64encode(tiddler.text)
else:
wanted_info["text"] = tiddler.text
return dict(wanted_info)
def _tiddler_as_div(self, tiddler):
"""
Read in the tiddler from a div.
"""
recipe_name = ''
if tiddler.recipe:
recipe_name = tiddler.recipe
try:
host = server_base_url(self.environ)
except KeyError:
host = ''
host = '%s/' % host
if binary_tiddler(tiddler):
tiddler_output = self._binary_tiddler(tiddler)
else:
tiddler_output = tiddler.text
if tiddler.type == 'None' or not tiddler.type:
tiddler.type = ''
return ('<div title="%s" server.title="%s" server.page.revision="%s" '
'server.etag="%s" '
'modifier="%s" creator="%s" server.workspace="bags/%s" '
'server.type="tiddlyweb" server.host="%s" '
'server.recipe="%s" server.bag="%s" server.permissions="%s" '
'server.content-type="%s" '
'modified="%s" created="%s" tags="%s" %s>\n'
'<pre>%s</pre>\n</div>\n' %
(escape_attribute_value(tiddler.title),
escape_attribute_value(tiddler.title), tiddler.revision,
escape_attribute_value(_tiddler_etag(self.environ, tiddler)),
escape_attribute_value(
tiddler.modifier), escape_attribute_value(
tiddler.creator), escape_attribute_value(tiddler.bag),
host, escape_attribute_value(recipe_name),
escape_attribute_value(
tiddler.bag), self._tiddler_permissions(tiddler),
tiddler.type, tiddler.modified, tiddler.created,
escape_attribute_value(self.tags_as(
tiddler.tags)), self._tiddler_fields(
tiddler.fields), html_encode(tiddler_output)))
def _tiddler_dict(self, tiddler, fat=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ['text', 'store']
wanted_keys = [
attribute for attribute in tiddler.slots
if attribute not in unwanted_keys
]
wanted_info = {}
for attribute in wanted_keys:
wanted_info[attribute] = getattr(tiddler, attribute, None)
wanted_info['permissions'] = self._tiddler_permissions(tiddler)
if fat:
if binary_tiddler(tiddler):
wanted_info['text'] = b64encode(tiddler.text)
else:
wanted_info['text'] = tiddler.text
return dict(wanted_info)
def _tiddler_dict(self, tiddler, fat=False, render=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ['text', 'store']
wanted_keys = [attribute for attribute in tiddler.slots if
attribute not in unwanted_keys]
wanted_info = {}
for attribute in wanted_keys:
wanted_info[attribute] = getattr(tiddler, attribute, None)
wanted_info['permissions'] = self._tiddler_permissions(tiddler)
if fat:
if binary_tiddler(tiddler):
wanted_info['text'] = b64encode(tiddler.text)
else:
wanted_info['text'] = tiddler.text
if render and renderable(tiddler, self.environ):
wanted_info['render'] = render_wikitext(tiddler,
self.environ)
return wanted_info
def tiddler_as(self, tiddler, omit_empty=False, omit_members=None):
"""
Represent a :py:class:`tiddler <tiddlyweb.model.tiddler.Tiddler>`
as a text string: headers, blank line, text.
``omit_*`` arguments are non-standard options, usable only when this
method is called directly (outside the regular Serializer interface)
If ``omit_empty`` is True, don't emit empty Tiddler members.
``omit_members`` can be used to provide a list of members to not
include in the output.
"""
omit_members = omit_members or []
headers = []
for member in self.tiddler_members:
if member in omit_members:
continue
value = getattr(tiddler, member)
if member == 'tags': # XXX: special-casing
value = self.tags_as(tiddler.tags).replace('\n', '\\n')
if value or not omit_empty:
if value is None:
value = ''
headers.append('%s: %s' % (member, value))
custom_fields = self.fields_as(tiddler)
headers.extend(custom_fields)
if binary_tiddler(tiddler):
body = b64encode(tiddler.text).decode('UTF-8')
else:
body = tiddler.text
return '%s\n\n%s\n' % ('\n'.join(headers), body)
def tiddler_as(self, tiddler, omit_empty=False, omit_members=None):
"""
Represent a :py:class:`tiddler <tiddlyweb.model.tiddler.Tiddler>`
as a text string: headers, blank line, text.
``omit_*`` arguments are non-standard options, usable only when this
method is called directly (outside the regular Serializer interface)
If ``omit_empty`` is True, don't emit empty Tiddler members.
``omit_members`` can be used to provide a list of members to not
include in the output.
"""
omit_members = omit_members or []
headers = []
for member in self.tiddler_members:
if member in omit_members:
continue
value = getattr(tiddler, member)
if member == 'tags': # XXX: special-casing
value = self.tags_as(tiddler.tags).replace('\n', '\\n')
if value or not omit_empty:
if value is None:
value = ''
headers.append('%s: %s' % (member, value))
custom_fields = self.fields_as(tiddler)
headers.extend(custom_fields)
if binary_tiddler(tiddler):
body = b64encode(tiddler.text).decode('UTF-8')
else:
body = tiddler.text
return '%s\n\n%s\n' % ('\n'.join(headers), body)
def as_tiddler(self, tiddler, input_string):
"""
Transform a text representation of a :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>` into a tiddler object.
"""
try:
header, text = input_string.split('\n\n', 1)
tiddler.text = text.rstrip()
headers = header.split('\n')
for field, value in [x.split(': ', 1) for x in headers]:
if value == '':
continue
try:
if hasattr(tiddler, field):
setattr(tiddler, field, value)
else:
tiddler.fields[field] = value.replace('\\n', '\n')
except UnicodeEncodeError:
tiddler.fields[field] = value.replace('\\n', '\n')
except ValueError as exc:
raise TiddlerFormatError('bad headers in tiddler: %s, %s' %
(tiddler.title, exc))
# In some strange situations tiddler.tags will not
# be a string here, so will still have its default
# value of [], which we want to keep.
if isinstance(tiddler.tags, basestring):
tag_string = tiddler.tags
if tag_string:
tiddler.tags = self.as_tags(tag_string)
# If this is a binary tiddler, clean up.
if binary_tiddler(tiddler):
tiddler.text = b64decode(tiddler.text.lstrip().rstrip())
return tiddler
def tiddler_as(self, tiddler, omit_empty=False, omit_members=None):
"""
Represent a tiddler as a text string: headers, blank line, text.
`omit_*` arguments are non-standard options, usable only when this
method is called directly (outside the regular Serializer interface)
If `omit_empty` is True, don't emit empty Tiddler members.
`omit_members` can represent a list of members to not include
in the output.
"""
omit_members = omit_members or []
headers = []
for member in self.tiddler_members:
if member in omit_members:
continue
value = getattr(tiddler, member)
if member == "tags": # XXX: special-casing
value = self.tags_as(tiddler.tags).replace("\n", "\\n")
if value or not omit_empty:
if value is None:
value = ""
headers.append("%s: %s" % (member, value))
custom_fields = self.fields_as(tiddler)
headers.extend(custom_fields)
if binary_tiddler(tiddler):
body = b64encode(tiddler.text)
else:
body = tiddler.text
return "%s\n\n%s\n" % ("\n".join(headers), body)
def _load_tiddler(self, tiddler, current_revision, base_revision):
tiddler.modifier = current_revision.modifier
tiddler.modified = current_revision.modified
tiddler.revision = current_revision.number
tiddler.type = current_revision.type
try:
if binary_tiddler(tiddler):
tiddler.text = b64decode(
current_revision.text.text.lstrip().rstrip())
else:
tiddler.text = current_revision.text.text
except AttributeError:
tiddler.text = ''
tiddler.tags = [tag.tag for tag in current_revision.tags]
for sfield in current_revision.fields:
tiddler.fields[sfield.name] = sfield.value
tiddler.created = base_revision.modified
tiddler.creator = base_revision.modifier
return tiddler
def csvimport(args):
"""Import a csv file as tiddlers. <bagname>"""
store = get_store(config)
try:
bag_name = args[0]
store.get(Bag(bag_name))
except IndexError:
usage('you must include a bag name')
except StoreError:
usage('bag %s does not exist' % bag_name)
tiddler_reader = DictReader(sys.stdin)
for tiddler_data in tiddler_reader:
try:
title = tiddler_data['title']
del tiddler_data['title']
except KeyError:
title = str(uuid4())
tiddler = Tiddler(title, bag_name)
for key, value in tiddler_data.iteritems():
if key is None:
continue
if key == 'tags':
value = string_to_tags_list(value)
if key in CORE_TIDDLER_ATTRS:
setattr(tiddler, key, value)
else:
tiddler.fields[key] = value
if binary_tiddler(tiddler):
try:
tiddler.text = b64decode(tiddler.text)
except TypeError, exc:
raise TiddlerFormatError(
'unable to decode b64 tiddler: %s: %s'
% (tiddler.title, exc))
store.put(tiddler)
"""
Turn a JSON dictionary into a Tiddler.
"""
try:
dict_from_input = simplejson.loads(input_string)
except simplejson.JSONDecodeError, exc:
raise TiddlerFormatError(
'unable to make json into tiddler: %s, %s' %
(tiddler.title, exc))
accepted_keys = [
'created', 'modified', 'modifier', 'tags', 'fields', 'text', 'type'
]
for key, value in dict_from_input.iteritems():
if value is not None and key in accepted_keys:
setattr(tiddler, key, value)
if binary_tiddler(tiddler):
tiddler.text = b64decode(tiddler.text)
return tiddler
def _tiddler_dict(self, tiddler, fat=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ['text', 'store']
wanted_keys = [
attribute for attribute in tiddler.slots
if attribute not in unwanted_keys
]
wanted_info = {}
class Serialization(SerializationInterface):
"""
Serialize entities and collections to and from
textual representations. This is primarily used
by the text Store.
"""
def list_recipes(self, recipes):
"""
Return a linefeed separated list of recipe names.
"""
return ('%s\n' % recipe.name for recipe in recipes)
def list_bags(self, bags):
"""
Return a linefeed separated list of recipe names.
"""
return ('%s\n' % bag.name for bag in bags)
def list_tiddlers(self, tiddlers):
"""
List the tiddlers as text.
"""
tiddlers.store = None
if hasattr(tiddlers, 'is_revisions') and tiddlers.is_revisions:
for tiddler in tiddlers:
yield "%s:%s\n" % (tiddler.title, tiddler.revision)
else:
for tiddler in tiddlers:
yield "%s\n" % tiddler.title
return
def recipe_as(self, recipe):
"""
Recipe as text.
"""
policy_dict = dict([(key, getattr(recipe.policy, key)) for
key in Policy.attributes])
lines = ['desc: %s' % recipe.desc, 'policy: %s' %
simplejson.dumps(policy_dict), '']
for bag, filter_string in recipe.get_recipe():
line = ''
if not isinstance(bag, basestring):
bag = bag.name
if not get_bag_retriever(self.environ, bag):
# If there is a retriever for this bag name then
# we want to write its name straight.
line += '/bags/%s/tiddlers' % urllib.quote(
bag.encode('utf-8'), safe='')
else:
line += bag
if filter_string:
line += '?%s' % filter_string
lines.append(line)
return "\n".join(lines)
def as_recipe(self, recipe, input_string):
"""
Turn a string back into a recipe.
"""
def _handle_headers(recipe, header):
"""
Parse recipe headers from text.
"""
headers = header.split('\n')
for field, value in [x.split(': ', 1) for x in headers]:
if field == 'policy':
recipe.policy = Policy()
info = simplejson.loads(value)
for key, value in info.items():
recipe.policy.__setattr__(key, value)
else:
setattr(recipe, field, value)
try:
header, body = input_string.rstrip().split('\n\n', 1)
_handle_headers(recipe, header)
except ValueError:
body = input_string.rstrip()
if body.startswith('desc:'):
header = body
body = ''
_handle_headers(recipe, header)
recipe_lines = self._recipe_lines(body)
recipe.set_recipe(recipe_lines)
return recipe
def tiddler_as(self, tiddler):
"""
Represent a tiddler as a text string: headers, blank line, text.
"""
if not tiddler.text:
tiddler.text = ''
if binary_tiddler(tiddler):
tiddler.text = b64encode(tiddler.text)
return ('modifier: %s\ncreated: %s\nmodified: %s\ntype: '
'%s\ntags: %s%s\n%s\n' %
(tiddler.modifier, tiddler.created, tiddler.modified,
tiddler.type,
self.tags_as(tiddler.tags).replace('\n', '\\n'),
self.fields_as(tiddler), tiddler.text))
def fields_as(self, tiddler):
"""
Turn tiddler fields into strings in
sort of a RFC 822 header form.
"""
info = '\n'
for key in tiddler.fields:
if not key.startswith('server.'):
value = unicode(tiddler.fields[key])
info += '%s: %s\n' % (key, value.replace('\n', '\\n'))
return info
def as_tiddler(self, tiddler, input_string):
"""
Transform a text representation of a tiddler into
tiddler attributes.
"""
try:
header, text = input_string.split('\n\n', 1)
tiddler.text = text.rstrip()
headers = header.split('\n')
for field, value in [x.split(': ', 1) for x in headers]:
if value == '':
continue
if hasattr(tiddler, field):
setattr(tiddler, field, value)
else:
tiddler.fields[field] = value.replace('\\n', '\n')
except ValueError, exc:
raise TiddlerFormatError('bad headers in tiddler: %s, %s' %
(tiddler.title, exc))
# In some strange situations tiddler.tags will not
# be a string here, so will still have its default
# value of [], which we want to keep.
if isinstance(tiddler.tags, basestring):
tag_string = tiddler.tags
if tag_string:
tiddler.tags = self.as_tags(tag_string)
# If this is a binary tiddler, clean up.
if binary_tiddler(tiddler):
tiddler.text = b64decode(tiddler.text.lstrip().rstrip())
return tiddler
tiddler_dict = self._tiddler_dict(tiddler, fat=True)
return simplejson.dumps(tiddler_dict)
def as_tiddler(self, tiddler, input_string):
"""
Turn a JSON dictionary into a Tiddler.
"""
try:
dict_from_input = simplejson.loads(input_string)
except simplejson.JSONDecodeError, exc:
raise TiddlerFormatError("unable to make json into tiddler: %s, %s" % (tiddler.title, exc))
accepted_keys = ["created", "modified", "modifier", "tags", "fields", "text", "type"]
for key, value in dict_from_input.iteritems():
if value is not None and key in accepted_keys:
setattr(tiddler, key, value)
if binary_tiddler(tiddler):
tiddler.text = b64decode(tiddler.text)
return tiddler
def _tiddler_dict(self, tiddler, fat=False):
"""
Select fields from a tiddler to create
a dictonary.
"""
unwanted_keys = ["text", "store"]
wanted_keys = [attribute for attribute in tiddler.slots if attribute not in unwanted_keys]
wanted_info = {}
for attribute in wanted_keys:
wanted_info[attribute] = getattr(tiddler, attribute, None)
wanted_info["permissions"] = self._tiddler_permissions(tiddler)
def binary_trap(tiddler, environ):
if binary_tiddler(tiddler):
tiddler = closet_binary(environ, tiddler)
def tiddler_delete(self, tiddler):
self.core_store.tiddler_delete(tiddler)
if binary_tiddler(tiddler):
self.binary_store.tiddler_delete(tiddler)
def tiddler_get(self, tiddler):
found_tiddler = self.core_store.tiddler_get(tiddler)
if binary_tiddler(found_tiddler):
found_tiddler.__class__ = BinaryTiddler
found_tiddler._text = None
return found_tiddler
def tiddler_delete(self, tiddler):
self.core_store.tiddler_delete(tiddler)
if binary_tiddler(tiddler):
self.binary_store.tiddler_delete(tiddler)
def tiddler_get(self, tiddler):
found_tiddler = self.core_store.tiddler_get(tiddler)
if binary_tiddler(found_tiddler):
found_tiddler.__class__ = BinaryTiddler
found_tiddler._text = None
return found_tiddler
def binary_trap(tiddler, environ):
if binary_tiddler(tiddler):
tiddler = closet_binary(environ, tiddler)
