def test_modifiers_and_case_modifiers_in_any_order(self):
libs = {"Framework": ["django"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("<-.Framework>"))
eq_(radlib, "django")
radlib = unicode(parse("<.-Framework>"))
eq_(radlib, "django")
def new_rad_by_name():
if not g.user:
return error_response('login required')
try:
parse(request.form['rad'])
except ParseError as e:
return error_response('parse error: {0}'.format(e.message))
session = Client().session()
lib_name = request.form['lib']
association_id = request.form['association_id']
try:
find_association(association_id)
except NoResultFound:
return error_response('no such association')
try:
lib = session.query(Lib).\
filter(Lib.name == lib_name).\
filter(Lib.association_id == association_id).\
one()
except NoResultFound:
return error_response("no such lib '{0}'".format(lib_name))
rad = Rad(created_by=g.user.user_id,
lib_id=lib.lib_id,
rad=request.form['rad'])
session.add(rad)
radlibs.lib.decache_lib(lib.name, lib.association_id)
return {
'status': 'ok',
'rad_id': rad.rad_id,
}
def edit_rad(rad_id):
if rad_id == 0:
abort(404)
if not g.user:
return error_response('login required')
try:
parse(request.form['rad'])
except ParseError as e:
return error_response('parse error: {0}'.format(e.message))
session = Client().session()
try:
(rad, lib) = session.query(Rad, Lib).\
join(Lib).\
join(Association).\
join(UserAssociation).\
filter(UserAssociation.user_id == g.user.user_id).\
filter(Rad.rad_id == rad_id).\
one()
except NoResultFound:
return error_response('no such rad')
rad.rad = request.form['rad']
session.add(rad)
radlibs.lib.decache_lib(lib.name, lib.association_id)
return {'status': 'ok'}
def test_exactly_one_or_zero_case_modifiers_are_legal(self):
plaintext = "<!/Confused>"
with assert_raises(ParseError) as error:
parse(plaintext)
eq_(error.exception.message, "Unexpected token '<' at line 1 character 1 of '<!/Confused>'")
plaintext = "<&.Confused>"
with assert_raises(ParseError) as error:
parse(plaintext)
eq_(error.exception.message, "Unexpected token '<' at line 1 character 1 of '<&.Confused>'")
def demo_eval():
try:
rad = request.form['rad']
except KeyError as e:
return error_response("the 'rad' param is required")
try:
libs = request.form['libs']
libs = json.loads(libs)
except KeyError as e:
return error_response("the 'libs' param is required")
except ValueError as e:
return error_response("'libs' param is not valid JSON: " + unicode(e))
with patch('radlibs.parser.load_lib', lambda name: libs[name]):
try:
radlib = unicode(parse(rad))
except KeyError as e:
return error_response("No such Library '{0}'".format(e.message))
except ParseError as e:
return error_response(e.message)
return {
'status': 'ok',
'radlib': radlib,
}
def test_past_tense__in_a_nested_lib(self):
libs = {"Verb": ["run"], "Action": ["I <Verb>^ quickly"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("sometimes <Action>d"))
eq_(radlib, "sometimes I ran quickly")
def test_a_literal_d_after_a_lib(self):
libs = {"Verb": ["run"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("<Verb>\\d"))
eq_(radlib, "rund")
def test_plural__in_a_nested_lib(self):
libs = {"Loot": ["sword^ of slaying"], "Treasure": ["You find 3 <Loot>s in the chest!"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("After defeating the monster, <Treasure>"))
eq_(radlib, "After defeating the monster, " "You find 3 swords of slaying in the chest!")
def new_rad(lib_id):
if lib_id == 0:
return error_response('lib_id is required')
if not g.user:
return error_response('login required')
try:
parse(request.form['rad'])
except ParseError as e:
return error_response('parse error: {0}'.format(e.message))
session = Client().session()
try:
lib = find_lib(lib_id)
except NoResultFound:
return error_response('no such lib')
rad = Rad(created_by=g.user.user_id,
lib_id=lib_id,
rad=request.form['rad'])
session.add(rad)
radlibs.lib.decache_lib(lib.name, lib.association_id)
return {
'status': 'ok',
'rad_id': rad.rad_id
}
def test_radlib(association_id):
session = Client().session()
if not g.user:
return error_response('login required')
try:
association = association_for_logged_in_user(association_id)
except NoResultFound:
return error_response('no such association')
g.association_id = association_id
try:
radlib = unicode(parse(request.form['rad']))
except KeyError as e:
return error_response("no such lib '{0}'".format(e.message))
except ParseError as e:
return error_response(e.message)
return {'status': 'ok', 'radlib': radlib}
def test_deeply_nested_parse_error(self):
libs = {
"Outermost": ["into <Middle>"],
"Middle": ["into <Inner>"],
"Inner": ["into <Broken>"],
"Broken": ["HAY GUISE>"],
}
load_lib = lambda lib_name: libs[lib_name]
with patch("radlibs.parser.load_lib", load_lib):
with assert_raises(ParseError) as error:
unicode(parse("<Outermost>"))
eq_(
error.exception.message,
"Unexpected token '>' at line 1 character 10 of 'HAY GUISE>' "
"(found inside Broken) (found inside Inner) (found inside Middle) "
"(found inside Outermost)",
)
def test_parse_error(self):
plaintext = "error>"
with assert_raises(ParseError) as error:
parse(plaintext)
eq_(error.exception.message, "Unexpected token '>' at line 1 character 6 of 'error>'")
def test_recursion_depth_is_limited(self):
plaintext = "<Song_which_never_ends>"
rad = parse(plaintext)
radlib = unicode(rad)
assert len(radlib) > 3000, radlib
assert len(radlib) < 9000, radlib
def test_literal_angle_brackets(self):
plaintext = "look over there --\>"
rad = parse(plaintext)
eq_(rad, "look over there -->")
def test_libs_and_text_intermingled(self):
plaintext = "the <Animal> ate my <Loot>"
rad = parse(plaintext)
eq_(rad, "the cat ate my blessed longsword")
eq_(rad.children, ["the", " ", "cat", " ", "ate", " ", "my", " ", "blessed longsword"])
def test_just_a_lib(self):
plaintext = "<Animal>"
rad = parse(plaintext)
eq_(unicode(rad), "cat")
eq_(type(rad.children[0]), Lib)
def test_an_empty_string(self):
plaintext = ""
rad = parse(plaintext)
eq_(rad, plaintext)
def test_uppercase_in_the_midst_of_a_string(self):
libs = {"Headline": ["man bites dog"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("the headlines read <!Headline> that day"))
eq_(radlib, "the headlines read MAN BITES DOG that day")
def test_indefinite_article__regular_vowel_beginning(self):
libs = {"Animal": ["aardvark"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("a <Animal>"))
eq_(radlib, "an aardvark")
def test_indefinite_article__vowel_start__many_words(self):
libs = {"Meat": ["aardvark tongue"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("a <Meat>"))
eq_(radlib, "an aardvark tongue")
def test_literal_modifiers(self):
plaintext = "!/&.-"
eq_(unicode(parse(plaintext)), plaintext)
def test_indefinite_article_hour(self):
libs = {"Time_unit": ["hour"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("a <Time_unit>"))
eq_(radlib, "an hour")
def test_modifier__period_is_lowercase_first_word(self):
libs = {"Food": ["PORK BELLY"], "One": ["ONE"], "Outer": ["<One> <Food>"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("<.Outer>"))
eq_(radlib, "oNE PORK BELLY")
def test_modifier__ampersand_is_uppercase_first_word(self):
libs = {"Food": ["pork belly"], "One": ["one"], "Outer": ["<One> <Food>"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("<&Outer>"))
eq_(radlib, "One pork belly")
def test_modifier__slash_is_lowercase(self):
libs = {"Animal": ["ORCA"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("</Animal>"))
eq_(radlib, "orca")
def test_just_a_string(self):
plaintext = "no remorse, 'cause I still remember"
rad = parse(plaintext)
eq_(rad, plaintext)
eq_(type(rad.children[0]), Text)
def test_a_literal_d_not_after_a_lib(self):
plaintext = "betted"
eq_(parse(plaintext), plaintext)
def test_modifier__bang_is_uppercase(self):
libs = {"Animal": ["orca"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("<!Animal>"))
eq_(radlib, "ORCA")
def test_hyphenate(self):
libs = {"Animal": ["death head moth"]}
plaintext = "It was <-Animal>-esque"
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse(plaintext))
eq_(radlib, "It was death-head-moth-esque")
def test_indefinite_article__easy_mode(self):
libs = {"Animal": ["dik-dik"]}
with patch("radlibs.parser.load_lib", lambda lib: libs[lib]):
radlib = unicode(parse("a <Animal>"))
eq_(radlib, "a dik-dik")
