def test_generated_html_with_revbag():
html_serializer = Serializer("html")
bagfour.revbag = True
string = html_serializer.list_tiddlers(bagfour)
assert expected_html_revbag_string in string
bagfour.revbag = False
def test_generated_string():
serializer = Serializer('text')
string = ''.join(serializer.list_tiddlers(tiddler_collection))
assert 'TiddlerOne' in string
assert 'TiddlerTwo' in string
assert 'TiddlerThree' in string
def test_generated_html_with_revbag():
html_serializer = Serializer("html")
bagfour.revbag = True
string = html_serializer.list_tiddlers(bagfour)
assert '<li><a href="/bags/bagfour/tiddlers/TiddlerTwo/revisions/0">TiddlerTwo:0</a></li>' in string
bagfour.revbag = False
def send_tiddlers(environ, start_response, bag):
"""
Output the tiddlers contained in the provided
bag in a Negotiated representation. Often, but
not always, a wiki.
"""
last_modified = None
etag = None
bags_tiddlers = bag.list_tiddlers()
download = environ['tiddlyweb.query'].get('download', [None])[0]
if bags_tiddlers:
last_modified, etag = _validate_tiddler_list(environ, bags_tiddlers)
else:
raise HTTP404('No tiddlers in container')
serialize_type, mime_type = get_serialize_type(environ)
serializer = Serializer(serialize_type, environ)
content_header = ('Content-Type', mime_type)
cache_header = ('Cache-Control', 'no-cache')
response = [content_header, cache_header]
if serialize_type == 'wiki':
if download:
response.append(('Content-Disposition',
'attachment; filename="%s"' % download))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
output = serializer.list_tiddlers(bag)
start_response("200 OK", response)
return [output]
def test_generated_string():
serializer = Serializer('text')
string = ''.join(serializer.list_tiddlers(tiddler_collection))
assert 'TiddlerOne' in string
assert 'TiddlerTwo' in string
assert 'TiddlerThree' in string
def list_tiddlers(self, bag):
try:
qs = self.environ["tiddlyweb.query"]["j"][0]
js = True
except KeyError:
js = False
if not js:
try:
host = "http://"+self.environ['HTTP_HOST']
refer = self.environ["HTTP_REFERER"]
if refer == host or refer == "%s%s"%(host,self.environ['REQUEST_URI']):
js = True
else:
js = False
except KeyError:
js = False
if js:
s = Serializer("tiddlywebwiki.serialization",self.environ)
return s.list_tiddlers(bag)
else:
if bag.tiddlers[0] and bag.tiddlers[0].recipe:
try:
beefcaked_recipe ="beefcaked_"+bag.tiddlers[0].recipe
store = self.environ['tiddlyweb.store']
recipe = store.get(Recipe(beefcaked_recipe))
return generate_index(self.environ,self.get_tiddlers_bag_for_recipe(beefcaked_recipe))
except NoRecipeError:
return generate_index(self.environ,bag)
else:
return generate_index(self.environ,bag)
def test_generated_html_with_prefix():
new_config = config.copy()
new_config["server_prefix"] = "/salacious"
environ = {"tiddlyweb.config": new_config}
html_serializer = Serializer("html", environ)
string = html_serializer.list_tiddlers(bagfour)
assert '<li><a href="/salacious/bags/bagfour/tiddlers/TiddlerOne">TiddlerOne</a></li>' in string
def test_generated_html_with_prefix():
new_config = config.copy()
new_config["server_prefix"] = "/salacious"
environ = {"tiddlyweb.config": new_config}
html_serializer = Serializer("html", environ)
string = html_serializer.list_tiddlers(bagfour)
assert prefix_expected_html_string in string
def test_generated_html_with_prefix():
new_config = config.copy()
new_config['server_prefix'] = '/salacious'
environ = {'tiddlyweb.config': new_config}
html_serializer = Serializer('html', environ)
string = html_serializer.list_tiddlers(tiddler_collection)
assert '<li><a href="/salacious/bags/bagfour/tiddlers/TiddlerOne">TiddlerOne</a></li>' in string
def test_tiddlers_to_csv():
expected_string = 'title,text,modified,created,modifier,creator,revision,bag,tags,one,two,three\r\nfoo,Hello There!,20120202000000,20120202000000,bob,bob,0,,foo bar baz,1,,\r\nbar,Lorem Ipsum Dolor Sit \xe2\x99\xa5,20120202000000,20120202000000,alice,alice,0,,[[foo baz]] biz bix,,2,\r\nbaz,Goodbye,20120202000000,20120202000000,Steve,Steve,0,,,1,,3\r\nbiz,"Some text, here",20120202000000,20120202000000,Bill,Bill,0,,foo biz bix,1,,\r\n'
serializer = Serializer('tiddlywebplugins.csv', environ=environ)
string = serializer.list_tiddlers(tiddlers)
output = string.split('\r\n')
expected_output = expected_string.split('\r\n')
for i in range(0,len(output)):
assert output[i] == expected_output[i]
def test_generated_wiki():
environ = {"tiddlyweb.config": config}
wiki_serializer = Serializer("wiki", environ)
# work around a limitation in the serializations
# when store is not set, we assume the bag has not been reified
string = wiki_serializer.list_tiddlers(bagfour)
assert '<div title="TiddlerOne' in string
assert '<div title="TiddlerTwo' in string
assert '<div title="TiddlerThree' in string
def test_generated_html_with_revbag():
html_serializer = Serializer('html')
tiddler_collection.is_revisions = True
string = html_serializer.list_tiddlers(tiddler_collection)
assert ('<li><a href="/bags/bagfour/tiddlers/TiddlerTwo/revisions/1">TiddlerTwo:1</a></li>'
in string or
'<li><a href="/bags/bagfour/tiddlers/TiddlerTwo/revisions/0">TiddlerTwo:0</a></li>'
in string)
tiddler_collection.is_revisions = False
def test_generated_string_with_revbag():
serializer = Serializer('text')
tiddler_collection.is_revisions = True
string = ''.join(serializer.list_tiddlers(tiddler_collection))
# XXX: Check for presense of ':'. The value of the revision
# changes based on test ordering.
assert 'TiddlerOne:' in string
assert 'TiddlerTwo:' in string
assert 'TiddlerThree:' in string
tiddler_collection.is_revisions = False
def test_generated_string_with_revbag():
serializer = Serializer('text')
tiddler_collection.is_revisions = True
string = ''.join(serializer.list_tiddlers(tiddler_collection))
# XXX: Check for presense of ':'. The value of the revision
# changes based on test ordering.
assert 'TiddlerOne:' in string
assert 'TiddlerTwo:' in string
assert 'TiddlerThree:' in string
tiddler_collection.is_revisions = False
def send_tiddlers(environ, start_response, tiddlers=None):
"""
Output the :py:class:`tiddlers <tiddlyweb.model.tiddler.Tiddler>`
contained in the provided :py:class:`Tiddlers collection
<tiddlyweb.model.collections.Tiddlers>` in a :py:mod:`Negotiated
<tiddlyweb.web.negotiate>` representation.
"""
download = environ['tiddlyweb.query'].get('download', [None])[0]
filters = environ['tiddlyweb.filters']
store = environ['tiddlyweb.store']
if tiddlers.store is None and not filters:
LOGGER.warn('Incoming tiddlers no store set %s', inspect.stack()[1])
if filters:
candidate_tiddlers = _filter_tiddlers(filters, store, tiddlers)
else:
candidate_tiddlers = tiddlers
last_modified, etag = _validate_tiddler_list(environ, candidate_tiddlers)
serialize_type, mime_type = get_serialize_type(environ, collection=True)
response = [('Content-Type', mime_type),
('Cache-Control', 'no-cache'),
('Vary', 'Accept')]
if download:
response.append(('Content-Disposition',
'attachment; filename="%s"' % encode_name(download)))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
try:
serializer = Serializer(serialize_type, environ)
output = serializer.list_tiddlers(candidate_tiddlers)
except NoSerializationError as exc:
raise HTTP415('Content type not supported: %s:%s, %s' %
(serialize_type, mime_type, exc))
except FilterError as exc: # serializations may filter tildders
raise HTTP400('malformed filter or tiddler during filtering: %s' % exc)
start_response("200 OK", response)
if isinstance(output, basestring):
return [output]
else:
return output
def send_tiddlers(environ, start_response, tiddlers=None):
"""
Output the :py:class:`tiddlers <tiddlyweb.model.tiddler.Tiddler>`
contained in the provided :py:class:`Tiddlers collection
<tiddlyweb.model.collections.Tiddlers>` in a :py:mod:`Negotiated
<tiddlyweb.web.negotiate>` representation.
"""
download = environ['tiddlyweb.query'].get('download', [None])[0]
filters = environ['tiddlyweb.filters']
store = environ['tiddlyweb.store']
if tiddlers.store is None and not filters:
LOGGER.warn('Incoming tiddlers no store set %s', inspect.stack()[1])
if filters:
candidate_tiddlers = _filter_tiddlers(filters, store, tiddlers)
else:
candidate_tiddlers = tiddlers
last_modified, etag = _validate_tiddler_list(environ, candidate_tiddlers)
serialize_type, mime_type = get_serialize_type(environ, collection=True)
response = [('Content-Type', mime_type), ('Cache-Control', 'no-cache'),
('Vary', 'Accept')]
if download:
response.append(('Content-Disposition',
'attachment; filename="%s"' % encode_name(download)))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
try:
serializer = Serializer(serialize_type, environ)
output = serializer.list_tiddlers(candidate_tiddlers)
except NoSerializationError as exc:
raise HTTP415('Content type not supported: %s:%s, %s' %
(serialize_type, mime_type, exc))
except FilterError as exc: # serializations may filter tildders
raise HTTP400('malformed filter or tiddler during filtering: %s' % exc)
start_response("200 OK", response)
if isinstance(output, basestring):
return [output]
else:
return output
def tiddler_as(self, tiddler):
store = self.environ['tiddlyweb.store']
try:
qs = self.environ["tiddlyweb.query"]["j"][0]
js = True
except KeyError:
js = False
if not js:
try:
host = "http://"+self.environ['HTTP_HOST']
refer = self.environ["HTTP_REFERER"]
if refer == host or refer == "%s%s"%(host,self.environ['REQUEST_URI']):
js = True
else:
js = False
except KeyError:
js = False
if js:
s = Serializer("tiddlywebwiki.serialization",self.environ)
#s.object = tiddler
if tiddler.recipe:
recipe_name = tiddler.recipe
tempbag = self.get_tiddlers_bag_for_recipe(recipe_name)
defaultTiddler = Tiddler("DefaultTiddlers")
defaultTiddler.text = "[["+tiddler.title +"]]"
tempbag.add_tiddlers([defaultTiddler])
return s.list_tiddlers(tempbag)
else:
tempbag = Bag(tiddler.bag)
tempbag = store.get(tempbag)
return s.list_tiddlers(tempbag)
else:
return generate_without_js(self.environ,tiddler.title)
def test_content_type():
bag = Bag('holder')
bag = store.get(bag)
tiddlers = Tiddlers(store=store)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
serializer = Serializer('tiddlywebwiki.serialization', {'tiddlyweb.config': config})
output = ''.join(serializer.list_tiddlers(tiddlers))
# we are expecting an img link to the image tiddler
assert 'server.content-type="image/png"' in output
# but we want just an html anchor link to the zero
assert 'server.content-type="application/octet-stream"' in output
assert 'server.content-type="text/html"' in output
def test_content_type():
bag = Bag('holder')
bag = store.get(bag)
tiddlers = Tiddlers(store=store)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
serializer = Serializer('tiddlywebwiki.serialization',
{'tiddlyweb.config': config})
output = ''.join(serializer.list_tiddlers(tiddlers))
# we are expecting an img link to the image tiddler
assert 'server.content-type="image/png"' in output
# but we want just an html anchor link to the zero
assert 'server.content-type="application/octet-stream"' in output
assert 'server.content-type="text/html"' in output
def send_tiddlers(environ, start_response, tiddlers=None):
"""
Output the tiddlers contained in the provided
Tiddlers collection in a Negotiated representation.
Often, but not always, a wiki.
"""
download = environ['tiddlyweb.query'].get('download', [None])[0]
filters = environ['tiddlyweb.filters']
store = environ['tiddlyweb.store']
if tiddlers.store is None and not filters:
LOGGER.warn('Incoming tiddlers no store set %s', inspect.stack()[1])
if filters:
candidate_tiddlers = _filter_tiddlers(filters, store, tiddlers)
else:
candidate_tiddlers = tiddlers
last_modified, etag = _validate_tiddler_list(environ, candidate_tiddlers)
serialize_type, mime_type = get_serialize_type(environ, collection=True)
response = [('Content-Type', mime_type),
('Cache-Control', 'no-cache'),
('Vary', 'Accept')]
if download:
response.append(('Content-Disposition',
'attachment; filename="%s"' % download.encode('utf-8')))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
try:
serializer = Serializer(serialize_type, environ)
output = serializer.list_tiddlers(candidate_tiddlers)
except NoSerializationError, exc:
raise HTTP415('Content type not supported: %s:%s, %s' %
(serialize_type, mime_type, exc))
def pass_through_external_serializer(self, name, tiddlers):
"""
The specified template has not been found, so assume it
is a different serializer that has ended up here due to
content-type confusion, or has been specified as a sub-
template within another template.
Passes the serializer name into the Serializer base class
so that it is rendered by the correct serializer and
returns the output.
"""
serializer_module = self.environ['tiddlyweb.config']['serializers'].get(self.environ['tiddlyweb.config']['extension_types'].get(name))[0]
serializer = Serializer(serializer_module, self.environ)
if (type(tiddlers) != Tiddler):
bag = Bag('tmpBag', tmpbag=True)
bag.add_tiddlers(tiddlers)
try:
serializer.object = tiddlers
return serializer.to_string()
except AttributeError:
return serializer.list_tiddlers(bag)
def test_content_type():
bag = Bag('holder')
bag = store.get(bag)
tiddlers = Tiddlers(store=store)
# duplicate what the handler would do
tiddlers.link = bag_url({'tiddlyweb.config': config}, bag,
full=False) + '/tiddlers'
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
serializer = Serializer('tiddlywebwiki.serialization',
{'tiddlyweb.config': config})
output = ''.join(serializer.list_tiddlers(tiddlers))
# we are expecting an img link to the image tiddler
assert 'server.content-type="image/png"' in output
# but we want just an html anchor link to the zero
assert 'server.content-type="application/octet-stream"' in output
assert 'server.content-type="text/html"' in output
assert ('you may still <a href="/bags/holder/tiddlers">browse' in output)
def pass_through_external_serializer(self, name, tiddlers):
"""
The specified template has not been found, so assume it
is a different serializer that has ended up here due to
content-type confusion, or has been specified as a sub-
template within another template.
Passes the serializer name into the Serializer base class
so that it is rendered by the correct serializer and
returns the output.
"""
serializer_module = self.environ['tiddlyweb.config']['serializers'].get(
self.environ['tiddlyweb.config']['extension_types'].get(name))[0]
serializer = Serializer(serializer_module, self.environ)
if (type(tiddlers) != Tiddler):
bag = Bag('tmpBag', tmpbag=True)
bag.add_tiddlers(tiddlers)
try:
serializer.object = tiddlers
return serializer.to_string()
except AttributeError:
return serializer.list_tiddlers(bag)
def profile_listing_tiddlers():
store = Store('text', environ=environ)
bag = Bag('profiler')
store.get(bag)
print 'filter', time()
#filter_string = '[sort[modified]]'
filter_string = ''
tiddlers = control.filter_tiddlers_from_bag(bag, filter_string)
print 'tmp bag', time()
tmp_bag = Bag('tmp_bag', tmpbag=True)
tmp_bag.add_tiddlers(tiddlers)
#print 'output', time()
#print ['.' for tiddler in control.get_tiddlers_from_bag(tmp_bag)]
print 'serializer', time()
serializer = Serializer('wiki', environ)
print 'wikify', time()
output = serializer.list_tiddlers(tmp_bag)
print 'done', time()
vary_header = ('Vary', 'Accept')
response = [content_header, cache_header, vary_header]
if download:
response.append(('Content-Disposition',
'attachment; filename="%s"' % download.encode('utf-8')))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
try:
serializer = Serializer(serialize_type, environ)
output = serializer.list_tiddlers(candidate_tiddlers)
except NoSerializationError, exc:
raise HTTP415('Content type not supported: %s:%s, %s' %
(serialize_type, mime_type, exc))
except FilterError, exc: # serializations may filter tildders
raise HTTP400('malformed filter or tiddler during filtering: %s' % exc)
start_response("200 OK", response)
if isinstance(output, basestring):
return [output]
else:
return output
def _validate_tiddler_list(environ, tiddlers):
response = [content_header, cache_header, vary_header]
if download:
response.append(
('Content-Disposition',
'attachment; filename="%s"' % download.encode('utf-8')))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
try:
serializer = Serializer(serialize_type, environ)
output = serializer.list_tiddlers(candidate_tiddlers)
except NoSerializationError, exc:
raise HTTP415('Content type not supported: %s:%s, %s' %
(serialize_type, mime_type, exc))
except FilterError, exc: # serializations may filter tildders
raise HTTP400('malformed filter or tiddler during filtering: %s' % exc)
start_response("200 OK", response)
if isinstance(output, basestring):
return [output]
else:
return output
def _validate_tiddler_list(environ, tiddlers):
def test_generated_html():
html_serializer = Serializer("html")
string = html_serializer.list_tiddlers(bagfour)
assert expected_html_string in string
def test_generated_html():
html_serializer = Serializer('html')
string = html_serializer.list_tiddlers(tiddler_collection)
assert (
'<li><a href="/bags/bagfour/tiddlers/TiddlerOne">TiddlerOne</a></li>'
in string)
content_header = ("Content-Type", mime_type)
cache_header = ("Cache-Control", "no-cache")
vary_header = ("Vary", "Accept")
response = [content_header, cache_header, vary_header]
if download:
response.append(("Content-Disposition", 'attachment; filename="%s"' % download.encode("utf-8")))
if last_modified:
response.append(last_modified)
if etag:
response.append(etag)
serializer = Serializer(serialize_type, environ)
try:
output = serializer.list_tiddlers(tmp_bag)
except NoSerializationError, exc:
raise HTTP415("Content type not supported: %s:%s, %s" % (serialize_type, mime_type, exc))
start_response("200 OK", response)
return [output]
def _validate_tiddler_list(environ, bag):
"""
Calculate the Last modified and ETag for
the tiddlers in bag. If the ETag matches an
incoming If-None-Match, then raise a 304 and
don't send the tiddler content. If the modified
string in an If-Modified-Since is newer than the
last-modified on the tiddlers, raise 304.
def test_generated_html():
html_serializer = Serializer('html')
string = html_serializer.list_tiddlers(tiddler_collection)
assert '<li><a href="/bags/bagfour/tiddlers/TiddlerOne">TiddlerOne</a></li>' in string
def test_generated_html():
html_serializer = Serializer("html")
string = html_serializer.list_tiddlers(bagfour)
assert '<li><a href="/bags/bagfour/tiddlers/TiddlerOne">TiddlerOne</a></li>' in string
