def get(environ, start_response): """ Using query parameters, determine the current tiddler and produce an editor for it. """ usersign = environ["tiddlyweb.usersign"] try: tiddler_name = environ["tiddlyweb.query"].get("tiddler", [""])[0] recipe_name = environ["tiddlyweb.query"].get("recipe", [""])[0] bag_name = environ["tiddlyweb.query"].get("bag", [""])[0] except (KeyError, IndexError): raise HTTP400("tiddler, recipe and bag query strings required") store = environ["tiddlyweb.store"] tiddler = Tiddler(tiddler_name) if bag_name: tiddler.bag = bag_name else: recipe = Recipe(recipe_name) try: recipe = store.get(recipe) tiddler.bag = determine_bag_from_recipe(recipe, tiddler).name tiddler.recipe = recipe.name except NoRecipeError, exc: raise HTTP404("unable to edit %s, recipe %s not found: %s" % (tiddler.title, recipe_name, exc)) except NoBagError, exc: raise HTTP404("unable to edit %s: %s" % (tiddler.title, exc))
def get(environ, start_response): """ Using query parameters, determine the current tiddler and produce an editor for it. """ usersign = environ['tiddlyweb.usersign'] try: tiddler_name = environ['tiddlyweb.query'].get('tiddler', [''])[0] recipe_name = environ['tiddlyweb.query'].get('recipe', [''])[0] bag_name = environ['tiddlyweb.query'].get('bag', [''])[0] #tiddler_name = unicode(urllib.unquote(tiddler_name), 'utf-8') #bag_name = unicode(urllib.unquote(bag_name), 'utf-8') #recipe_name = unicode(urllib.unquote(recipe_name), 'utf-8') except (KeyError, IndexError): raise HTTP400('tiddler, recipe and bag query strings required') store = environ['tiddlyweb.store'] tiddler = Tiddler(tiddler_name) if bag_name: tiddler.bag = bag_name else: recipe = Recipe(recipe_name) try: recipe = store.get(recipe) tiddler.bag = control.determine_tiddler_bag_from_recipe(recipe, tiddler).name tiddler.recipe = recipe.name except NoRecipeError, exc: raise HTTP404('unable to edit %s, recipe %s not found: %s' % (tiddler.title, recipe_name, exc)) except NoBagError, exc: raise HTTP404('unable to edit %s: %s' % (tiddler.title, exc))
def get(environ, start_response): """ Using query parameters, determine the current tiddler and produce an editor for it. """ usersign = environ['tiddlyweb.usersign'] try: tiddler_name = environ['tiddlyweb.query'].get('tiddler', [''])[0] recipe_name = environ['tiddlyweb.query'].get('recipe', [''])[0] bag_name = environ['tiddlyweb.query'].get('bag', [''])[0] except (KeyError, IndexError): raise HTTP400('tiddler, recipe and bag query strings required') store = environ['tiddlyweb.store'] tiddler = Tiddler(tiddler_name) if bag_name: tiddler.bag = bag_name else: recipe = Recipe(recipe_name) try: recipe = store.get(recipe) tiddler.bag = control.determine_tiddler_bag_from_recipe( recipe, tiddler).name tiddler.recipe = recipe.name except NoRecipeError, exc: raise HTTP404('unable to edit %s, recipe %s not found: %s' % (tiddler.title, recipe_name, exc)) except NoBagError, exc: raise HTTP404('unable to edit %s: %s' % (tiddler.title, exc))
def _manage_update_routes(environ, gym): """ Update routes with new information. """ store = environ['tiddlyweb.store'] query = environ['tiddlyweb.query'] existing_titles = query.get('title', []) count = len(existing_titles) index = 0 delete = query.get('delete', []) lead_route = query.get(LEAD_FIELD, []) while index < count: title = existing_titles[index] tiddler = Tiddler(title, '%s_climbs' % gym) try: tiddler = store.get(tiddler) if title in delete: original_bag = tiddler.bag tiddler.bag = '%s_archive' % gym store.put(tiddler) tiddler.bag = original_bag store.delete(tiddler) index += 1 continue except StoreError: pass changed = False for key in ROUTE_FIELDS: value = query.get(key, [''])[index] if tiddler.fields[key] != value: tiddler.fields[key] = value changed = True if LEAD_FIELD in tiddler.fields and title not in lead_route: del tiddler.fields[LEAD_FIELD] changed = True elif title in lead_route and LEAD_FIELD not in tiddler.fields: tiddler.fields[LEAD_FIELD] = '1' changed = True if changed: store.put(tiddler) index += 1 try: title = query.get('title', [])[index] except IndexError: title = str(uuid4()) tiddler = Tiddler(title, '%s_climbs' % gym) new_route = False if 'new_one' in lead_route: tiddler.fields[LEAD_FIELD] = '1' for key in ROUTE_FIELDS: value = query.get(key, [''])[index] if value == '': continue new_route = True tiddler.fields[key] = value if new_route: store.put(tiddler) raise HTTP303(server_base_url(environ) + '/manager/%s' % gym)
def test_put_and_get_tiddler(): tiddler = Tiddler('testbag') tiddler.text = 'bag1 here' bag = Bag('bag1') tiddler.bag = u'bag1' store.put(bag) store.put(tiddler) new_tiddler = Tiddler('testbag') new_tiddler.bag = u'bag1' new_tiddler = store.get(new_tiddler) assert new_tiddler.text == 'bag1 here'
def test_tiddler_unique_by_bags(): tiddler_one = Tiddler('testbag') tiddler_one.bag = 'bag1' tiddler_two = Tiddler('testbag') tiddler_two.bag = 'bag2' assert tiddler_one.text == tiddler_two.text == '', \ 'empty tiddlers have equally empty content' tiddler_one = store.get(tiddler_one) tiddler_two = store.get(tiddler_two) assert tiddler_one.text != tiddler_two.text, \ 'empty tiddlers have different content'
def test_put_and_get_tiddler(): tiddler = Tiddler(title='testbag') tiddler.text = 'bag1 here' bag = Bag(name = 'bag1') tiddler.bag = 'bag1' store.put(bag) store.put(tiddler) new_tiddler = Tiddler(title='testbag') new_tiddler.bag = 'bag1' new_tiddler = store.get(new_tiddler) assert new_tiddler.text == 'bag1 here'
def test_tiddler_unique_by_bags(): tiddler_one = Tiddler('testbag') tiddler_one.bag = 'bag1' tiddler_two = Tiddler('testbag') tiddler_two.bag = 'bag2' assert tiddler_one.text == tiddler_two.text == None, \ 'empty tiddlers have equally empty content' tiddler_one = store.get(tiddler_one) tiddler_two = store.get(tiddler_two) assert tiddler_one.text != tiddler_two.text, \ 'empty tiddlers have different content'
def url(args): """Add a URL via tiddlywebplugins.URLs. Redirect is optional. [--redirect] <selector_path> <destination_url>""" if 2 != len(args) != 3: print >> sys.stderr, ('you must include both the path you want to use (selector path) and the destination url') store = get_store(config) if args[0] == '--redirect': redirect = args.pop(0).lstrip('-') else: redirect = None selector_path = args[0] destination_url = args[1] tiddler = Tiddler(selector_path) tiddler.bag = config['url_bag'] tiddler.text = destination_url if redirect: tiddler.tags = [redirect] if validate_url(tiddler): store.put(tiddler) return True
def test_tiddler_title_with_slash(): tiddler = Tiddler('hello/monkey') tiddler.bag = u'bag/puss' tiddler.text = 'artifice' assert tiddler.title == 'hello/monkey' store.put(tiddler) tiddler2 = Tiddler('hello/monkey') tiddler2.bag = u'bag/puss' tiddler2 = store.get(tiddler2) assert tiddler2.title == 'hello/monkey' assert tiddler2.text == 'artifice'
def _process_choices(environ, start_response, form): store = environ['tiddlyweb.store'] user = environ['tiddlyweb.usersign'] tmp_bag = form['tmp_bag'][0] bag = form['target_bag'][0] if bag: bag = Bag(bag) try: bag.skinny = True bag = store.get(bag) except NoBagError: return _send_wimport(environ, start_response, 'chosen bag does not exist') else: bag = form['new_bag'][0] bag = _make_bag(environ, bag) try: bag.policy.allows(user, 'write') except (ForbiddenError, UserRequiredError): return _send_wimport(environ, start_response, 'you may not write to that bag') tiddler_titles = form['tiddler'] for title in tiddler_titles: tiddler = Tiddler(title.decode('utf-8', 'ignore'), tmp_bag) tiddler = store.get(tiddler) tiddler.bag = bag.name store.put(tiddler) tmp_bag = Bag(tmp_bag) store.delete(tmp_bag) bagurl = bag_url(environ, bag) + '/tiddlers' raise HTTP302(bagurl)
def retrieve_from_store(email): """ get the tiddler requested by the email from the store and return it as an email """ store = get_store(config) tiddler_title = clean_subject(email["subject"]) tiddler = Tiddler(tiddler_title) bag = determine_bag(email["to"]) tiddler.bag = bag try: tiddler = store.get(tiddler) response_text = tiddler.text except NoTiddlerError: # Tiddler not found. Return a list of all tiddlers bag = Bag(bag) bag = store.get(bag) response_text = "The following tiddlers are in %s:\n" % email["to"].split("@")[1] tiddlers = bag.gen_tiddlers() tiddlers = [tiddler for tiddler in tiddlers] response_text += "\n".join([tiddler.title for tiddler in tiddlers]) response_email = {"from": email["to"], "to": email["from"], "subject": tiddler.title, "body": response_text} return response_email
def test_no_bag_for_tiddler(): tiddler = Tiddler('testnobag') tiddler.text = 'no bag here' tiddler.bag = u'no bag of this name' with py.test.raises(NoBagError): store.put(tiddler)
def test_get_revision(): """ Test we are able to retrieve a particular revision. """ bagone = Bag('bagone') store.put(bagone) tiddler = Tiddler('RevisionTiddler') tiddler.text = 'how now 1' tiddler.bag = u'bagone' store.put(tiddler) tiddler.text = 'how now 2' store.put(tiddler) tiddler.text = 'how now 3' store.put(tiddler) tiddler = Tiddler('RevisionTiddler', 'bagone') tiddler = store.get(tiddler) assert tiddler.text == 'how now 3' assert tiddler.revision == 3 tiddler = Tiddler('RevisionTiddler', 'bagone') tiddler.revision = 2 tiddler = store.get(tiddler) assert tiddler.text == 'how now 2' assert tiddler.revision == 2 revisions = store.list_tiddler_revisions(tiddler) assert len(revisions) == 3 assert revisions[0] == 3
def test_determine_tiddler_from_recipe(): """ Work out what bag a provided tiddler is in, when we have no knowledge of the bag, but we do have a recipe. """ short_recipe = Recipe(name='foobar') short_recipe.set_recipe([ [bagone, ''], [bagfour, 'select=tag:tagone'] ]) bag = control.determine_tiddler_bag_from_recipe(short_recipe, tiddlers[0]) assert bag.name == bagfour.name, 'bag name should be bagfour, is %s' % bag.name short_recipe.set_recipe([ [bagone, ''], [bagfour, 'select=tag:tagthree'] ]) bag = control.determine_tiddler_bag_from_recipe(short_recipe, tiddlers[0]) assert bag.name == bagone.name, 'bag name should be bagone, is %s' % bag.name lonely_tiddler = Tiddler('lonely') lonely_tiddler.bag = 'lonelybag' py.test.raises(NoBagError, 'bag = control.determine_tiddler_bag_from_recipe(short_recipe, lonely_tiddler)')
def test_html_attribute_escape_with_bag(): tiddler = Tiddler('escape "double" quotes in tiddler field values') tiddler.bag = 'foo "bar" baz' tiddler.modifier = 'Chris "sensei" Dent' tiddler.tags = ["foo", 'xxx "yyy" zzz'] tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet""" tiddler.text = '' serializer = Serializer('tiddlywebwiki.serialization', environ) serializer.object = tiddler string = serializer.to_string() assert ('title="escape "double" quotes in tiddler field values"' in string) assert ('server.title="escape "double" quotes in tiddler ' 'field values"' in string) assert 'bag="foo "bar" baz"' in string assert 'server.workspace="bags/foo "bar" baz"' in string assert 'modifier="Chris "sensei" Dent"' in string assert 'creator="Chris "sensei" Dent"' in string assert 'tags="foo [[xxx "yyy" zzz]]"' in string assert '''custom="lorem 'ipsum' dolor "sit" amet"''' in string # single tiddler's browse link is that tiddler in its bag assert ('you may still <a href="/bags/foo%20%22bar%22%20baz/tiddlers/' 'escape%20%22double%22%20quotes%20in%20tiddler%20field%20' 'values">browse' in string)
def test_tiddler_url(): tiddler = Tiddler('foobar') tiddler.bag = 'zoom' url = tiddler_url(environ, tiddler) assert url == 'http://our_test_domain:8001/bags/zoom/tiddlers/foobar' tiddler.recipe = 'car' url = tiddler_url(environ, tiddler, container='recipes') assert url == 'http://our_test_domain:8001/recipes/car/tiddlers/foobar' url = tiddler_url(environ, tiddler, container='recipes', full=False) assert url == '/recipes/car/tiddlers/foobar' config['server_prefix'] = '/sleep' url = tiddler_url(environ, tiddler, container='recipes', full=False) assert url == '/sleep/recipes/car/tiddlers/foobar' url = tiddler_url(environ, tiddler) assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar' tiddler.fields['_canonical_uri'] = 'http://example.com' url = tiddler_url(environ, tiddler) # we decided url is always local #assert url == 'http://example.com' assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
def test_tiddler_full_create(): """ Confirm we can populate a tiddler at create time. """ tiddler = Tiddler('test tiddler') tiddler.modifier = '*****@*****.**' tiddler.text = test_tiddler_text tiddler.tags = ['foo', 'bar'] tiddler.bag = u'bagone' assert type(tiddler) == Tiddler, \ 'Tiddler returns a Tiddler' assert tiddler.title == 'test tiddler', \ 'tiddler title should be test tiddler, got %s' \ % tiddler.title assert tiddler.modifier == '*****@*****.**', \ 'tiddler modifier should [email protected], got %s' \ % tiddler.modifier assert tiddler.text == test_tiddler_text, \ 'tiddler content is correct' assert tiddler.tags == ['foo', 'bar'], \ 'tiddler tags are correct' assert tiddler.bag == 'bagone', \ 'tiddler has a bag of bagone' assert tiddler.revision is None, \ 'tiddler revision is None' assert tiddler.creator == '*****@*****.**'
def test_tiddler_title_with_slash(): tiddler = Tiddler("hello/monkey") tiddler.bag = "bag/puss" tiddler.text = "artifice" assert tiddler.title == "hello/monkey" store.put(tiddler) tiddler2 = Tiddler("hello/monkey") tiddler2.bag = "bag/puss" tiddler2 = store.get(tiddler2) assert tiddler2.title == "hello/monkey" assert tiddler2.text == "artifice"
def test_tiddler_url(): tiddler = Tiddler('foobar') tiddler.bag = 'zoom' url = tiddler_url(environ, tiddler) assert url == 'http://our_test_domain:8001/bags/zoom/tiddlers/foobar' tiddler.recipe = 'car' url = tiddler_url(environ, tiddler, container='recipes') assert url == 'http://our_test_domain:8001/recipes/car/tiddlers/foobar' url = tiddler_url(environ, tiddler, container='recipes', full=False) assert url == '/recipes/car/tiddlers/foobar' config['server_prefix'] = '/sleep' url = tiddler_url(environ, tiddler, container='recipes', full=False) assert url == '/sleep/recipes/car/tiddlers/foobar' url = tiddler_url(environ, tiddler) assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar' tiddler.fields['_canonical_uri'] = 'http://example.com' url = tiddler_url(environ, tiddler) assert url == 'http://our_test_domain:8001/sleep/bags/zoom/tiddlers/foobar'
def test_call_jsonp(): """ test that we can get some stuff as JSONP """ tiddler = Tiddler('public') tiddler.bag = 'foo_public' tiddler.text = 'some text' store.put(tiddler) user_cookie = get_auth('foo', 'foobar') callback = 'callback' response, content = http.request('http://foo.0.0.0.0:8080/bags/' 'foo_public/tiddlers/public?callback=%s' % callback, method='GET', headers={ 'Cookie': 'tiddlyweb_user="******"' % user_cookie, 'Accept': 'application/json' }) assert response['status'] == '200' assert content.startswith('%s(' % callback) assert content[-1:] == ')' response, content = http.request('http://0.0.0.0:8080/bags/' 'foo_public/tiddlers/public?callback=%s' % callback, method='GET', headers={ 'Cookie': 'tiddlyweb_user="******"' % user_cookie, 'Accept': 'application/json' }) assert response['status'] == '200' assert content.startswith('%s(' % callback) assert content[-1:] == ')'
def _determine_tiddler(environ): """ Inspect the environment to determine which tiddler from which bag will provide content for the page named in the URL. If the page exists, and we have permission to read the bag in which it is stored, the return the tiddler. If we do not have permission, a login interface will be shown. If the tiddler does not exist, an empty tiddler with stub text will be returned. """ user = environ['tiddlyweb.usersign'] config = environ['tiddlyweb.config'] store = environ['tiddlyweb.store'] recipe = Recipe(_get_recipe(config)) recipe = store.get(recipe) recipe.policy.allows(user, 'read') tiddler_name = environ['wsgiorg.routing_args'][1]['tiddler_name'] tiddler_name = urllib.unquote(tiddler_name) tiddler_name = unicode(tiddler_name, 'utf-8') tiddler = Tiddler(tiddler_name) try: bag = control.determine_bag_from_recipe(recipe, tiddler, environ) bag.policy.allows(user, 'read') tiddler.bag = bag.name tiddler = store.get(tiddler) except NoBagError, exc: # Apparently the tiddler doesn't exist, let's fill in an empty one # then. tiddler.text = 'That Page does not yet exist.' tiddler.type = 'text/x-markdown'
def _get_status_tiddler(self, environ, status): """ Load up the tiddler associated with the current status. If the tiddler is not present in the recipe, load up the tiddler with title 'default'. If that tiddler is not present, use DEFAULT_TEXT. """ try: tiddler = Tiddler(status) store = environ['tiddlyweb.store'] recipe_name = environ['tiddlyweb.config'].get('prettyerror.recipe', '_errors') recipe = Recipe(recipe_name) recipe = store.get(recipe) bag = determine_bag_from_recipe(recipe, tiddler, environ) tiddler.bag = bag.name tiddler = store.get(tiddler) except (NoRecipeError, NoBagError): if status == 'default': tiddler.text = DEFAULT_TEXT else: tiddler = self._get_status_tiddler(environ, 'default') except (NoTiddlerError): # If there is no default tiddler we get recursion error. tiddler = self._get_status_tiddler(environ, 'default') except: # Deal with failures early in the stack tiddler.text = DEFAULT_TEXT return tiddler
def test_get_tiddler_revision(): _cleanup() config = { "server_store": ["tiddlywebplugins.devstore", { "store_root": STORE_DIR }], "instance_tiddlers": { "myBag": ["%s/alpha/index.recipe" % REPO_DIR] }, "root_dir": "" } env = { "tiddlyweb.config": config } store = Store(config["server_store"][0], config["server_store"][1], env) tiddler = Tiddler("lorem") tiddler.bag = "myBag" t = store.get(tiddler) assert t.title == "lorem" assert t.bag == "myBag" assert t.revision == 1 assert t.tags == [] assert t.creator == "FND" assert t.modifier == "FND" assert len(t.created) == 14 assert len(t.modified) == 14 assert t.created == t.modified assert t.text == "lorem ipsum" tiddler = Tiddler("hello world") tiddler.bag = "myBag" tiddler.tags = ["foo", "bar"] tiddler.modifier = "FND" tiddler.text = "lorem ipsum" store.put(tiddler) tiddler = Tiddler("hello world") tiddler.bag = "myBag" t = store.get(tiddler) assert t.title == "hello world" assert t.bag == "myBag" assert t.revision == 1 assert t.tags == ["foo", "bar"] assert t.creator == "FND" assert t.modifier == "FND" assert len(t.created) == 14 assert len(t.modified) == 14 assert t.created == t.modified assert t.text == "lorem ipsum"
def test_get_diddle_put_tiddler(): new_tiddler = Tiddler(title='testbag') new_tiddler.bag = u'bag1' new_tiddler = store.get(new_tiddler) new_tiddler.bag = u'bag2' new_tiddler.text = 'bag2 here' py.test.raises(NoBagError, "store.put(new_tiddler)") bag = Bag('bag2') store.put(bag) store.put(new_tiddler) assert os.path.exists('store/bags/bag2/tiddlers/testbag') assert os.path.exists('store/bags/bag1/tiddlers/testbag')
def bag_get(self, bag): tiddlers = [] tiddler_count = int(bag.name) for i in xrange(tiddler_count): tiddler = Tiddler(_generate_title()) tiddler.bag = bag.name bag.add_tiddler(tiddler) return bag
def resolve_tiddler(self, target, title): interior_tiddler = Tiddler(title) if target: tiddlywebconfig = self.environ['tiddlyweb.config'] target_resolver = tiddlywebconfig.get('markdown.target_resolver') if not target_resolver: interior_tiddler.bag = 'NoSuchBag' else: target_resolver(self.environ, target, interior_tiddler) else: if self.tiddler.recipe: interior_bag = get_bag_from_recipe(self.environ, self.tiddler.recipe, interior_tiddler) interior_tiddler.bag = interior_bag.name else: interior_tiddler.bag = self.tiddler.bag return interior_tiddler
def test_get_diddle_put_tiddler(): new_tiddler = Tiddler(title='testbag') new_tiddler.bag = 'bag1' new_tiddler = store.get(new_tiddler) new_tiddler.bag = 'bag2' new_tiddler.text = 'bag2 here' py.test.raises(NoBagError, "store.put(new_tiddler)") bag = Bag('bag2') store.put(bag) store.put(new_tiddler) assert os.path.exists('store/bags/bag2/tiddlers/testbag') assert os.path.exists('store/bags/bag1/tiddlers/testbag')
def test_tiddler_html_encode(): serializer = Serializer('html') tiddler = Tiddler('jeremy found a bug') tiddler.bag = u'foo' tiddler.text = u'"Hello." I\'m > than 5 & < you.' serializer.object = tiddler string = serializer.to_string() assert '"Hello." I\'m > than 5 & < you.' in string
def save_tiddler(store, tiddler): title = tiddler['title'] bag = tiddler['bag'] tiddler_json = simplejson.dumps(tiddler) tid = Tiddler(title) s = Serializer('json') s.object = tid s.from_string(tiddler_json) tid.bag = bag store.put(tid)
def test_simple_render(): tiddler = Tiddler('bar') tiddler.text = """ |hello|goodbye|h |foo|bar| """ tiddler.bag = 'zoo' html = render(tiddler, {}) assert 'WikError' in html
def bag_get(self, bag): bag.desc = 'Available users' bag.policy = self._policy() store = self.main_store users = store.list_users() for user in users: tiddler = Tiddler(user.usersign) tiddler.bag = bag.name bag.add_tiddler(tiddler) return bag
def get_app(environ, client_id): """ Get the app out of the store. """ store = environ['tiddlyweb.store'] config = environ['tiddlyweb.config'] bag = config.get('oauth.app_bag', 'oauth_apps') app = Tiddler(client_id) app.bag = bag return store.get(app)
def test_tiddler_get(): _cleanup() config = { "server_store": ["tiddlywebplugins.devstore", { "store_root": STORE_DIR }], "instance_tiddlers": { "myBag": ["%s/alpha/index.recipe" % REPO_DIR] }, "root_dir": "" } env = { "tiddlyweb.config": config } store = Storage(config["server_store"][1], env) tiddler = Tiddler("lorem") tiddler.bag = "myBag" t = store.tiddler_get(tiddler) assert t.title == "lorem" assert t.bag == "myBag" assert t.tags == [] assert t.creator == "FND" assert t.modifier == "FND" assert len(t.created) == 14 assert len(t.modified) == 14 assert t.created == t.modified assert t.text == "lorem ipsum" tiddler = Tiddler("foo") tiddler.bag = "myBag" t = store.tiddler_get(tiddler) assert t.title == "foo" assert t.bag == "myBag" assert t.type == "text/javascript" assert t.revision == 1 assert t.tags == ["systemConfig"] assert t.creator == None assert t.modifier == None assert len(t.created) == 14 assert len(t.modified) == 14 assert t.created == t.modified assert t.text == 'console.log("foo");'
def test_put_tiddler_to_store(): _cleanup() config = { "server_store": ["tiddlywebplugins.devstore", { "store_root": STORE_DIR }], "instance_tiddlers": { "myBag": ["%s/alpha/index.recipe" % REPO_DIR] }, "root_dir": "" } env = { "tiddlyweb.config": config } store = Store(config["server_store"][0], config["server_store"][1], env) tiddler = Tiddler("lorem") tiddler.bag = "myBag" store.put(tiddler) tiddler_path = os.path.join(STORE_DIR, tiddler.bag, "%s.tid" % tiddler.title) assert os.path.exists(tiddler_path) tiddler = Tiddler("foo bar") tiddler.bag = "myBag" store.put(tiddler) tiddler_path = os.path.join(STORE_DIR, "myBag", "foo%20bar.tid") assert os.path.exists(tiddler_path) assert store.get(tiddler).title == "foo bar" # XXX: testing get operation here for convenience bag = Bag("myBag") try: assert "foo bar" in [t.title for t in store.list_bag_tiddlers(bag)] except AttributeError: # TiddlyWeb 1.0 has no list_bag_tiddlers method pass tiddler = Tiddler("foo/bar") tiddler.bag = "myBag" store.put(tiddler) tiddler_path = os.path.join(STORE_DIR, "myBag", "foo%2Fbar.tid") assert os.path.exists(tiddler_path) assert store.get(tiddler).title == "foo/bar"
def create_test_data(): testbag = Bag(name='testbag') WikiTextTiddler = Tiddler('WikiTextTiddler') WikiTextTiddler.modifier = 'WikiAuthor' WikiTextTiddler.text = u"A ''tiddler'' //with// {{{wikitext}}}" WikiTextTiddler.bag = testbag.name store = _get_store() store.put(testbag) store.put(WikiTextTiddler)
def test_store_tiddler(): tiddler = Tiddler('tiddler1') tiddler.text = 'i am tiddler 1' tiddler.bag = 'bag1' store.put(tiddler) assert os.path.isdir('store/bag1/tiddler1') assert os.path.exists('store/bag1/tiddler1/1') loaded_tiddler = Tiddler('tiddler1', 'bag1') loaded_tiddler = store.get(loaded_tiddler) assert loaded_tiddler.text == tiddler.text
def test_tiddler_json_render(): serializer = Serializer('json', environ={'tiddlyweb.query': { 'render': [1]}, 'tiddlyweb.config': config}) tiddler = Tiddler('htmltest') tiddler.text = '!Hi\n//you//' tiddler.bag = 'snoop' serializer.object = tiddler output = serializer.to_string() info = simplejson.loads(output) assert info['render'] == '<pre>\n!Hi\n//you//</pre>\n' assert info['text'] == '!Hi\n//you//'
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)
def test_simple_get(): """ get a tiddler that had been stored """ stored_tiddler = Tiddler('TiddlerOne') stored_tiddler.bag = u'bagone' stored_tiddler.modified = '200803030303' stored_tiddler = store.get(stored_tiddler) assert stored_tiddler.title == 'TiddlerOne' assert stored_tiddler.bag == 'bagone' assert stored_tiddler.text == 'c tiddler one content' assert sorted(stored_tiddler.tags) == ['tag five', 'tagone', 'tagtwo']
def tiddler(args): """Import a single tiddler into an existing bag from stdin: <bag> <tiddler>""" try: bag_name, tiddler_name = args[0:3] except (IndexError, ValueError): usage('you must include a tiddler and bag name') from tiddlyweb.model.tiddler import Tiddler new_tiddler = Tiddler(tiddler_name) new_tiddler.bag = bag_name content = sys.stdin.read() _put(new_tiddler, unicode(content, 'UTF-8'), 'text')
def test_simple_render(): tiddler = Tiddler('bar') tiddler.text = 'Hello [[monkey]]!' tiddler.bag = 'zoo' html = render(tiddler, {}) assert 'href="/bags/zoo/tiddlers/monkey"' in html tiddler.recipe = 'city' html = render(tiddler, {}) assert 'href="/recipes/city/tiddlers/monkey"' in html html = render(tiddler, {'tiddlyweb.config': {'server_prefix': '/wiki'}}) assert 'href="/wiki/recipes/city/tiddlers/monkey"' in html
def test_tiddler_json_render_skinny(): serializer = Serializer('json', environ={'tiddlyweb.query': { 'render': ['1'], 'fat': ['0']}, 'tiddlyweb.config': config}) tiddler = Tiddler('htmltest') tiddler.bag = 'snoop' tiddler.text = '!Hi\n//you//' serializer.object = tiddler output = serializer.to_string() info = simplejson.loads(output) assert info['render'] == '<pre>\n!Hi\n//you//</pre>\n' with pytest.raises(KeyError): info['text']
def populate_store(): store = get_store(config) for bag_name in ["alpha", "bravo"]: bag = Bag(bag_name) store.put(bag) for title in ["foo", "bar"]: tiddler = Tiddler(title) tiddler.bag = bag.name store.put(tiddler) for recipe_name in ["omega"]: recipe = Recipe(recipe_name) store.put(recipe)
def test_store_lock(): """ Make the sure the locking system throws the proper lock. """ if type(store.storage) != Texter: py.test.skip('skipping this test for non-text store') write_lock('store/bags') py.test.raises(LockError, 'write_lock("store/bags")') write_lock('store/bags' + '/bagone/tiddlers/foobar') tiddler = Tiddler('foobar') tiddler.text = 'hello' tiddler.bag = u'bagone' py.test.raises(StoreLockError, 'store.put(tiddler)')
def test_tiddler_json_base64(): serializer = Serializer('json') tiddler = Tiddler('binarytiddler') tiddler.bag = u'foo' tiddler.text = file('test/peermore.png', 'rb').read() bininfo = tiddler.text b64expected = b64encode(tiddler.text) tiddler.type = 'image/png' serializer.object = tiddler string = serializer.to_string() info = simplejson.loads(string) assert info['text'] == b64expected tiddler = serializer.from_string(string) assert tiddler.text == bininfo
def create_tiddler(store, bag, numeral): tiddler = Tiddler('tiddler%s' % numeral) tiddler.bag = bag.name tiddler.text = u'i am tiddler %s' % numeral tags = [u'basic tag'] if not numeral % 2: tags.append(u'tagtwo') if not numeral % 3: tags.append(u'tagthree') if not numeral % 4: tags.append(u'tagfour') tiddler.tags = tags if tiddler.title == 'tiddler8': tiddler.modified = '200805230303' store.put(tiddler)
def test_html_attribute_escape(): tiddler = Tiddler( 'escape "double" quotes & & in <tiddler> field values') tiddler.bag = u'foo "bar" baz' tiddler.modifier = 'Chris "sensei" Dent' tiddler.tags = ["foo", 'xxx "yyy" zzz'] tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet""" tiddler.text = '' serializer = Serializer('html') serializer.object = tiddler string = serializer.to_string() assert r'''title="escape "double" quotes & &amp; in <tiddler> field values"''' in string assert r'''modifier="Chris "sensei" Dent"''' in string assert r'''tags="foo [[xxx "yyy" zzz]]"''' in string assert r'''custom="lorem 'ipsum' dolor "sit" amet"''' in string
def test_simple_get(): """ get a tiddler that had been stored in bagfour """ stored_tiddler = Tiddler(title='TiddlerOne') stored_tiddler.bag = u'bagone' stored_tiddler.modified = '200803030303' stored_tiddler = store.get(stored_tiddler) assert stored_tiddler.title == 'TiddlerOne', 'retrieved tiddler has correct title' assert stored_tiddler.bag == 'bagone', 'retrieve tiddler has correct bag' assert stored_tiddler.text == 'c tiddler one content', 'text is %s should b %s' % ( stored_tiddler.text, 'c tiddler one content\n') assert sorted(stored_tiddler.tags) == ['tag five', 'tagone', 'tagtwo']