shadowfacts/fonttools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1469 from khaledhosny/voltlib-coverage

Browse Source 
[voltLib] Return a tuple from parse_coverage_()
This commit is contained in:
Denis Moyogo Jacquerye 2019-02-02 07:45:21 +00:00 committed by GitHub
commit 5e3f3eded1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 108 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Lib/fontTools/voltLib/ast.py
View File

@ -96,15 +96,6 @@ class Enum(Expression):
for e in self.glyphSet(): for e in self.glyphSet():
yield e yield e
def __len__(self):
return len(self.enum)
def __eq__(self, other):
return self.glyphSet() == other.glyphSet()
def __hash__(self):
return hash(self.glyphSet())
def glyphSet(self, groups=None): def glyphSet(self, groups=None):
glyphs = [] glyphs = []
for element in self.enum: for element in self.enum:

9
Lib/fontTools/voltLib/parser.py
View File

@ -96,7 +96,6 @@ class Parser(object):
name = self.expect_string_() name = self.expect_string_()
enum = None enum = None
if self.next_token_ == "ENUM": if self.next_token_ == "ENUM":
self.expect_keyword_("ENUM")
enum = self.parse_enum_() enum = self.parse_enum_()
self.expect_keyword_("END_GROUP") self.expect_keyword_("END_GROUP")
if self.groups_.resolve(name) is not None: if self.groups_.resolve(name) is not None:
@ -499,8 +498,9 @@ class Parser(object):
return unicode_values if unicode_values != [] else None return unicode_values if unicode_values != [] else None
def parse_enum_(self): def parse_enum_(self):
assert self.is_cur_keyword_("ENUM") self.expect_keyword_("ENUM")
enum = self.parse_coverage_() location = self.cur_token_location_
enum = ast.Enum(self.parse_coverage_(), location=location)
self.expect_keyword_("END_ENUM") self.expect_keyword_("END_ENUM")
return enum return enum
@ -509,7 +509,6 @@ class Parser(object):
location = self.cur_token_location_ location = self.cur_token_location_
while self.next_token_ in ("GLYPH", "GROUP", "RANGE", "ENUM"): while self.next_token_ in ("GLYPH", "GROUP", "RANGE", "ENUM"):
if self.next_token_ == "ENUM": if self.next_token_ == "ENUM":
self.advance_lexer_()
enum = self.parse_enum_() enum = self.parse_enum_()
coverage.append(enum) coverage.append(enum)
elif self.next_token_ == "GLYPH": elif self.next_token_ == "GLYPH":
@ -526,7 +525,7 @@ class Parser(object):
self.expect_keyword_("TO") self.expect_keyword_("TO")
end = self.expect_string_() end = self.expect_string_()
coverage.append(ast.Range(start, end, self, location=location)) coverage.append(ast.Range(start, end, self, location=location))
return ast.Enum(coverage, location=location) return tuple(coverage)
def resolve_group(self, group_name): def resolve_group(self, group_name):
return self.groups_.resolve(group_name) return self.groups_.resolve(group_name)

216
Tests/voltLib/parser_test.py
View File

