def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information. If
the tiddler has recently been deleted, resulting
in a StoreError, simply don't add it.
"""
if not tiddler.store and self.store:
try:
tiddler = self.store.get(tiddler)
except StoreError, exc:
LOGGER.debug(
'tried to add missing tiddler to collection: %s, %s',
tiddler, exc)
return
if not self.store.environ['tiddlyweb.config'].get(
'collections.use_memory', False):
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
else:
self._container.append(tiddler)
def add(self, tiddler):
"""
Add a reference to the :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>` to the container, updating the
digest and modified information. If the tiddler has recently been
deleted, resulting in a :py:class:`StoreError
<tiddlyweb.store.StoreError>`, don't add it.
"""
if not tiddler.store and self.store:
try:
tiddler = self.store.get(tiddler)
except StoreError as exc:
LOGGER.debug(
'tried to add missing tiddler to collection: %s, %s',
tiddler, exc)
return
if not self.store.environ['tiddlyweb.config'].get(
'collections.use_memory', False):
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
else:
self._container.append(tiddler)
else:
self._container.append(tiddler)
self._update_digest(tiddler)
modified_string = str(tiddler.modified)
modified_string = modified_string.ljust(14, '0')
if modified_string > self.modified:
self.modified = modified_string
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % web.tiddler_url(
environ, tiddler, container=container, full=False)
recipe = tiddler.recipe
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
if recipe:
tmp_tiddler.recipe = recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError, exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
def mapper(atom_field_name, tiddler, default):
logging.debug(
"atom-custom:: doing a mapping on field %s \n atom-custom::with tiddler %s \n atom-custom::and config %s"
% (atom_field_name, tiddler, mappings))
tid = Tiddler(tiddler['title'], tiddler['bag'])
tid = serializer.as_tiddler(tid, tiddler)
try:
tid.recipe = tiddler['recipe']
except KeyError:
pass
if atom_field_name in mappings:
val = mappings[atom_field_name]
if atom_field_name == 'link' or atom_field_name == 'id' and val.startswith(
"/"):
sh = config['server_host']
val = u"%s://%s%s" % (sh['scheme'], sh['host'], val)
wikified = "http://%s" % wikitext_to_wikklyhtml(
baseurl,
'',
val[7:],
self.environ,
tiddler=tid,
wikiwords=False)
else:
wikified = wikitext_to_wikklyhtml(baseurl,
'',
val,
self.environ,
tiddler=tid,
wikiwords=False)
return cgi.escape(wikified).decode("utf-8")
else:
return default
def test_tiddler_url():
tiddler = Tiddler('foobar')
tiddler.bag = 'zoom'
url = tiddler_url(environ, tiddler)
assert url == 'http://our_test_domain:8001/bags/zoom/tiddlers/foobar'
tiddler.recipe = 'car'
url = tiddler_url(environ, tiddler, container='recipes')
assert url == 'http://our_test_domain:8001/recipes/car/tiddlers/foobar'
url = tiddler_url(environ, tiddler, container='recipes', full=False)
assert url == '/recipes/car/tiddlers/foobar'
config['server_prefix'] = '/sleep'
url = tiddler_url(environ, tiddler, container='recipes', full=False)
assert url == '/sleep/recipes/car/tiddlers/foobar'
url = tiddler_url(environ, tiddler)
assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
tiddler.fields['_canonical_uri'] = 'http://example.com'
url = tiddler_url(environ, tiddler)
# we decided url is always local
#assert url == 'http://example.com'
assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
def get(environ, start_response):
"""
Using query parameters, determine the current tiddler
and produce an editor for it.
"""
usersign = environ['tiddlyweb.usersign']
try:
tiddler_name = environ['tiddlyweb.query'].get('tiddler', [''])[0]
recipe_name = environ['tiddlyweb.query'].get('recipe', [''])[0]
bag_name = environ['tiddlyweb.query'].get('bag', [''])[0]
#tiddler_name = unicode(urllib.unquote(tiddler_name), 'utf-8')
#bag_name = unicode(urllib.unquote(bag_name), 'utf-8')
#recipe_name = unicode(urllib.unquote(recipe_name), 'utf-8')
except (KeyError, IndexError):
raise HTTP400('tiddler, recipe and bag query strings required')
store = environ['tiddlyweb.store']
tiddler = Tiddler(tiddler_name)
if bag_name:
tiddler.bag = bag_name
else:
recipe = Recipe(recipe_name)
try:
recipe = store.get(recipe)
tiddler.bag = control.determine_tiddler_bag_from_recipe(recipe, tiddler).name
tiddler.recipe = recipe.name
except NoRecipeError, exc:
raise HTTP404('unable to edit %s, recipe %s not found: %s' % (tiddler.title, recipe_name, exc))
except NoBagError, exc:
raise HTTP404('unable to edit %s: %s' % (tiddler.title, exc))
def get(environ, start_response):
"""
Using query parameters, determine the current tiddler
and produce an editor for it.
"""
usersign = environ["tiddlyweb.usersign"]
try:
tiddler_name = environ["tiddlyweb.query"].get("tiddler", [""])[0]
recipe_name = environ["tiddlyweb.query"].get("recipe", [""])[0]
bag_name = environ["tiddlyweb.query"].get("bag", [""])[0]
except (KeyError, IndexError):
raise HTTP400("tiddler, recipe and bag query strings required")
store = environ["tiddlyweb.store"]
tiddler = Tiddler(tiddler_name)
if bag_name:
tiddler.bag = bag_name
else:
recipe = Recipe(recipe_name)
try:
recipe = store.get(recipe)
tiddler.bag = determine_bag_from_recipe(recipe, tiddler).name
tiddler.recipe = recipe.name
except NoRecipeError, exc:
raise HTTP404("unable to edit %s, recipe %s not found: %s" % (tiddler.title, recipe_name, exc))
except NoBagError, exc:
raise HTTP404("unable to edit %s: %s" % (tiddler.title, exc))
def test_tiddler_url():
tiddler = Tiddler('foobar')
tiddler.bag = 'zoom'
url = tiddler_url(environ, tiddler)
assert url == 'http://our_test_domain:8001/bags/zoom/tiddlers/foobar'
tiddler.recipe = 'car'
url = tiddler_url(environ, tiddler, container='recipes')
assert url == 'http://our_test_domain:8001/recipes/car/tiddlers/foobar'
url = tiddler_url(environ, tiddler, container='recipes', full=False)
assert url == '/recipes/car/tiddlers/foobar'
config['server_prefix'] = '/sleep'
url = tiddler_url(environ, tiddler, container='recipes', full=False)
assert url == '/sleep/recipes/car/tiddlers/foobar'
url = tiddler_url(environ, tiddler)
assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
tiddler.fields['_canonical_uri'] = 'http://example.com'
url = tiddler_url(environ, tiddler)
assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information.
"""
self._update_digest(tiddler)
if self.store:
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
else:
self._container.append(tiddler)
try:
modified_string = str(tiddler.modified)
modified_string = modified_string.ljust(14, '0')
if modified_string > self.modified:
self.modified = modified_string
except AttributeError:
pass
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % web.tiddler_url(environ, tiddler,
container=container, full=False)
recipe = tiddler.recipe
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
if recipe:
tmp_tiddler.recipe = recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError, exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
def get(environ, start_response):
"""
Using query parameters, determine the current tiddler
and produce an editor for it.
"""
usersign = environ['tiddlyweb.usersign']
try:
tiddler_name = environ['tiddlyweb.query'].get('tiddler', [''])[0]
recipe_name = environ['tiddlyweb.query'].get('recipe', [''])[0]
bag_name = environ['tiddlyweb.query'].get('bag', [''])[0]
except (KeyError, IndexError):
raise HTTP400('tiddler, recipe and bag query strings required')
store = environ['tiddlyweb.store']
tiddler = Tiddler(tiddler_name)
if bag_name:
tiddler.bag = bag_name
else:
recipe = Recipe(recipe_name)
try:
recipe = store.get(recipe)
tiddler.bag = control.determine_tiddler_bag_from_recipe(
recipe, tiddler).name
tiddler.recipe = recipe.name
except NoRecipeError, exc:
raise HTTP404('unable to edit %s, recipe %s not found: %s' %
(tiddler.title, recipe_name, exc))
except NoBagError, exc:
raise HTTP404('unable to edit %s: %s' % (tiddler.title, exc))
def test_html_attribute_escape_with_recipe():
tiddler = Tiddler(
'escape "double" quotes & & in <tiddler> field values')
tiddler.bag = 'foo "bar" baz'
tiddler.recipe = 'baz "bar" foo'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('tiddlywebwiki.serialization', environ)
serializer.object = tiddler
string = serializer.to_string()
assert ('title="escape "double" quotes & '
'&amp; in <tiddler> field values"' in string)
assert ('server.title="escape "double" quotes & '
'&amp; in <tiddler> field values"' in string)
assert 'bag="foo "bar" baz"' in string
assert 'recipe="baz "bar" foo"' in string
assert 'server.workspace="bags/foo "bar" baz"' in string
assert 'modifier="Chris "sensei" Dent"' in string
assert 'creator="Chris "sensei" Dent"' in string
assert 'tags="foo [[xxx "yyy" zzz]]"' in string
assert '''custom="lorem 'ipsum' dolor "sit" amet"''' in string
# single tiddler's browse link is that tiddler in its bag
assert ('you may still <a href="/bags/foo%20%22bar%22%20baz/tiddlers'
'/escape%20%22double%22%20quotes%20%26%20%26amp%3B%20in%20%3C'
'tiddler%3E%20field%20values">browse' in string)
def wikifier(mystr, path):
"""
Render TiddlyWiki wikitext in the provided
string to HTML. This function taken and modified
from wikklytextrender.py
"""
tiddler = Tiddler('tmp')
tiddler.text = mystr
tiddler.recipe = path
environ={'tiddlyweb.config': config}
return render_wikitext(tiddler, environ)
def wikifier(mystr, path):
"""
Render TiddlyWiki wikitext in the provided
string to HTML. This function taken and modified
from wikklytextrender.py
"""
tiddler = Tiddler('tmp')
tiddler.text = mystr
tiddler.recipe = path
environ = {'tiddlyweb.config': config}
return render_wikitext(tiddler, environ)
def test_simple_render():
tiddler = Tiddler('bar')
tiddler.text = 'Hello [[monkey]]!'
tiddler.bag = 'zoo'
html = render(tiddler, {})
assert 'href="/bags/zoo/tiddlers/monkey"' in html
tiddler.recipe = 'city'
html = render(tiddler, {})
assert 'href="/recipes/city/tiddlers/monkey"' in html
html = render(tiddler, {'tiddlyweb.config': {'server_prefix': '/wiki'}})
assert 'href="/wiki/recipes/city/tiddlers/monkey"' in html
def test_simple_render():
tiddler = Tiddler('bar')
tiddler.text = 'Hello [[monkey]]!'
tiddler.bag = 'zoo'
html = render(tiddler, {})
assert 'href="/bags/zoo/tiddlers/monkey"' in html
tiddler.recipe = 'city'
html = render(tiddler, {})
assert 'href="/recipes/city/tiddlers/monkey"' in html
html = render(tiddler, {'tiddlyweb.config': {'server_prefix': '/wiki'}})
assert 'href="/wiki/recipes/city/tiddlers/monkey"' in html
def test_base_output():
tiddler = Tiddler('link thing', 'fake')
tiddler.text = TEXT
serializer.object = tiddler
output = serializer.to_string()
assert 'xml:base="http://0.0.0.0:8080/bags/fake/tiddlers/"' in output
tiddler.recipe = 'carnage'
serializer.object = tiddler
output = serializer.to_string()
assert 'xml:base="http://0.0.0.0:8080/recipes/carnage/tiddlers/"' in output
def test_base_output():
tiddler = Tiddler('link thing', 'fake')
tiddler.text = TEXT
serializer.object = tiddler
output = serializer.to_string()
assert 'xml:base="http://0.0.0.0:8080/bags/fake/tiddlers/"' in output
tiddler.recipe = 'carnage'
serializer.object = tiddler
output = serializer.to_string()
assert 'xml:base="http://0.0.0.0:8080/recipes/carnage/tiddlers/"' in output
def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information. If
the tiddler has recently been deleted, resulting
in a StoreError, simply don't add it.
"""
if not tiddler.store and self.store:
try:
tiddler = self.store.get(tiddler)
except StoreError, exc:
logging.debug("tried to add missing tiddler to collection: %s, %s", tiddler, exc)
return
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information.
"""
if not tiddler.store and self.store:
tiddler = self.store.get(tiddler)
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
else:
self._container.append(tiddler)
self._update_digest(tiddler)
modified_string = str(tiddler.modified)
modified_string = modified_string.ljust(14, '0')
if modified_string > self.modified:
self.modified = modified_string
def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information.
"""
if not tiddler.store and self.store:
tiddler = self.store.get(tiddler)
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
else:
self._container.append(tiddler)
self._update_digest(tiddler)
modified_string = str(tiddler.modified)
modified_string = modified_string.ljust(14, '0')
if modified_string > self.modified:
self.modified = modified_string
def mapper(atom_field_name,tiddler,default):
logging.debug("atom-custom:: doing a mapping on field %s \n atom-custom::with tiddler %s \n atom-custom::and config %s"%(atom_field_name,tiddler,mappings))
tid = Tiddler(tiddler['title'],tiddler['bag'])
tid = serializer.as_tiddler(tid,tiddler)
try:
tid.recipe = tiddler['recipe']
except KeyError:
pass
if atom_field_name in mappings:
val = mappings[atom_field_name]
if atom_field_name == 'link' or atom_field_name == 'id' and val.startswith("/"):
sh =config['server_host']
val = u"%s://%s%s"%(sh['scheme'],sh['host'],val)
wikified = "http://%s"%wikitext_to_wikklyhtml(baseurl, '', val[7:], self.environ,tiddler=tid,wikiwords=False)
else:
wikified = wikitext_to_wikklyhtml(baseurl, '', val, self.environ,tiddler=tid,wikiwords=False)
return cgi.escape(wikified).decode("utf-8")
else:
return default
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
recipe = tiddler.recipe
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
if recipe:
tmp_tiddler.recipe = recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError, exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
def add(self, tiddler):
"""
Add a reference to the tiddler to the container,
updating the digest and modified information. If
the tiddler has recently been deleted, resulting
in a StoreError, simply don't add it.
"""
if not tiddler.store and self.store:
try:
tiddler = self.store.get(tiddler)
except StoreError, exc:
logging.debug(
'tried to add missing tiddler to collection: %s, %s',
tiddler, exc)
return
reference = Tiddler(tiddler.title, tiddler.bag)
if tiddler.revision:
reference.revision = tiddler.revision
if tiddler.recipe:
reference.recipe = tiddler.recipe
self._container.append(reference)
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
recipe = tiddler.recipe
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
if recipe:
tmp_tiddler.recipe = recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError, exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % tiddler_url(environ, tiddler,
container=container, full=False)
# Set the container on the tiddlers. Since tiddler.recipe
# defaults to None, we're "safe" here.
tiddlers.recipe = tiddler.recipe
tiddlers.bag = tiddler.bag
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
tmp_tiddler.recipe = tiddler.recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError as exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
except NoBagError as exc:
raise HTTP404('tiddler %s not found, bag %s does not exist, %s'
% (tiddler.title, tiddler.bag, exc))
except StoreMethodNotImplemented:
raise HTTP400('no revision support')
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % tiddler_url(environ, tiddler,
container=container, full=False)
# Set the container on the tiddlers. Since tiddler.recipe
# defaults to None, we're "safe" here.
tiddlers.recipe = tiddler.recipe
tiddlers.bag = tiddler.bag
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
tmp_tiddler.recipe = tiddler.recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError as exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
except NoBagError as exc:
raise HTTP404('tiddler %s not found, bag %s does not exist, %s'
% (tiddler.title, tiddler.bag, exc))
except StoreMethodNotImplemented:
raise HTTP400('no revision support')
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def test_html_attribute_escape_with_recipe():
tiddler = Tiddler('escape "double" quotes in tiddler field values')
tiddler.bag = 'foo "bar" baz'
tiddler.recipe = 'baz "bar" foo'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('tiddlywebwiki.serialization', environ)
serializer.object = tiddler
string = serializer.to_string()
assert r'''title="escape "double" quotes in tiddler field values"''' in string
assert r'''server.title="escape "double" quotes in tiddler field values"''' in string
assert r'''bag="foo "bar" baz"''' in string
assert r'''recipe="baz "bar" foo"''' in string
assert r'''server.workspace="bags/foo "bar" baz"''' in string
assert r'''modifier="Chris "sensei" Dent"''' in string
assert r'''creator="Chris "sensei" Dent"''' in string
assert r'''tags="foo [[xxx "yyy" zzz]]"''' in string
assert r'''custom="lorem 'ipsum' dolor "sit" amet"''' in string
assert r'''you may still <a href="http://0.0.0.0:8080/recipes/baz%20%22bar%22%20foo/tiddlers">browse''' in string
def test_html_attribute_escape_with_recipe():
tiddler = Tiddler('escape "double" quotes & & in <tiddler> field values')
tiddler.bag = 'foo "bar" baz'
tiddler.recipe = 'baz "bar" foo'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('tiddlywebwiki.serialization', environ)
serializer.object = tiddler
string = serializer.to_string()
assert r'''title="escape "double" quotes & &amp; in <tiddler> field values"''' in string
assert r'''server.title="escape "double" quotes & &amp; in <tiddler> field values"''' in string
assert r'''bag="foo "bar" baz"''' in string
assert r'''recipe="baz "bar" foo"''' in string
assert r'''server.workspace="bags/foo "bar" baz"''' in string
assert r'''modifier="Chris "sensei" Dent"''' in string
assert r'''creator="Chris "sensei" Dent"''' in string
assert r'''tags="foo [[xxx "yyy" zzz]]"''' in string
assert r'''custom="lorem 'ipsum' dolor "sit" amet"''' in string
assert r'''you may still <a href="http://our_test_domain:8001/recipes/baz%20%22bar%22%20foo/tiddlers">browse''' in string
def test_tiddler():
#setup
wikklytextplugins.init({})
store.put(Bag("bar"))
store.put(Bag("foo"))
recipe = Recipe("foo")
recipe.set_recipe([['foo', ''], ['bar', '']])
store.put(recipe)
tid = Tiddler("jon robson", "bar")
tid.text = "My name is Jon Robson"
store.put(tid)
tid = Tiddler("a tiddler in foo", "foo")
tid.text = "rainbow [[title]]"
store.put(tid)
tid = Tiddler("foo", "bar")
tid.tags = ['ab', 'cd', 'ef gh']
#run and verify
out = macros.tiddler(WikiContext(tid, config), WikiArgument("jon robson"))
assert 'My name is Jon Robson' in out
out = macros.tiddler(WikiContext(tid, config),
WikiArgument("a tiddler in foo"))
assert out == "" #we are viewing from bag bar not foo.
tid.recipe = "foo"
out = macros.tiddler(WikiContext(tid, config),
WikiArgument("a tiddler in foo"))
assert "rainbow" in out #we are viewing from recipe now
assert "title</a>" in out
#teardown
store.delete(Bag("foo"))
store.delete(Bag("bar"))
store.delete(Recipe("foo"))
def test_tiddler():
#setup
wikklytextplugins.init({})
store.put(Bag("bar"))
store.put(Bag("foo"))
recipe = Recipe("foo")
recipe.set_recipe([['foo',''],['bar','']])
store.put(recipe)
tid = Tiddler("jon robson","bar")
tid.text = "My name is Jon Robson"
store.put(tid)
tid = Tiddler("a tiddler in foo","foo")
tid.text = "rainbow [[title]]"
store.put(tid)
tid = Tiddler("foo","bar")
tid.tags = ['ab', 'cd','ef gh']
#run and verify
out = macros.tiddler(WikiContext(tid,config),WikiArgument("jon robson"))
assert 'My name is Jon Robson' in out
out = macros.tiddler(WikiContext(tid,config),WikiArgument("a tiddler in foo"))
assert out == "" #we are viewing from bag bar not foo.
tid.recipe = "foo"
out = macros.tiddler(WikiContext(tid,config),WikiArgument("a tiddler in foo"))
assert "rainbow" in out #we are viewing from recipe now
assert "title</a>" in out
#teardown
store.delete(Bag("foo"))
store.delete(Bag("bar"))
store.delete(Recipe("foo"))
def getBeefcakedTiddler(environ,start_response):
store = environ['tiddlyweb.store']
start_response('200 OK', [
('Content-Type', 'text/html; charset=utf-8')
])
tiddler_name = environ['wsgiorg.routing_args'][1]['tiddler']
tiddler =Tiddler(tiddler_name)
try:
initial_recipe_name = environ['wsgiorg.routing_args'][1]['recipe']
recipe_name = "beefcaked_"+initial_recipe_name
environ['selector.vars']['recipe_name'] = environ['wsgiorg.routing_args'][1]['recipe']
recipe = store.get(Recipe(recipe_name))
bag = control.determine_tiddler_bag_from_recipe(recipe, Tiddler(tiddler_name))
bag_name = bag.name
tiddler.recipe = initial_recipe_name
except KeyError:
bag_name = environ['wsgiorg.routing_args'][1]['bag']
environ['selector.vars']['bag_name'] = bag_name
tiddler.bag = bag_name
s = Serialization(environ)
return s.tiddler_as(store.get(tiddler))
def _process_for_transclusion(output, tiddler, environ):
"""
Process the output for transclusions.
"""
if 'twikified.seen_titles' in environ:
seen_titles = environ['twikified.seen_titles']
else:
seen_titles = []
parser = html5lib.HTMLParser(
tree=html5lib.treebuilders.getTreeBuilder("dom"))
output = output.decode('utf-8', 'replace')
try:
dom = parser.parse('<div>' + output + '</div>')
spans = dom.getElementsByTagName('span')
for span in spans:
for attribute in span.attributes.keys():
if attribute == 'tiddler':
attr = span.attributes[attribute]
interior_title = attr.value
try:
span_class = span.attributes['class'].value
if span_class.startswith('@'):
interior_recipe = span_class[1:] + '_public'
else:
interior_recipe = ''
except KeyError:
interior_recipe = ''
title_semaphore = '%s:%s' % (interior_title,
interior_recipe)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_recipe:
recipe = store.get(Recipe(interior_recipe))
interior_tiddler.recipe = interior_recipe
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
interior_tiddler.bag = tiddler.bag
interior_bag = store.get(Bag(interior_tiddler.bag))
interior_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler = store.get(interior_tiddler)
except (StoreError, PermissionsError):
continue
if renderable(interior_tiddler, environ):
environ['twikified.seen_titles'] = seen_titles
interior_content = render_wikitext(
interior_tiddler, environ)
interior_dom = parser.parse('<div>' +
interior_content +
'</div>')
span.appendChild(
interior_dom.getElementsByTagName('div')[0])
output = dom.getElementsByTagName('div')[0].toxml()
except ExpatError, exc:
# If expat couldn't process the output, we need to make it
# unicode as what came over the socket was utf-8 but expat
# needs that in the first place.
LOGGER.warn('got expat error: %s:%s %s', tiddler.bag, tiddler.title,
exc)
output = output.decode('utf-8', 'replace')
# continue over entries in database from previous format
for link in links:
if is_link(link): # external link
continue
else:
container, title = link.split(':', 1)
if not title: # plain space link
continue
elif title:
if container != bag_name:
if container.endswith('_public'):
try:
recipe = Recipe(container)
recipe = store.get(recipe)
tiddler = Tiddler(title)
tiddler.recipe = container
bag = determine_bag_from_recipe(recipe, tiddler,
environ)
tiddler.bag = bag.name
except StoreError, exc:
tiddler = Tiddler(title, bag_name)
tiddler.recipe = container
else:
tiddler = Tiddler(title, container)
else:
tiddler = Tiddler(title, bag_name)
try:
tiddler = store.get(tiddler)
except StoreError:
tiddler.store = store
if _is_readable(environ, tiddler):
except KeyError:
interior_bag = ''
title_semaphore = '%s:%s' % (interior_title, interior_bag)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_bag:
public_bag = store.get(Bag(interior_bag))
public_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler.bag = interior_bag
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = determine_bag_from_recipe(
recipe, interior_tiddler, environ).name
else:
interior_tiddler.bag = tiddler.bag
interior_tiddler = store.get(interior_tiddler)
except (StoreError, PermissionsError):
continue
if renderable(interior_tiddler, environ):
interior_content = render(interior_tiddler, environ,
seen_titles)
interior_dom = parser.parse('<div>' +
interior_content
+ '</div>')
span.appendChild(interior_dom.getElementsByTagName('div')[0])
def _process_for_transclusion(output, tiddler, environ):
"""
Process the output for transclusions.
"""
if 'twikified.seen_titles' in environ:
seen_titles = environ['twikified.seen_titles']
else:
seen_titles = []
parser = html5lib.HTMLParser(
tree=html5lib.treebuilders.getTreeBuilder("dom"))
output = output.decode('utf-8', 'replace')
try:
dom = parser.parse('<div>' + output + '</div>')
spans = dom.getElementsByTagName('span')
for span in spans:
for attribute in span.attributes.keys():
if attribute == 'tiddler':
attr = span.attributes[attribute]
interior_title = attr.value
try:
span_class = span.attributes['class'].value
if span_class.startswith('@'):
interior_recipe = span_class[1:] + '_public'
else:
interior_recipe = ''
except KeyError:
interior_recipe = ''
title_semaphore = '%s:%s' % (interior_title,
interior_recipe)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_recipe:
recipe = store.get(Recipe(interior_recipe))
interior_tiddler.recipe = interior_recipe
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
interior_tiddler.bag = tiddler.bag
interior_bag = store.get(Bag(interior_tiddler.bag))
interior_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler = store.get(interior_tiddler)
except (StoreError, PermissionsError):
continue
if renderable(interior_tiddler, environ):
environ['twikified.seen_titles'] = seen_titles
interior_content = render_wikitext(
interior_tiddler, environ)
interior_dom = parser.parse('<div>' +
interior_content
+ '</div>')
span.appendChild(
interior_dom.getElementsByTagName(
'div')[0])
output = dom.getElementsByTagName('div')[0].toxml()
except ExpatError, exc:
# If expat couldn't process the output, we need to make it
# unicode as what came over the socket was utf-8 but expat
# needs that in the first place.
LOGGER.warn('got expat error: %s:%s %s',
tiddler.bag, tiddler.title, exc)
output = output.decode('utf-8', 'replace')
except KeyError:
interior_bag = ''
title_semaphore = '%s:%s' % (interior_title, interior_bag)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_bag:
public_bag = store.get(Bag(interior_bag))
public_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler.bag = interior_bag
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = determine_bag_from_recipe(
recipe, interior_tiddler, environ).name
else:
interior_tiddler.bag = tiddler.bag
interior_tiddler = store.get(interior_tiddler)
except (StoreError, PermissionsError):
continue
if renderable(interior_tiddler, environ):
interior_content = render(interior_tiddler,
environ, seen_titles)
interior_dom = parser.parse('<div>' +
interior_content +
'</div>')
span.appendChild(
