def tiddler_get(self, tiddler):
if tiddler.revision:
url = self.revision_url % (encode_name(tiddler.bag), encode_name(tiddler.title), tiddler.revision)
else:
url = self.tiddler_url % (encode_name(tiddler.bag), encode_name(tiddler.title))
self.doit(url, tiddler, self._any_get, NoTiddlerError)
return tiddler
def recipe_as(self, recipe):
"""
Recipe as html.
"""
self.environ['tiddlyweb.title'] = 'Recipe %s' % recipe.name
lines = []
for bag, filter_string in recipe.get_recipe():
line = '<li><a href="'
if not isinstance(bag, basestring):
bag = bag.name
line += '%s/bags/%s/tiddlers' % (self._server_prefix(),
encode_name(bag))
if filter_string:
line += '?%s' % urllib.quote(filter_string.encode('utf-8'),
safe=':=;')
line += '">bag: %s filter:%s</a></li>' % (bag, filter_string)
lines.append(line)
output = "\n".join(lines)
title = 'Bags in Recipe %s' % recipe.name
tiddler_link = '%s/tiddlers' % encode_name(recipe.name)
return """
<div class="tiddlerslink"><a href="%s">Tiddlers in Recipe</a></div>
<div id="recipedesc" class="description">%s</div>
<ul id="recipe" class="listing">
%s
</ul>
""" % (tiddler_link, recipe.desc, output)
def send_entity(environ, start_response, entity):
"""
Send a bag or recipe out HTTP, first serializing to
the correct type.
"""
username = environ['tiddlyweb.usersign']['name']
try:
serialize_type, mime_type = get_serialize_type(environ)
serializer = Serializer(serialize_type, environ)
serializer.object = entity
content = serializer.to_string()
except NoSerializationError:
raise HTTP415('Content type %s not supported' % mime_type)
etag_string = '"%s"' % (sha(_entity_etag(entity) +
encode_name(username) + encode_name(mime_type)).hexdigest())
start_response("200 OK",
[('Content-Type', mime_type),
('ETag', etag_string),
('Vary', 'Accept')])
if isinstance(content, basestring):
return [content]
else:
return content
def _tiddler_to_wikklyhtml(self, tiddler):
"""
Render tiddler.text to HTML using wikklytext.
"""
server_prefix = self._server_prefix()
if tiddler.recipe:
list_link = 'recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = 'bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
from tiddlyweb.wikklyhtml import wikitext_to_wikklyhtml
html = wikitext_to_wikklyhtml('%s/' % server_prefix,
list_link, tiddler.text)
# Have to be very careful in the following about UTF-8 handling
# because wikklytext wants to encode its output.
self.environ['tiddlyweb.title'] = tiddler.title
return """
<div class="tiddlerslink"><a href="%s" title="tiddler list">%s</a></div>
%s
%s
</div>
""" % ('%s/%s' % (server_prefix, list_link),
list_title.encode('utf-8'),
self._tiddler_div(tiddler).encode('utf-8'),
html)
def recipe_as(self, recipe):
"""
:py:class:`Recipe <tiddlyweb.model.recipe.Recipe>` as HTML,
including a link to the tiddlers within.
"""
self.environ['tiddlyweb.title'] = 'Recipe %s' % recipe.name
lines = []
for bag, filter_string in recipe.get_recipe():
line = '<li><a href="'
line += '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(bag))
if filter_string:
line += '?%s' % quote(
filter_string.encode('utf-8'), safe=':=;')
line += '">bag: %s filter:%s</a></li>' % (bag, filter_string)
lines.append(line)
output = "\n".join(lines)
tiddler_link = '%s/tiddlers' % encode_name(recipe.name)
return """
%s
<div class="tiddlerslink"><a href="%s">Tiddlers in Recipe</a></div>
<div id="recipedesc" class="description">%s</div>
<ul id="recipe" class="listing">
%s
</ul>
%s
""" % (self._header(), tiddler_link, recipe.desc, output, self._footer())
def tiddler_as(self, tiddler):
"""
Transform the provided tiddler into an HTML
representation of the tiddler packaged in a
DIV. Render the content using the render_wikitext
subsystem. Links to the tiddler in the wiki are
provided.
"""
user = self.environ['tiddlyweb.usersign']
store = self.environ['tiddlyweb.store']
if tiddler.recipe:
list_link = '/recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = '/bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
try:
store.get(Bag(tiddler.bag)).policy.allows(user, 'manage')
container_policy = True
except PermissionsError:
container_policy = False
space_link = self._space_link(tiddler)
html = render_wikitext(tiddler, self.environ)
return send_template(self.environ, 'tiddler.html', {
'title': '%s' % tiddler.title,
'tags': tiddler.tags,
'fields': tiddler.fields,
'html': html,
'list_link': list_link,
'list_title': list_title,
'space_link': space_link,
'tiddler': tiddler,
'container_policy': container_policy,
'tiddler_url': tiddler_url(self.environ, tiddler)})
def recipe_as(self, recipe):
"""
:py:class:`Recipe <tiddlyweb.model.recipe.Recipe>` as HTML,
including a link to the tiddlers within.
"""
self.environ['tiddlyweb.title'] = 'Recipe %s' % recipe.name
lines = []
for bag, filter_string in recipe.get_recipe():
line = '<li><a href="'
line += '%s/bags/%s/tiddlers' % (self._server_prefix(),
encode_name(bag))
if filter_string:
line += '?%s' % quote(filter_string.encode('utf-8'),
safe=':=;')
line += '">bag: %s filter:%s</a></li>' % (bag, filter_string)
lines.append(line)
output = "\n".join(lines)
tiddler_link = '%s/tiddlers' % encode_name(recipe.name)
return """
%s
<div class="tiddlerslink"><a href="%s">Tiddlers in Recipe</a></div>
<div id="recipedesc" class="description">%s</div>
<ul id="recipe" class="listing">
%s
</ul>
%s
""" % (self._header(), tiddler_link, recipe.desc, output, self._footer())
def send_entity(environ, start_response, entity):
"""
Send a bag or recipe out HTTP, first serializing to
the correct type.
"""
username = environ['tiddlyweb.usersign']['name']
try:
serialize_type, mime_type = get_serialize_type(environ)
serializer = Serializer(serialize_type, environ)
serializer.object = entity
content = serializer.to_string()
except NoSerializationError:
raise HTTP415('Content type %s not supported' % mime_type)
etag_string = '"%s"' % (sha(
_entity_etag(entity) + encode_name(username) +
encode_name(mime_type)).hexdigest())
start_response("200 OK", [('Content-Type', mime_type),
('ETag', etag_string), ('Vary', 'Accept')])
if isinstance(content, basestring):
return [content]
else:
return content
def tiddler_get(self, tiddler):
if tiddler.revision:
url = self.revision_url % (encode_name(tiddler.bag), encode_name(tiddler.title), tiddler.revision)
else:
url = self.tiddler_url % (encode_name(tiddler.bag), encode_name(tiddler.title))
self.doit(url, tiddler, self._any_get, NoTiddlerError)
return tiddler
def recipe_as(self, recipe):
"""
Recipe as html.
"""
self.environ['tiddlyweb.title'] = 'Recipe %s' % recipe.name
lines = []
for bag, filter_string in recipe.get_recipe():
line = '<li><a href="'
if not isinstance(bag, basestring):
bag = bag.name
line += '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(bag))
if filter_string:
line += '?%s' % urllib.quote(
filter_string.encode('utf-8'), safe=':=;')
line += '">bag: %s filter:%s</a></li>' % (bag, filter_string)
lines.append(line)
output = "\n".join(lines)
title = 'Bags in Recipe %s' % recipe.name
tiddler_link = '%s/tiddlers' % encode_name(recipe.name)
return """
<div class="tiddlerslink"><a href="%s">Tiddlers in Recipe</a></div>
<div id="recipedesc" class="description">%s</div>
<ul id="recipe" class="listing">
%s
</ul>
""" % (tiddler_link, recipe.desc, output)
def _new_tiddler_etag(tiddler):
"""
Calculate the ETag of a tiddler that does not
yet exist. This is a bastardization of ETag handling
but is useful for doing edit contention handling.
"""
return str('"%s/%s/%s"' % (encode_name(tiddler.bag),
encode_name(tiddler.title), '0'))
def _new_tiddler_etag(tiddler):
"""
Calculate the ETag of a tiddler that does not
yet exist. This is a bastardization of ETag handling
but is useful for doing edit contention handling.
"""
return str('"%s/%s/%s"' % (web.encode_name(tiddler.bag),
web.encode_name(tiddler.title), '0'))
def _put_tiddlers_in_tiddlywiki(self, tiddlers, title='TiddlyWeb Loading'):
"""
Take the provided tiddlers and inject them into the base_tiddlywiki,
adjusting content for title, subtite, and the various pre and post
head sections of the file.
"""
if tiddlers[0].recipe:
workspace = '/recipes/%s/tiddlers' % encode_name(tiddlers[0].recipe)
else:
workspace = '/bags/%s/tiddlers' % encode_name(tiddlers[0].bag)
browsable_url = server_base_url(self.environ) + workspace
if len(tiddlers) == 1:
default_tiddler = Tiddler('DefaultTiddlers')
default_tiddler.text = '[[' + tiddlers[0].title + ']]'
tiddlers = [tiddlers[0], default_tiddler]
# figure out the content to be pushed into the
# wiki and calculate the title
lines = ''
candidate_title = None
candidate_subtitle = None
markup_tiddlers = MARKUPS.keys()
found_markup_tiddlers = {}
for tiddler in tiddlers:
lines += self._tiddler_as_div(tiddler)
if tiddler.title == 'SiteTitle':
candidate_title = tiddler.text
if tiddler.title == 'SiteSubtitle':
candidate_subtitle = tiddler.text
if tiddler.title in markup_tiddlers:
found_markup_tiddlers[tiddler.title] = tiddler.text
# Turn the title into HTML and then turn it into
# plain text so it is of a form satisfactory to <title>
title = self._determine_title(title, candidate_title, candidate_subtitle)
title = self._plain_textify_string(title)
# load the wiki
wiki = self._get_wiki()
# put the title in place
wiki = self._inject_title(wiki, title)
wiki = self._replace_chunk(wiki, '\n<noscript>\n', '\n</noscript>\n', self._no_script(browsable_url))
# replace the markup bits
if len(found_markup_tiddlers):
for title in found_markup_tiddlers:
start = '\n<!--%s-START-->\n' % MARKUPS[title]
finish = '\n<!--%s-END-->\n' % MARKUPS[title]
wiki = self._replace_chunk(wiki, start, finish, found_markup_tiddlers[title])
# split the wiki into the before store and after store
# sections, put our content in the middle
tiddlystart, tiddlyfinish = wiki.split(SPLITTER, 2)
return tiddlystart + lines + SPLITTER + tiddlyfinish
def _uri(environ, *segments, **query_params):
server_prefix = environ['tiddlyweb.config'].get('server_prefix', '')
uri = '/'.join([server_prefix] +
[encode_name(segment) for segment in segments])
if query_params:
uri += '?%s' % ';'.join('%s=%s' % (encode_name(key), encode_name(value))
for key, value in query_params.items())
return uri
def list_tiddlers(self, tiddlers):
"""
Yield the provided :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` as HTML.
This is somewhat more complex than the other list methods as
we need to list the tiddler whether it is a revision or not,
if it is in a bag or recipe or if it is a search result.
"""
tiddlers.store = None
title = tiddlers.title
server_prefix = self._server_prefix()
lines = []
container_link = ''
if tiddlers.link:
representation_link = tiddlers.link
elif tiddlers.is_search:
representation_link = '%s/search' % server_prefix
else:
representation_link = ''
for tiddler in tiddlers:
if tiddlers.is_revisions:
line = self._tiddler_revision_info(tiddler)
else:
line = self._tiddler_in_container_info(tiddler)
lines.append(line)
if not tiddlers.is_revisions and not tiddlers.is_search:
if tiddlers.bag:
container_link = ('<div class="baglink">'
'<a href="%s/bags/%s">Bag %s</a></div>'
% (server_prefix, encode_name(tiddlers.bag),
tiddlers.bag))
elif tiddlers.recipe:
container_link = ('<div class="recipelink">'
'<a href="%s/recipes/%s">Recipe %s</a></div>'
% (server_prefix, encode_name(tiddlers.recipe),
tiddlers.recipe))
output = "\n".join(lines)
self.environ['tiddlyweb.title'] = title
return """
%s
%s
%s
<ul id="tiddlers" class="listing">
%s
</ul>
%s
""" % (self._header(),
self._tiddler_list_header(representation_link),
container_link, output, self._footer())
def list_tiddlers(self, tiddlers):
"""
Yield the provided :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` as HTML.
This is somewhat more complex than the other list methods as
we need to list the tiddler whether it is a revision or not,
if it is in a bag or recipe or if it is a search result.
"""
tiddlers.store = None
title = tiddlers.title
server_prefix = self._server_prefix()
lines = []
container_link = ''
if tiddlers.link:
representation_link = tiddlers.link
elif tiddlers.is_search:
representation_link = '%s/search' % server_prefix
else:
representation_link = ''
for tiddler in tiddlers:
if tiddlers.is_revisions:
line = self._tiddler_revision_info(tiddler)
else:
line = self._tiddler_in_container_info(tiddler)
lines.append(line)
if not tiddlers.is_revisions and not tiddlers.is_search:
if tiddlers.bag:
container_link = (
'<div class="baglink">'
'<a href="%s/bags/%s">Bag %s</a></div>' %
(server_prefix, encode_name(tiddlers.bag), tiddlers.bag))
elif tiddlers.recipe:
container_link = (
'<div class="recipelink">'
'<a href="%s/recipes/%s">Recipe %s</a></div>' %
(server_prefix, encode_name(
tiddlers.recipe), tiddlers.recipe))
output = "\n".join(lines)
self.environ['tiddlyweb.title'] = title
return """
%s
%s
%s
<ul id="tiddlers" class="listing">
%s
</ul>
%s
""" % (self._header(), self._tiddler_list_header(representation_link),
container_link, output, self._footer())
def list_tiddler_revisions(self, tiddler):
url = self.revisions_url % (encode_name(tiddler.bag), encode_name(tiddler.title))
response, content = self._request("GET", url)
if self._is_success(response):
revisions = simplejson.loads(content)
revision_ids = [revision["revision"] for revision in revisions]
# revision_ids.reverse()
return revision_ids
else:
# XXX better error handling than this would be nice
raise NoTiddlerError
def list_tiddler_revisions(self, tiddler):
url = self.revisions_url % (encode_name(tiddler.bag), encode_name(tiddler.title))
response, content = self._request('GET', url)
if self._is_success(response):
revisions = simplejson.loads(content)
revision_ids = [revision['revision'] for revision in revisions]
#revision_ids.reverse()
return revision_ids
else:
# XXX better error handling than this would be nice
raise NoTiddlerError
def _tiddler_list_info(self, tiddler):
"""
Get the basic link info needed for listing tiddlers.
"""
if tiddler.recipe:
representation_link = '%s/recipes/%s/tiddlers' % (
self._server_prefix(), encode_name(tiddler.recipe))
else:
representation_link = '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(tiddler.bag))
return representation_link
def _tiddler_list_info(self, tiddler):
"""
Get the basic link info needed for listing tiddlers.
"""
if tiddler.recipe:
representation_link = '%s/recipes/%s/tiddlers' % (
self._server_prefix(), encode_name(tiddler.recipe))
else:
representation_link = '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(tiddler.bag))
return representation_link
def tiddler_as(self, tiddler):
"""
Transform the provided tiddler into an HTML
representation of the tiddler packaged in a
DIV. Render the content using the render_wikitext
subsystem. Links to the tiddler in the wiki are
provided.
"""
user = self.environ['tiddlyweb.usersign']
store = self.environ['tiddlyweb.store']
if tiddler.recipe:
list_link = '/recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = '/bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
try:
store.get(Bag(tiddler.bag)).policy.allows(user, 'manage')
container_policy = True
except PermissionsError:
container_policy = False
if not self.environ['tiddlyweb.space_settings'].get('index', None):
space_link = self._space_link(tiddler)
else:
space_link = ''
try:
modifier_link = space_uri(self.environ, tiddler.modifier)
except AttributeError:
modifier_link = ""
try:
creator_link = space_uri(self.environ, tiddler.creator)
except AttributeError:
creator_link = ""
html = render_wikitext(tiddler, self.environ)
return send_template(
self.environ, 'tiddler.html', {
'meta_keywords': ', '.join(tiddler.tags),
'meta_description': tiddler.title,
'title': '%s' % tiddler.title,
'tags': tiddler.tags,
'modifier_link': modifier_link,
'creator_link': creator_link,
'fields': tiddler.fields,
'html': html,
'list_link': list_link,
'list_title': list_title,
'space_link': space_link,
'tiddler': tiddler,
'container_policy': container_policy,
'tiddler_url': tiddler_url(self.environ, tiddler)
})
def get_auth(username, password):
response, _ = http.request(
"http://0.0.0.0:8080/challenge/cookie_form",
body="user=%s&password=%s" % (encode_name(username), encode_name(password)),
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
assert response.previous["status"] == "303"
user_cookie = response.previous["set-cookie"]
cookie = Cookie.SimpleCookie()
cookie.load(user_cookie)
return cookie["tiddlyweb_user"].value
def _tiddler_in_container_info(self, tiddler):
"""
Get the info for a non-revision tiddler in a list.
"""
if tiddler.recipe:
base = 'recipes'
container = tiddler.recipe
else:
base = 'bags'
container = tiddler.bag
return '<li><a href="%s/%s/%s/tiddlers/%s">%s</a></li>' % (
self._server_prefix(), base, encode_name(container),
encode_name(tiddler.title), tiddler.title.replace(
' ', ' ', 1))
def _tiddler_etag(environ, tiddler):
"""
Calculate the ETAG of a tiddler, based on
bag name, tiddler title and revision.
"""
try:
mime_type = web.get_serialize_type(environ)[1]
mime_type = mime_type.split(';', 1)[0].strip()
except (TypeError, AttributeError):
mime_type = tiddler.type or ''
username = environ.get('tiddlyweb.usersign', {}).get('name', '')
digest = sha('%s:%s' % (username, mime_type)).hexdigest()
return str('"%s/%s/%s;%s"' % (web.encode_name(tiddler.bag),
web.encode_name(tiddler.title), tiddler.revision, digest))
def tiddler_as(self, tiddler):
"""
Transform the provided tiddler into an HTML
representation of the tiddler packaged in a
DIV. Render the content using the render_wikitext
subsystem. Links to the tiddler in the wiki are
provided.
"""
user = self.environ['tiddlyweb.usersign']
store = self.environ['tiddlyweb.store']
if tiddler.recipe:
list_link = '/recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = '/bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
try:
store.get(Bag(tiddler.bag)).policy.allows(user, 'manage')
container_policy = True
except PermissionsError:
container_policy = False
if not self.environ['tiddlyweb.space_settings'].get('index', None):
space_link = self._space_link(tiddler)
else:
space_link = ''
try:
modifier_link = space_uri(self.environ, tiddler.modifier)
except AttributeError:
modifier_link = ""
try:
creator_link = space_uri(self.environ, tiddler.creator)
except AttributeError:
creator_link = ""
html = render_wikitext(tiddler, self.environ)
return send_template(self.environ, 'tiddler.html', {
'meta_keywords': ', '.join(tiddler.tags),
'meta_description': tiddler.title,
'title': '%s' % tiddler.title,
'tags': tiddler.tags,
'modifier_link': modifier_link,
'creator_link': creator_link,
'fields': tiddler.fields,
'html': html,
'list_link': list_link,
'list_title': list_title,
'space_link': space_link,
'tiddler': tiddler,
'container_policy': container_policy,
'tiddler_url': tiddler_url(self.environ, tiddler)})
def list_tiddlers(self, tiddlers):
"""
List the tiddlers as html.
"""
title = tiddlers.title
server_prefix = self._server_prefix()
lines = []
representation_link = ''
bag_link = ''
for tiddler in tiddlers:
if not representation_link:
representation_link = self._tiddler_list_info(tiddler)
if tiddlers.is_revisions:
line = self._tiddler_revision_info(tiddler)
else:
line = self._tiddler_in_container_info(tiddler)
lines.append(line)
# If we were able to load the tiddler revisions there is at
# least one revision, so tiddler.title is defined here.
if tiddlers.is_revisions:
representation_link += '/%s/revisions' % encode_name(
tiddler.title)
if tiddlers.is_search:
representation_link = '%s/search' % server_prefix
try:
routing_args = self.environ.get('wsgiorg.routing_args')[1]
except (TypeError, IndexError, KeyError):
routing_args = {}
if 'bag_name' in routing_args and not 'tiddler_name' in routing_args:
bag_name = routing_args['bag_name']
bag_name = urllib.unquote(bag_name)
bag_name = unicode(bag_name, 'utf-8')
bag_link = ('<div class="baglink"><a href="%s/bags/%s">'
'Bag %s</a></div>' % (server_prefix,
encode_name(bag_name), bag_name))
output = "\n".join(lines)
self.environ['tiddlyweb.title'] = title
return """
%s
%s
<ul id="tiddlers" class="listing">
%s
</ul>
""" % (self._tiddler_list_header(representation_link), bag_link, output)
def list_tiddlers(self, tiddlers):
"""
List the tiddlers as html.
"""
tiddlers.store = None
title = tiddlers.title
server_prefix = self._server_prefix()
lines = []
container_link = ''
if tiddlers.link:
representation_link = tiddlers.link
elif tiddlers.is_search:
representation_link = '%s/search' % server_prefix
else:
representation_link = ''
for tiddler in tiddlers:
if tiddlers.is_revisions:
line = self._tiddler_revision_info(tiddler)
else:
line = self._tiddler_in_container_info(tiddler)
lines.append(line)
if not tiddlers.is_revisions and not tiddlers.is_search:
if tiddlers.bag:
container_link = ('<div class="baglink">'
'<a href="%s/bags/%s">Bag %s</a></div>'
% (server_prefix, encode_name(tiddlers.bag),
tiddlers.bag))
elif tiddlers.recipe:
container_link = ('<div class="recipelink">'
'<a href="%s/recipes/%s">Recipe %s</a></div>'
% (server_prefix, encode_name(tiddlers.recipe),
tiddlers.recipe))
output = "\n".join(lines)
self.environ['tiddlyweb.title'] = title
return """
%s
%s
%s
<ul id="tiddlers" class="listing">
%s
</ul>
%s
""" % (self._header(), self._tiddler_list_header(representation_link),
container_link, output, self._footer())
def _create_tiddlers(self, title, tiddlers):
"""
Figure out the content to be pushed into the
wiki and calculate the title.
"""
kept_tiddlers = []
window_title = None
candidate_title = None
candidate_subtitle = None
markup_tiddlers = MARKUPS.keys()
found_markup_tiddlers = {}
tiddler_count = 0
for tiddler in tiddlers:
if not self._lazy_eligible(tiddler):
kept_tiddlers.append(tiddler)
tiddler_title = tiddler.title
if tiddler_title == 'WindowTitle':
window_title = tiddler.text
if tiddler_title == 'SiteTitle':
candidate_title = tiddler.text
if tiddler_title == 'SiteSubtitle':
candidate_subtitle = tiddler.text
if tiddler_title in markup_tiddlers:
found_markup_tiddlers[tiddler_title] = tiddler.text
tiddler_count += 1
if tiddler_count == 1:
default_tiddler = Tiddler('DefaultTiddlers', '')
default_tiddler.tags = ['excludeLists']
default_tiddler.text = '[[' + tiddler.title + ']]'
kept_tiddlers.append(default_tiddler)
browsable_url = None
try:
if tiddler.recipe:
workspace = ('/recipes/%s/tiddlers'
% encode_name(tiddler.recipe))
else:
workspace = '/bags/%s/tiddlers' % encode_name(tiddler.bag)
browsable_url = server_base_url(self.environ) + workspace
except UnboundLocalError:
pass # tiddler is not set because tiddlers was empty
# Turn the title into HTML and then turn it into
# plain text so it is of a form satisfactory to <title>
title = self._determine_title(title, window_title, candidate_title,
candidate_subtitle)
return browsable_url, kept_tiddlers, title, found_markup_tiddlers
def _tiddler_revision_info(self, tiddler):
"""
Get the individual revision info for listing revisions.
"""
if tiddler.recipe:
base = 'recipes'
container = tiddler.recipe
else:
base = 'bags'
container = tiddler.bag
return ('<li><a href="%s/%s/%s/tiddlers/'
'%s/revisions/%s">%s:%s</a></li>' %
(self._server_prefix(), base, encode_name(container),
encode_name(tiddler.title), tiddler.revision, tiddler.title,
tiddler.revision))
def _tiddler_etag(environ, tiddler):
"""
Calculate the ETAG of a tiddler, based on
bag name, tiddler title and revision.
"""
try:
mime_type = web.get_serialize_type(environ)[1]
mime_type = mime_type.split(';', 1)[0].strip()
except (TypeError, AttributeError):
mime_type = tiddler.type or ''
username = environ.get('tiddlyweb.usersign', {}).get('name', '')
digest = sha('%s:%s' % (username, mime_type)).hexdigest()
return str('"%s/%s/%s;%s"' %
(web.encode_name(tiddler.bag), web.encode_name(
tiddler.title), tiddler.revision, digest))
def render(tiddler, environ):
"""
Render TiddlyWiki wikitext in the provided
tiddler to HTML. The provided path helps
set paths in wikilinks correctly.
"""
server_prefix = environ.get("tiddlyweb.config", {}).get("server_prefix", "")
if tiddler.recipe:
path = "recipes/%s/tiddlers" % encode_name(tiddler.recipe)
elif tiddler.bag:
path = "bags/%s/tiddlers" % encode_name(tiddler.bag)
else:
path = ""
html = wikitext_to_wikklyhtml("%s/" % server_prefix, path, tiddler.text, environ)
return unicode(html, "utf-8")
def list_tiddlers(self, tiddlers):
"""
List the tiddlers as html.
"""
title = tiddlers.title
server_prefix = self._server_prefix()
lines = []
representation_link = ''
bag_link = ''
for tiddler in tiddlers:
if not representation_link:
representation_link = self._tiddler_list_info(tiddler)
if tiddlers.is_revisions:
line = self._tiddler_revision_info(tiddler)
else:
line = self._tiddler_in_container_info(tiddler)
lines.append(line)
# If we were able to load the tiddler revisions there is at
# least one revision, so tiddler.title is defined here.
if tiddlers.is_revisions:
representation_link += '/%s/revisions' % encode_name(tiddler.title)
if tiddlers.is_search:
representation_link = '%s/search' % server_prefix
try:
routing_args = self.environ.get('wsgiorg.routing_args')[1]
except (TypeError, IndexError, KeyError):
routing_args = {}
if 'bag_name' in routing_args and not 'tiddler_name' in routing_args:
bag_name = routing_args['bag_name']
bag_name = urllib.unquote(bag_name)
bag_name = unicode(bag_name, 'utf-8')
bag_link = ('<div class="baglink"><a href="%s/bags/%s">'
'Bag %s</a></div>' %
(server_prefix, encode_name(bag_name), bag_name))
output = "\n".join(lines)
self.environ['tiddlyweb.title'] = title
return """
%s
%s
<ul id="tiddlers" class="listing">
%s
</ul>
""" % (self._tiddler_list_header(representation_link), bag_link, output)
def _create_tiddlers(self, title, tiddlers):
"""
Figure out the content to be pushed into the
wiki and calculate the title.
"""
lines = []
window_title = None
candidate_title = None
candidate_subtitle = None
markup_tiddlers = MARKUPS.keys()
found_markup_tiddlers = {}
tiddler_count = 0
for tiddler in tiddlers:
lines.append(self._tiddler_as_div(tiddler))
tiddler_title = tiddler.title
if tiddler_title == 'WindowTitle':
window_title = tiddler.text
if tiddler_title == 'SiteTitle':
candidate_title = tiddler.text
if tiddler_title == 'SiteSubtitle':
candidate_subtitle = tiddler.text
if tiddler_title in markup_tiddlers:
found_markup_tiddlers[tiddler_title] = tiddler.text
tiddler_count += 1
if tiddler_count == 1:
default_tiddler = Tiddler('DefaultTiddlers', '_virtual')
default_tiddler.text = '[[' + tiddler.title + ']]'
lines.append(self._tiddler_as_div(default_tiddler))
browsable_url = None
try:
if tiddler.recipe:
workspace = '/recipes/%s/tiddlers' % encode_name(
tiddler.recipe)
else:
workspace = '/bags/%s/tiddlers' % encode_name(tiddler.bag)
browsable_url = server_base_url(self.environ) + workspace
except UnboundLocalError:
pass # tiddler is not set because tiddlers was empty
# Turn the title into HTML and then turn it into
# plain text so it is of a form satisfactory to <title>
title = self._determine_title(title, window_title, candidate_title,
candidate_subtitle)
title = self._plain_textify_string(title)
return browsable_url, lines, title, found_markup_tiddlers
def test_invalid_cookie():
"""
Test that an invalid/old cookie causes a new cookie to be sent
"""
store = get_store(config)
hostname = "foo.0.0.0.0:8080"
user = User(u"f\u00F6o")
user.set_password("foobar")
store.put(user)
user_cookie = get_auth(u"f\u00F6o", "foobar")
time = datetime.utcnow() - timedelta(hours=3)
time = time.strftime("%Y%m%d%H")
cookie = "csrf_token=%s:%s:%s" % (
time,
encode_name(user.usersign),
sha("%s:%s:%s:%s" % (encode_name(user.usersign), time, hostname, config["secret"])).hexdigest(),
)
response, _ = http.request(
"http://foo.0.0.0.0:8080/status",
method="GET",
headers={"Cookie": 'tiddlyweb_user="******"; %s' % (user_cookie, cookie)},
)
assert "csrf_token" in response["set-cookie"]
cookie = "csrf_token=adiudh9389wefnf98"
response, _ = http.request(
"http://foo.0.0.0.0:8080/status",
method="GET",
headers={"Cookie": 'tiddlyweb_user="******"; %s' % (user_cookie, cookie)},
)
assert "csrf_token" in response["set-cookie"]
user2 = User("bar")
user2.set_password("foobar")
store.put(user2)
user2_cookie = get_auth("bar", "foobar")
response, _ = http.request(
"http://foo.0.0.0.0:8080/status",
method="GET",
headers={"Cookie": 'tiddlyweb_user="******"; %s' % (user2_cookie, cookie)},
)
assert "csrf_token" in response.get("set-cookie", "")
def _recipe_list(self, tiddlers, recipe_name):
representation_link = '%s/recipes/%s/tiddlers' % (
self._server_prefix(), encode_name(recipe_name))
representations = self._tiddler_list_header(representation_link)
user_object = get_user_object(self.environ)
recipe = self.environ['tiddlyweb.store'].get(Recipe(recipe_name))
publicity = ''
try:
recipe.policy.allows(user_object, 'manage')
policy = recipe.policy
if policy.read == [user_object['name']]:
publicity = 'private'
elif policy.read == []:
publicity = 'public'
else:
publicity = 'custom'
delete = True
except (UserRequiredError, ForbiddenError):
policy = None
delete = False
data = {
'title': 'TiddlyHoster Recipe %s' % recipe.name,
'policy': policy,
'publicity': publicity,
'delete': delete,
'recipe': recipe,
'tiddlers': tiddlers,
'representations': representations
}
del self.environ['tiddlyweb.title']
return send_template(self.environ, 'recipelist.html', data)
def _tiddler_in_container_info(self, tiddler):
"""
Get the info for a non-revision tiddler in a list.
"""
if tiddler.recipe:
base = 'recipes'
container = tiddler.recipe
else:
base = 'bags'
container = tiddler.bag
return '<li><a href="%s/%s/%s/tiddlers/%s">%s</a></li>' % (
self._server_prefix(),
base,
encode_name(container),
encode_name(tiddler.title),
tiddler.title.replace(' ', ' ', 1))
def tiddler_as(self, tiddler):
host = '%s/' % server_base_url(self.environ) # TODO: normalize?
title, bag = [encode_name(name) for name in (tiddler.title, tiddler.bag)]
namespaces = {
'': host,
'tweb': 'http://tiddlyweb.com/'
}
subject = ':bags/%s/%s' % (bag, title)
rdf_data = {
subject: {
'rdf:type': ['tweb:tiddler'],
'tweb:bag': [':bags/%s' % bag]
}
}
for field, value in tiddler.fields.items():
try:
prefix, suffix = field.split(':')
# TODO: use collections.defaultdict
rdf_data[subject] = rdf_data.get(subject) or {}
rdf_data[subject][field] = rdf_data[subject].get(field) or []
rdf_data[subject][field].append(value)
except ValueError: # not RDF-related
pass
return to_turtle(namespaces, rdf_data)
def _recipe_list(self, tiddlers, recipe_name):
representation_link = '%s/recipes/%s/tiddlers' % (
self._server_prefix(), encode_name(recipe_name))
representations = self._tiddler_list_header(representation_link)
user_object = get_user_object(self.environ)
recipe = self.environ['tiddlyweb.store'].get(Recipe(recipe_name))
publicity = ''
try:
recipe.policy.allows(user_object, 'manage')
policy = recipe.policy
if policy.read == [user_object['name']]:
publicity = 'private'
elif policy.read == []:
publicity = 'public'
else:
publicity = 'custom'
delete = True
except (UserRequiredError, ForbiddenError):
policy = None
delete = False
data = {'title': 'TiddlyHoster Recipe %s' % recipe.name,
'policy': policy,
'publicity': publicity,
'delete': delete,
'recipe': recipe,
'tiddlers': tiddlers,
'representations': representations}
del self.environ['tiddlyweb.title']
return send_template(self.environ, 'recipelist.html', data)
def provider_auth_success(environ, data):
"""
Provider responds to authorize requests with redirect
including code.
"""
user = environ['tiddlyweb.usersign']['name']
redirect_uri = data['redirect_uri']
try:
auth_code = register_code(environ,
user=user,
client=data['client_id'],
redirect=redirect_uri,
scope=data['scope'])
except StoreError:
return provider_auth_error(data, error='server_error')
redirect_data = 'code=%s' % auth_code
if 'state' in data:
redirect_data += '&state=%s' % encode_name(data['state'])
if '?' in redirect_uri:
redirect_uri += '&%s' % redirect_data
else:
redirect_uri += '?%s' % redirect_data
raise HTTP302(redirect_uri)
def _bag_list(self, tiddlers):
if '/feedbag' in self.environ['selector.matches'][0]:
representation_link = '%s/feedbag' % (self._server_prefix())
bag = Bag('feedbag')
bag.policy.manage = ["NONE"]
bag.policy.delete = ["NONE"]
bag.desc = 'Recent Public Stuff'
else:
name = self.environ['wsgiorg.routing_args'][1]['bag_name']
name = urllib.unquote(name)
name = name.decode('utf-8')
representation_link = '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(name))
bag = self.environ['tiddlyweb.store'].get(Bag(name))
representations = self._tiddler_list_header(representation_link)
user_object = get_user_object(self.environ)
publicity = ''
try:
bag.policy.allows(user_object, 'manage')
policy = bag.policy
publicity = determine_publicity(user_object, policy)
except (UserRequiredError, ForbiddenError):
policy = None
try:
bag.policy.allows(user_object, 'delete')
delete = True
except (UserRequiredError, ForbiddenError):
delete = False
data = {'title': 'TiddlyHoster Bag %s' % bag.name, 'policy': policy,
'publicity': publicity, 'delete': delete,
'bag': bag, 'tiddlers': tiddlers, 'representations': representations}
del self.environ['tiddlyweb.title']
return send_template(self.environ, 'baglist.html', data)
def get_home(environ, start_response):
user = environ['tiddlyweb.usersign']
if user['name'] == 'GUEST' or 'MEMBER' not in user['roles']:
raise HTTP302(server_base_url(environ) + '/')
else:
raise HTTP302(
server_base_url(environ) + '/' + encode_name(user['name']))
def list_bag_tiddlers(self, bag):
filepath = os.path.join(self._base, encode_name(bag.name))
if os.path.isdir(filepath):
dev_tiddlers = self._get_bag_tiddlers(bag)
return dev_tiddlers
else:
return self.wrapped_storage.list_bag_tiddlers(bag)
def list_tiddlers(self, bag):
"""
If the URL is a list of bag tiddlers, we present a bag
editing interface. Otherwise we use the parent serialization.
"""
if (self.environ['wsgiorg.routing_args'][1].get('tiddler_name')):
return HTMLSerialization.list_tiddlers(self, bag)
try:
name = self.environ['wsgiorg.routing_args'][1]['bag_name']
except KeyError: # not a bag link
return HTMLSerialization.list_tiddlers(self, bag)
representation_link = '%s/bags/%s/tiddlers' % (
self._server_prefix(), encode_name(bag.name))
representations = self._tiddler_list_header(representation_link)
user_object = get_user_object(self.environ)
publicity = ''
try:
bag.policy.allows(user_object, 'manage')
policy = bag.policy
publicity = determine_publicity(user_object, policy)
except (UserRequiredError, ForbiddenError):
policy = None
try:
bag.policy.allows(user_object, 'delete')
delete = True
except (UserRequiredError, ForbiddenError):
delete = False
data = {'title': 'TiddlyHoster Bag %s' % bag.name, 'policy': policy,
'publicity': publicity, 'delete': delete,
'bag': bag, 'representations': representations}
del self.environ['tiddlyweb.title']
return send_template(self.environ, 'baglist.html', data)
def _tiddlers_links(self, tiddlers, tiddler):
"""
Establish the links to use with a tiddlers collection.
If the collection is a search or revisions we need to
do some special work, otherwise just look at the last
tiddler in the collection to determine the container.
"""
if tiddlers.is_search:
return {}
if tiddlers.is_revisions:
links = {}
links['self'] = '%s/%s/revisions' % (
self._tiddlers_collection_uri(),
encode_name(tiddler.title))
links['tiddlyweb:tiddler'] = tiddler_url(self.environ,
tiddler, full=True)
return links
links = {}
if tiddler:
links = self._tiddlers_self(tiddler)
tiddler_link = self._tiddlers_collection_uri()
if tiddler_link:
links['self'] = tiddler_link
links['tiddlyweb:tiddler'] = tiddler_link + '/{tiddler}'
return links
def get_home(environ, start_response):
user = environ['tiddlyweb.usersign']
if user['name'] == 'GUEST' or 'MEMBER' not in user['roles']:
raise HTTP302(server_base_url(environ) + '/')
else:
raise HTTP302(server_base_url(environ) + '/'
+ encode_name(user['name']))
def make_ticklist(environ, start_response):
"""
Record routes the user would like to climb.
"""
store = environ['tiddlyweb.store']
current_user = environ['tiddlyweb.usersign']['name']
gym = get_route_value(environ, 'gym')
tick_wishes = environ['tiddlyweb.query'].get('addroute', [])
routes = _get_gym_routes(environ, gym)
for route in routes:
route.bag = current_user
if route.title in tick_wishes:
route.tags = ['tickwish']
route.fields['gym'] = gym
store.put(route)
else:
try:
tiddler = store.get(route)
tiddler.tags.remove('tickwish')
store.put(tiddler)
except (StoreError, ValueError):
pass
raise HTTP303(server_base_url(environ)
+ '/gyms/%s/ticklist' % encode_name(gym))
def _get_tiddlyweb_tiddler(environ, uri, title):
"""
Get a tiddler with title from uri.
"""
url = uri + '/' + encode_name(title)
_, content = retrieve_remote(url, accept='application/json')
return _process_json_tiddler(environ, content, uri)
def render(tiddler, environ):
"""
Render TiddlyWiki wikitext in the provided
tiddler to HTML. The provided path helps
set paths in wikilinks correctly.
"""
server_prefix = environ.get('tiddlyweb.config',
{}).get('server_prefix', '')
if tiddler.recipe:
path = 'recipes/%s/tiddlers' % encode_name(tiddler.recipe)
elif tiddler.bag:
path = 'bags/%s/tiddlers' % encode_name(tiddler.bag)
else:
path = ''
html = wikitext_to_wikklyhtml('%s/' % server_prefix, path, tiddler.text,
environ)
return unicode(html, 'utf-8')
def gravatar(environ):
"""
Generate a gravatar link.
"""
email = environ.get('tank.user_info', {}).get('email', '')
return GRAVATAR % (md5(email.lower()).hexdigest(),
encode_name(
tank_page_uri(environ, 'tank', DEFAULT_GRAVATAR)))
def wrap_list():
yield self._header()
yield '<ul id="bags" class="listing">\n'
for bag in bags:
yield '<li><a href="bags/%s/tiddlers">%s</a></li>\n' % (
encode_name(bag.name), bag.name)
yield '\n</ul>'
yield self._footer()
def wrap_list():
yield self._header()
yield '<ul id="recipes" class="listing">\n'
for recipe in recipes:
yield '<li><a href="recipes/%s">%s</a></li>\n' % (encode_name(
recipe.name), recipe.name)
yield '\n</ul>'
yield self._footer()
def tiddler_as(self, tiddler):
"""
Transform the provided tiddler into an HTML
representation of the tiddler packaged in a
DIV. Render the content using the render_wikitext
subsystem.
"""
if tiddler.recipe:
list_link = 'recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = 'bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
list_html = ('<div class="tiddlerslink"><a href="%s/%s" ' %
(self._server_prefix(), list_link) +
'title="tiddler list">%s</a></div>' % list_title)
html = render_wikitext(tiddler, self.environ)
self.environ['tiddlyweb.title'] = tiddler.title
return list_html + self._tiddler_div(tiddler) + html + '</div>'
def list_bag_tiddlers(self, bag):
url = self.bag_tiddlers_url % encode_name(bag.name)
response, content = self._request('GET', url)
if self._is_success(response):
tiddlers = simplejson.loads(content)
for tiddler in tiddlers:
yield Tiddler(tiddler['title'], tiddler['bag'])
else:
pass
return
def bag_as(self, bag):
"""
Bag as html.
"""
self.environ['tiddlyweb.title'] = 'Bag %s' % bag.name
tiddler_link = '%s/tiddlers' % encode_name(bag.name)
return """
<div id="bagdesc" class="description">%s</div>
<div class="tiddlerslink"><a href="%s">Tiddlers in Bag %s</a></div>
""" % (bag.desc, tiddler_link, bag.name)
def match_tiddler(title, match_string, neg=False):
response, content = http.request('http://thing.0.0.0.0:8080/%s' %
(encode_name(title)),
method='GET')
assert response['status'] == '200'
if neg:
assert match_string not in content
else:
assert match_string in content
def tiddler_as(self, tiddler):
"""
Transform the provided :py:class:`tiddler
<tiddlyweb.model.tiddler.Tiddler>` into an HTML representation.
:py:mod:`Render <tiddlyweb.wikitext>` the ``text`` of the tiddler
if its ``type`` is configured.
"""
if tiddler.recipe:
list_link = 'recipes/%s/tiddlers' % encode_name(tiddler.recipe)
list_title = 'Tiddlers in Recipe %s' % tiddler.recipe
else:
list_link = 'bags/%s/tiddlers' % encode_name(tiddler.bag)
list_title = 'Tiddlers in Bag %s' % tiddler.bag
list_html = ('<div class="tiddlerslink"><a href="%s/%s" ' %
(self._server_prefix(), list_link) +
'title="tiddler list">%s</a></div>' % list_title)
html = render_wikitext(tiddler, self.environ)
self.environ['tiddlyweb.title'] = tiddler.title
return (self._header() + list_html + self._tiddler_div(tiddler) +
html + '</div>' + self._footer())
def bag_get(self, bag):
url = self.bag_url % encode_name(bag.name)
self.doit(url, bag, self._any_get, NoBagError)
if not (hasattr(bag, 'skinny') and bag.skinny):
url = self.bag_tiddlers_url % bag.name
response, content = self._request('GET', url)
if self._is_success(response):
tiddlers = simplejson.loads(content)
for tiddler in tiddlers:
bag.add_tiddler(Tiddler(tiddler['title']))
return bag
def search(self, search_query):
def _make_tiddler(result_dict):
tiddler = Tiddler(result_dict['title'])
tiddler.bag = result_dict['bag']
tiddler.revision = result_dict['revision']
return tiddler
url = self.search_url % encode_name(search_query)
response, content = self._request('GET', url)
if self._is_success(response):
results = simplejson.loads(content)
return [_make_tiddler(result) for result in results]
else:
return []
def bag_as(self, bag):
"""
:py:class:`Bag <tiddlyweb.model.bag.Bag>` as HTML,
including a link to the tiddlers within.
"""
self.environ['tiddlyweb.title'] = 'Bag %s' % bag.name
tiddler_link = '%s/tiddlers' % encode_name(bag.name)
return """
%s
<div id="bagdesc" class="description">%s</div>
<div class="tiddlerslink"><a href="%s">Tiddlers in Bag %s</a></div>
%s
""" % (self._header(), bag.desc, tiddler_link, bag.name, self._footer())
def send_template(environ, template_name, template_data=None):
"""
Set some defaults for a template and send the output.
"""
if template_data == None:
template_data = {}
template = get_template(environ, template_name)
store = environ['tiddlyweb.store']
linked_resources = {
'HtmlCss': ['/bags/common/tiddlers/profile.css'],
'HtmlJavascript': []
}
# Load CSS and JavaScript overrides.
current_space = determine_space(environ, determine_host(environ)[0])
if current_space:
recipe_name = determine_space_recipe(environ, current_space)
try:
recipe = store.get(Recipe(recipe_name))
for title in linked_resources:
try:
tiddler = Tiddler(title)
bag = control.determine_bag_from_recipe(
recipe, tiddler, environ)
tiddler.bag = bag.name
try:
tiddler = store.get(tiddler)
if 'Javascript' in title:
urls = tiddler.text.strip().rstrip().split('\n')
linked_resources[title] = urls
else:
url = '/bags/%s/tiddlers/%s' % (encode_name(
tiddler.bag), title)
linked_resources[title] = [url]
except StoreError:
continue
except StoreError:
pass
except StoreError:
pass
template_defaults = {
'original_server_host': original_server_host_url(environ),
'css': linked_resources['HtmlCss'],
'js': linked_resources['HtmlJavascript'],
'server_host': server_base_url(environ),
}
template_defaults.update(template_data)
return template.generate(template_defaults)