@ -18,6 +18,13 @@ class ParserTest(unittest.TestCase):
if not hasattr(self, "assertRaisesRegex"): if not hasattr(self, "assertRaisesRegex"):
self.assertRaisesRegex = self.assertRaisesRegexp self.assertRaisesRegex = self.assertRaisesRegexp
def assertSubEqual(self, sub, glyph_ref, replacement_ref):
glyphs = [[g.glyph for g in v] for v in sub.mapping.keys()]
replacement = [[g.glyph for g in v] for v in sub.mapping.values()]
self.assertEqual(glyphs, glyph_ref)
self.assertEqual(replacement, replacement_ref)
def test_def_glyph_base(self): def test_def_glyph_base(self):
[def_glyph] = self.parse( [def_glyph] = self.parse(
'DEF_GLYPH ".notdef" ID 0 TYPE BASE END_GLYPH' 'DEF_GLYPH ".notdef" ID 0 TYPE BASE END_GLYPH'
@ -130,7 +137,7 @@ class ParserTest(unittest.TestCase):
"atilde"))) "atilde")))
def test_def_group_groups(self): def test_def_group_groups(self):
parser = self.parser( [group1, group2, test_group] = self.parse(
'DEF_GROUP "Group1"\n' 'DEF_GROUP "Group1"\n'
'ENUM GLYPH "a" GLYPH "b" GLYPH "c" GLYPH "d" END_ENUM\n' 'ENUM GLYPH "a" GLYPH "b" GLYPH "c" GLYPH "d" END_ENUM\n'
'END_GROUP\n' 'END_GROUP\n'
@ -140,16 +147,14 @@ class ParserTest(unittest.TestCase):
'DEF_GROUP "TestGroup"\n' 'DEF_GROUP "TestGroup"\n'
'ENUM GROUP "Group1" GROUP "Group2" END_ENUM\n' 'ENUM GROUP "Group1" GROUP "Group2" END_ENUM\n'
'END_GROUP\n' 'END_GROUP\n'
) ).statements
[group1, group2, test_group] = parser.parse().statements groups = [g.group for g in test_group.enum.enum]
self.assertEqual( self.assertEqual((test_group.name, groups),
(test_group.name, test_group.enum), ("TestGroup", ["Group1", "Group2"]))
("TestGroup",
ast.Enum([ast.GroupName("Group1", parser),
ast.GroupName("Group2", parser)])))
def test_def_group_groups_not_yet_defined(self): def test_def_group_groups_not_yet_defined(self):
parser = self.parser( [group1, test_group1, test_group2, test_group3, group2] = \
self.parse(
'DEF_GROUP "Group1"\n' 'DEF_GROUP "Group1"\n'
'ENUM GLYPH "a" GLYPH "b" GLYPH "c" GLYPH "d" END_ENUM\n' 'ENUM GLYPH "a" GLYPH "b" GLYPH "c" GLYPH "d" END_ENUM\n'
'END_GROUP\n' 'END_GROUP\n'
@ -165,23 +170,19 @@ class ParserTest(unittest.TestCase):
'DEF_GROUP "Group2"\n' 'DEF_GROUP "Group2"\n'
'ENUM GLYPH "e" GLYPH "f" GLYPH "g" GLYPH "h" END_ENUM\n' 'ENUM GLYPH "e" GLYPH "f" GLYPH "g" GLYPH "h" END_ENUM\n'
'END_GROUP\n' 'END_GROUP\n'
) ).statements
[group1, test_group1, test_group2, test_group3, group2] = \ groups = [g.group for g in test_group1.enum.enum]
parser.parse().statements
self.assertEqual( self.assertEqual(
(test_group1.name, test_group1.enum), (test_group1.name, groups),
("TestGroup1", ("TestGroup1", ["Group1", "Group2"]))
ast.Enum([ast.GroupName("Group1", parser), groups = [g.group for g in test_group2.enum.enum]
ast.GroupName("Group2", parser)])))
self.assertEqual( self.assertEqual(
(test_group2.name, test_group2.enum), (test_group2.name, groups),
("TestGroup2", ("TestGroup2", ["Group2"]))
ast.Enum([ast.GroupName("Group2", parser)]))) groups = [g.group for g in test_group3.enum.enum]
self.assertEqual( self.assertEqual(
(test_group3.name, test_group3.enum), (test_group3.name, groups),
("TestGroup3", ("TestGroup3", ["Group2", "Group1"]))
ast.Enum([ast.GroupName("Group2", parser),
ast.GroupName("Group1", parser)])))
# def test_def_group_groups_undefined(self): # def test_def_group_groups_undefined(self):
# with self.assertRaisesRegex( # with self.assertRaisesRegex(
@ -556,12 +557,11 @@ class ParserTest(unittest.TestCase):
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
).statements ).statements
self.assertEqual((lookup.name, list(lookup.sub.mapping.items())), self.assertEqual(lookup.name, "smcp")
("smcp", [(self.enum(["a"]), self.enum(["a.sc"])), self.assertSubEqual(lookup.sub, [["a"], ["b"]], [["a.sc"], ["b.sc"]])
(self.enum(["b"]), self.enum(["b.sc"]))]))
def test_substitution_single_in_context(self): def test_substitution_single_in_context(self):
parser = self.parser( [group, lookup] = self.parse(
'DEF_GROUP "Denominators" ENUM GLYPH "one.dnom" GLYPH "two.dnom" ' 'DEF_GROUP "Denominators" ENUM GLYPH "one.dnom" GLYPH "two.dnom" '
'END_ENUM END_GROUP\n' 'END_ENUM END_GROUP\n'
'DEF_LOOKUP "fracdnom" PROCESS_BASE PROCESS_MARKS ALL ' 'DEF_LOOKUP "fracdnom" PROCESS_BASE PROCESS_MARKS ALL '
@ -577,22 +577,22 @@ class ParserTest(unittest.TestCase):
'WITH GLYPH "two.dnom"\n' 'WITH GLYPH "two.dnom"\n'
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
) ).statements
[group, lookup] = parser.parse().statements
context = lookup.context[0] context = lookup.context[0]
self.assertEqual(
(lookup.name, list(lookup.sub.mapping.items()), self.assertEqual(lookup.name, "fracdnom")
context.ex_or_in, context.left, context.right), self.assertEqual(context.ex_or_in, "IN_CONTEXT")
("fracdnom", self.assertEqual(len(context.left), 1)
[(self.enum(["one"]), self.enum(["one.dnom"])), self.assertEqual(len(context.left[0]), 1)
(self.enum(["two"]), self.enum(["two.dnom"]))], self.assertEqual(len(context.left[0][0].enum), 2)
"IN_CONTEXT", [ast.Enum([ self.assertEqual(context.left[0][0].enum[0].group, "Denominators")
ast.GroupName("Denominators", parser=parser), self.assertEqual(context.left[0][0].enum[1].glyph, "fraction")
ast.GlyphName("fraction")])], []) self.assertEqual(context.right, [])
) self.assertSubEqual(lookup.sub, [["one"], ["two"]],
[["one.dnom"], ["two.dnom"]])
def test_substitution_single_in_contexts(self): def test_substitution_single_in_contexts(self):
parser = self.parser( [group, lookup] = self.parse(
'DEF_GROUP "Hebrew" ENUM GLYPH "uni05D0" GLYPH "uni05D1" ' 'DEF_GROUP "Hebrew" ENUM GLYPH "uni05D0" GLYPH "uni05D1" '
'END_ENUM END_GROUP\n' 'END_ENUM END_GROUP\n'
'DEF_LOOKUP "HebrewCurrency" PROCESS_BASE PROCESS_MARKS ALL ' 'DEF_LOOKUP "HebrewCurrency" PROCESS_BASE PROCESS_MARKS ALL '
@ -610,19 +610,27 @@ class ParserTest(unittest.TestCase):
'WITH GLYPH "dollar.Hebr"\n' 'WITH GLYPH "dollar.Hebr"\n'
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
) ).statements
[group, lookup] = parser.parse().statements
context1 = lookup.context[0] context1 = lookup.context[0]
context2 = lookup.context[1] context2 = lookup.context[1]
self.assertEqual(
(lookup.name, context1.ex_or_in, context1.left, self.assertEqual(lookup.name, "HebrewCurrency")
context1.right, context2.ex_or_in,
context2.left, context2.right), self.assertEqual(context1.ex_or_in, "IN_CONTEXT")
("HebrewCurrency", "IN_CONTEXT", [], self.assertEqual(context1.left, [])
[ast.Enum([ast.GroupName("Hebrew", parser)]), self.assertEqual(len(context1.right), 2)
self.enum(["one.Hebr"])], "IN_CONTEXT", self.assertEqual(len(context1.right[0]), 1)
[ast.Enum([ast.GroupName("Hebrew", parser)]), self.assertEqual(len(context1.right[1]), 1)
self.enum(["one.Hebr"])], [])) self.assertEqual(context1.right[0][0].group, "Hebrew")
self.assertEqual(context1.right[1][0].glyph, "one.Hebr")
self.assertEqual(context2.ex_or_in, "IN_CONTEXT")
self.assertEqual(len(context2.left), 2)
self.assertEqual(len(context2.left[0]), 1)
self.assertEqual(len(context2.left[1]), 1)
self.assertEqual(context2.left[0][0].group, "Hebrew")
self.assertEqual(context2.left[1][0].glyph, "one.Hebr")
self.assertEqual(context2.right, [])
def test_substitution_skip_base(self): def test_substitution_skip_base(self):
[group, lookup] = self.parse( [group, lookup] = self.parse(
@ -787,11 +795,9 @@ class ParserTest(unittest.TestCase):
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
).statements ).statements
self.assertEqual((lookup.name, list(lookup.sub.mapping.items())), self.assertEqual(lookup.name, "ccmp")
("ccmp", self.assertSubEqual(lookup.sub, [["aacute"], ["agrave"]],
[(self.enum(["aacute"]), self.enum(["a", "acutecomb"])), [["a", "acutecomb"], ["a", "gravecomb"]])
(self.enum(["agrave"]), self.enum(["a", "gravecomb"]))]
))
def test_substitution_multiple_to_single(self): def test_substitution_multiple_to_single(self):
[lookup] = self.parse( [lookup] = self.parse(
@ -808,33 +814,12 @@ class ParserTest(unittest.TestCase):
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
).statements ).statements
self.assertEqual((lookup.name, list(lookup.sub.mapping.items())), self.assertEqual(lookup.name, "liga")
("liga", self.assertSubEqual(lookup.sub, [["f", "i"], ["f", "t"]],
[(self.enum(["f", "i"]), self.enum(["f_i"])), [["f_i"], ["f_t"]])
(self.enum(["f", "t"]), self.enum(["f_t"]))]))
def test_substitution_reverse_chaining_single(self): def test_substitution_reverse_chaining_single(self):
parser = self.parser( [lookup] = self.parse(
'DEF_GLYPH "zero" ID 1 UNICODE 48 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "one" ID 2 UNICODE 49 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "two" ID 3 UNICODE 50 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "three" ID 4 UNICODE 51 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "four" ID 5 UNICODE 52 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "five" ID 6 UNICODE 53 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "six" ID 7 UNICODE 54 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "seven" ID 8 UNICODE 55 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "eight" ID 9 UNICODE 56 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "nine" ID 10 UNICODE 57 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "zero.numr" ID 11 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "one.numr" ID 12 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "two.numr" ID 13 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "three.numr" ID 14 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "four.numr" ID 15 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "five.numr" ID 16 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "six.numr" ID 17 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "seven.numr" ID 18 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "eight.numr" ID 19 TYPE BASE END_GLYPH\n'
'DEF_GLYPH "nine.numr" ID 20 TYPE BASE END_GLYPH\n'
'DEF_LOOKUP "numr" PROCESS_BASE PROCESS_MARKS ALL ' 'DEF_LOOKUP "numr" PROCESS_BASE PROCESS_MARKS ALL '
'DIRECTION LTR REVERSAL\n' 'DIRECTION LTR REVERSAL\n'
'IN_CONTEXT\n' 'IN_CONTEXT\n'
@ -848,16 +833,23 @@ class ParserTest(unittest.TestCase):
'WITH RANGE "zero.numr" TO "nine.numr"\n' 'WITH RANGE "zero.numr" TO "nine.numr"\n'
'END_SUB\n' 'END_SUB\n'
'END_SUBSTITUTION' 'END_SUBSTITUTION'
) ).statements
lookup = parser.parse().statements[-1]
self.assertEqual( mapping = lookup.sub.mapping
(lookup.name, lookup.context[0].right, glyphs = [[(r.start, r.end) for r in v] for v in mapping.keys()]
list(lookup.sub.mapping.items())), replacement = [[(r.start, r.end) for r in v] for v in mapping.values()]
("numr",
[(ast.Enum([ast.GlyphName("fraction"), self.assertEqual(lookup.name, "numr")
ast.Range("zero.numr", "nine.numr", parser)]))], self.assertEqual(glyphs, [[('zero', 'nine')]])
[(ast.Enum([ast.Range("zero", "nine", parser)]), self.assertEqual(replacement, [[('zero.numr', 'nine.numr')]])
ast.Enum([ast.Range("zero.numr", "nine.numr", parser)]))]))
self.assertEqual(len(lookup.context[0].right), 1)
self.assertEqual(len(lookup.context[0].right[0]), 1)
enum = lookup.context[0].right[0][0]
self.assertEqual(len(enum.enum), 2)
self.assertEqual(enum.enum[0].glyph, "fraction")
self.assertEqual((enum.enum[1].start, enum.enum[1].end),
('zero.numr', 'nine.numr'))
# GPOS # GPOS
# ATTACH_CURSIVE # ATTACH_CURSIVE
@ -899,11 +891,13 @@ class ParserTest(unittest.TestCase):
'DEF_ANCHOR "top" ON 35 GLYPH e COMPONENT 1 ' 'DEF_ANCHOR "top" ON 35 GLYPH e COMPONENT 1 '
'AT POS DX 215 DY 450 END_POS END_ANCHOR\n' 'AT POS DX 215 DY 450 END_POS END_ANCHOR\n'
).statements ).statements
pos = lookup.pos
coverage = [g.glyph for g in pos.coverage]
coverage_to = [[[g.glyph for g in e], a] for (e, a) in pos.coverage_to]
self.assertEqual( self.assertEqual(
(lookup.name, lookup.pos.coverage, lookup.pos.coverage_to), (lookup.name, coverage, coverage_to),
("anchor_top", self.enum(["a", "e"]), ("anchor_top", ["a", "e"],
[(self.enum(["acutecomb"]), "top"), [[["acutecomb"], "top"], [["gravecomb"], "top"]])
(self.enum(["gravecomb"]), "top")])
) )
self.assertEqual( self.assertEqual(
(anchor1.name, anchor1.gid, anchor1.glyph_name, anchor1.component, (anchor1.name, anchor1.gid, anchor1.glyph_name, anchor1.component,
@ -939,11 +933,11 @@ class ParserTest(unittest.TestCase):
'END_ATTACH\n' 'END_ATTACH\n'
'END_POSITION\n' 'END_POSITION\n'
).statements ).statements
exit = [[g.glyph for g in v] for v in lookup.pos.coverages_exit]
enter = [[g.glyph for g in v] for v in lookup.pos.coverages_enter]
self.assertEqual( self.assertEqual(
(lookup.name, (lookup.name, exit, enter),
lookup.pos.coverages_exit, lookup.pos.coverages_enter), ("SomeLookup", [["a", "b"]], [["c"]])
("SomeLookup",
[self.enum(["a", "b"])], [self.enum(["c"])])
) )
def test_position_adjust_pair(self): def test_position_adjust_pair(self):
@ -961,10 +955,12 @@ class ParserTest(unittest.TestCase):
'END_ADJUST\n' 'END_ADJUST\n'
'END_POSITION\n' 'END_POSITION\n'
).statements ).statements
coverages_1 = [[g.glyph for g in v] for v in lookup.pos.coverages_1]
coverages_2 = [[g.glyph for g in v] for v in lookup.pos.coverages_2]
self.assertEqual( self.assertEqual(
(lookup.name, lookup.pos.coverages_1, lookup.pos.coverages_2, (lookup.name, coverages_1, coverages_2,
lookup.pos.adjust_pair), lookup.pos.adjust_pair),
("kern1", [self.enum(["A"])], [self.enum(["V"])], ("kern1", [["A"]], [["V"]],
{(1, 2): ((-30, None, None, {}, {}, {}), {(1, 2): ((-30, None, None, {}, {}, {}),
(None, None, None, {}, {}, {})), (None, None, None, {}, {}, {})),
(2, 1): ((-30, None, None, {}, {}, {}), (2, 1): ((-30, None, None, {}, {}, {}),
@ -986,11 +982,13 @@ class ParserTest(unittest.TestCase):
'END_ADJUST\n' 'END_ADJUST\n'
'END_POSITION\n' 'END_POSITION\n'
).statements ).statements
pos = lookup.pos
adjust = [[[g.glyph for g in a], b] for (a, b) in pos.adjust_single]
self.assertEqual( self.assertEqual(
(lookup.name, lookup.pos.adjust_single), (lookup.name, adjust),
("TestLookup", ("TestLookup",
[(self.enum(["glyph1"]), (0, 123, None, {}, {}, {})), [[["glyph1"], (0, 123, None, {}, {}, {})],
(self.enum(["glyph2"]), (0, 456, None, {}, {}, {}))]) [["glyph2"], (0, 456, None, {}, {}, {})]])
) )
def test_def_anchor(self): def test_def_anchor(self):
@ -1129,20 +1127,14 @@ class ParserTest(unittest.TestCase):
if self.tempdir: if self.tempdir:
shutil.rmtree(self.tempdir) shutil.rmtree(self.tempdir)
def parser(self, text): def parse(self, text):
if not self.tempdir: if not self.tempdir:
self.tempdir = tempfile.mkdtemp() self.tempdir = tempfile.mkdtemp()
self.num_tempfiles += 1 self.num_tempfiles += 1
path = os.path.join(self.tempdir, "tmp%d.vtp" % self.num_tempfiles) path = os.path.join(self.tempdir, "tmp%d.vtp" % self.num_tempfiles)
with open(path, "w") as outfile: with open(path, "w") as outfile:
outfile.write(text) outfile.write(text)
return Parser(path) return Parser(path).parse()
def parse(self, text):
return self.parser(text).parse()
def enum(self, glyphs):
return ast.Enum([ast.GlyphName(g) for g in glyphs])
if __name__ == "__main__": if __name__ == "__main__":
import sys import sys