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 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_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)