def test_escape(s):
pat = XMLFromMarkupPattern(r'\[b]')
s.assertEquals(pat.format(s.a), '[b]')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'\\[b]\\[/b]')
s.assertEquals(pat.format(s.a), r'\<b>\</b>')
s._test_markup(pat.format(s.a))
def test_convenience(s):
pat = XMLFromMarkupPattern(r'[b]foo[/b]')
s.assertEquals(pat.format(s.a), '<b>foo</b>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern('[small ]foo[/small \t]')
s.assertEquals(pat.format(s.a), '<small >foo</small \t>')
s._test_markup(pat.format(s.a))
def test_span(s):
pat = XMLFromMarkupPattern(r'[span]foo[/span]')
s.assertEquals(pat.format(s.a), '<span>foo</span>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'[span weight="bold"]foo[/span]')
s.assertEquals(pat.format(s.a), '<span weight="bold">foo</span>')
s._test_markup(pat.format(s.a))
def test_escape(s):
pat = XMLFromMarkupPattern(r'\[b]')
s.assertEquals(pat.format(s.a), '[b]')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'\\[b]\\[/b]')
s.assertEquals(pat.format(s.a), r'\<b>\</b>')
s._test_markup(pat.format(s.a))
def test_span(s):
pat = XMLFromMarkupPattern(r'[span]foo[/span]')
s.assertEquals(pat.format(s.a), '<span>foo</span>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern(r'[span weight="bold"]foo[/span]')
s.assertEquals(pat.format(s.a), '<span weight="bold">foo</span>')
s._test_markup(pat.format(s.a))
def test_convenience(s):
pat = XMLFromMarkupPattern(r'[b]foo[/b]')
s.assertEquals(pat.format(s.a), '<b>foo</b>')
s._test_markup(pat.format(s.a))
pat = XMLFromMarkupPattern('[small ]foo[/small \t]')
s.assertEquals(pat.format(s.a), '<small >foo</small \t>')
s._test_markup(pat.format(s.a))
def pattern(pat, cap=True, esc=False, markup=False):
"""Return a 'natural' version of the pattern string for human-readable
bits. Assumes all tags in the pattern are present.
"""
from quodlibet.pattern import Pattern, XMLFromPattern, XMLFromMarkupPattern
class Fakesong(dict):
cap = False
def comma(self, key):
return " - ".join(self.list(key))
def list(self, key):
return [tag(k, self.cap) for k in tagsplit(key)]
list_separate = list
def __call__(self, tag, *args):
return 0 if '~#' in tag[:2] else self.comma(tag)
fakesong = Fakesong({'filename': tag('filename', cap)})
fakesong.cap = cap
try:
if markup:
p = XMLFromMarkupPattern(pat)
elif esc:
p = XMLFromPattern(pat)
else:
p = Pattern(pat)
except ValueError:
return _("Invalid pattern")
return p.format(fakesong)
def pattern(pat, cap=True, esc=False, markup=False):
"""Return a 'natural' version of the pattern string for human-readable
bits. Assumes all tags in the pattern are present.
"""
from quodlibet.pattern import Pattern, XMLFromPattern, XMLFromMarkupPattern
class Fakesong(dict):
cap = False
def comma(self, key):
return " - ".join(self.list(key))
def list(self, key):
return [tag(k, self.cap) for k in tagsplit(key)]
list_separate = list
def __call__(self, tag, *args):
return 0 if '~#' in tag[:2] else self.comma(tag)
fakesong = Fakesong({'filename': tag('filename', cap)})
fakesong.cap = cap
try:
if markup:
p = XMLFromMarkupPattern(pat)
elif esc:
p = XMLFromPattern(pat)
else:
p = Pattern(pat)
except ValueError:
return _("Invalid pattern")
return p.format(fakesong)
def test_convenience_invalid(s):
pat = XMLFromMarkupPattern(r'[b foo="1"]')
s.assertEquals(pat.format(s.a), '[b foo="1"]')
s._test_markup(pat.format(s.a))
def test_link(s):
pat = XMLFromMarkupPattern(r'[a href=""]foo[/a]')
s.assertEquals(pat.format(s.a), '<a href="">foo</a>')
def test_convenience_invalid(s):
pat = XMLFromMarkupPattern(r'[b foo="1"]')
s.assertEquals(pat.format(s.a), '[b foo="1"]')
s._test_markup(pat.format(s.a))
def test_link(s):
pat = XMLFromMarkupPattern(r'[a href=""]foo[/a]')
s.assertEquals(pat.format(s.a), '<a href="">foo</a>')
