| import io |
| import itertools |
| from fontTools import ttLib |
| from fontTools.ttLib.tables._g_l_y_f import Glyph |
| from fontTools.fontBuilder import FontBuilder |
| from fontTools.merge import Merger, main as merge_main |
| import difflib |
| import os |
| import re |
| import shutil |
| import sys |
| import tempfile |
| import unittest |
| import pathlib |
| import pytest |
| |
| |
| class MergeIntegrationTest(unittest.TestCase): |
| def setUp(self): |
| self.tempdir = None |
| self.num_tempfiles = 0 |
| |
| def tearDown(self): |
| if self.tempdir: |
| shutil.rmtree(self.tempdir) |
| |
| @staticmethod |
| def getpath(testfile): |
| path, _ = os.path.split(__file__) |
| return os.path.join(path, "data", testfile) |
| |
| def temp_path(self, suffix): |
| if not self.tempdir: |
| self.tempdir = tempfile.mkdtemp() |
| self.num_tempfiles += 1 |
| return os.path.join(self.tempdir, "tmp%d%s" % (self.num_tempfiles, suffix)) |
| |
| IGNORED_LINES_RE = re.compile( |
| "^(<ttFont | <(checkSumAdjustment|created|modified) ).*" |
| ) |
| def read_ttx(self, path): |
| lines = [] |
| with open(path, "r", encoding="utf-8") as ttx: |
| for line in ttx.readlines(): |
| # Elide lines with data that often change. |
| if self.IGNORED_LINES_RE.match(line): |
| lines.append("\n") |
| else: |
| lines.append(line.rstrip() + "\n") |
| return lines |
| |
| def expect_ttx(self, font, expected_ttx, tables=None): |
| path = self.temp_path(suffix=".ttx") |
| font.saveXML(path, tables=tables) |
| actual = self.read_ttx(path) |
| expected = self.read_ttx(expected_ttx) |
| if actual != expected: |
| for line in difflib.unified_diff( |
| expected, actual, fromfile=expected_ttx, tofile=path): |
| sys.stdout.write(line) |
| self.fail("TTX output is different from expected") |
| |
| def compile_font(self, path, suffix): |
| savepath = self.temp_path(suffix=suffix) |
| font = ttLib.TTFont(recalcBBoxes=False, recalcTimestamp=False) |
| font.importXML(path) |
| font.save(savepath, reorderTables=None) |
| return font, savepath |
| |
| # ----- |
| # Tests |
| # ----- |
| |
| def test_merge_cff(self): |
| _, fontpath1 = self.compile_font(self.getpath("CFFFont1.ttx"), ".otf") |
| _, fontpath2 = self.compile_font(self.getpath("CFFFont2.ttx"), ".otf") |
| mergedpath = self.temp_path(".otf") |
| merge_main([fontpath1, fontpath2, "--output-file=%s" % mergedpath]) |
| mergedfont = ttLib.TTFont(mergedpath) |
| self.expect_ttx(mergedfont, self.getpath("CFFFont_expected.ttx")) |
| |
| |
| class gaspMergeUnitTest(unittest.TestCase): |
| def setUp(self): |
| self.merger = Merger() |
| |
| self.table1 = ttLib.newTable('gasp') |
| self.table1.version = 1 |
| self.table1.gaspRange = { |
| 0x8: 0xA , |
| 0x10: 0x5, |
| } |
| |
| self.table2 = ttLib.newTable('gasp') |
| self.table2.version = 1 |
| self.table2.gaspRange = { |
| 0x6: 0xB , |
| 0xFF: 0x4, |
| } |
| |
| self.result = ttLib.newTable('gasp') |
| |
| def test_gasp_merge_basic(self): |
| result = self.result.merge(self.merger, [self.table1, self.table2]) |
| self.assertEqual(result, self.table1) |
| |
| result = self.result.merge(self.merger, [self.table2, self.table1]) |
| self.assertEqual(result, self.table2) |
| |
| def test_gasp_merge_notImplemented(self): |
| result = self.result.merge(self.merger, [NotImplemented, self.table1]) |
| self.assertEqual(result, NotImplemented) |
| |
| result = self.result.merge(self.merger, [self.table1, NotImplemented]) |
| self.assertEqual(result, self.table1) |
| |
| |
| class CmapMergeUnitTest(unittest.TestCase): |
| def setUp(self): |
| self.merger = Merger() |
| self.table1 = ttLib.newTable('cmap') |
| self.table2 = ttLib.newTable('cmap') |
| self.mergedTable = ttLib.newTable('cmap') |
| pass |
| |
| def tearDown(self): |
| pass |
| |
| |
| def makeSubtable(self, format, platformID, platEncID, cmap): |
| module = ttLib.getTableModule('cmap') |
| subtable = module.cmap_classes[format](format) |
| (subtable.platformID, |
| subtable.platEncID, |
| subtable.language, |
| subtable.cmap) = (platformID, platEncID, 0, cmap) |
| return subtable |
| |
| # 4-3-1 table merged with 12-3-10 table with no dupes with codepoints outside BMP |
| def test_cmap_merge_no_dupes(self): |
| table1 = self.table1 |
| table2 = self.table2 |
| mergedTable = self.mergedTable |
| |
| cmap1 = {0x2603: 'SNOWMAN'} |
| table1.tables = [self.makeSubtable(4,3,1, cmap1)] |
| |
| cmap2 = {0x26C4: 'SNOWMAN WITHOUT SNOW'} |
| cmap2Extended = {0x1F93C: 'WRESTLERS'} |
| cmap2Extended.update(cmap2) |
| table2.tables = [self.makeSubtable(4,3,1, cmap2), self.makeSubtable(12,3,10, cmap2Extended)] |
| |
| self.merger.alternateGlyphsPerFont = [{},{}] |
| mergedTable.merge(self.merger, [table1, table2]) |
| |
| expectedCmap = cmap2.copy() |
| expectedCmap.update(cmap1) |
| expectedCmapExtended = cmap2Extended.copy() |
| expectedCmapExtended.update(cmap1) |
| self.assertEqual(mergedTable.numSubTables, 2) |
| self.assertEqual([(table.format, table.platformID, table.platEncID, table.language) for table in mergedTable.tables], |
| [(4,3,1,0),(12,3,10,0)]) |
| self.assertEqual(mergedTable.tables[0].cmap, expectedCmap) |
| self.assertEqual(mergedTable.tables[1].cmap, expectedCmapExtended) |
| |
| # Tests Issue #322 |
| def test_cmap_merge_three_dupes(self): |
| table1 = self.table1 |
| table2 = self.table2 |
| mergedTable = self.mergedTable |
| |
| cmap1 = {0x20: 'space#0', 0xA0: 'space#0'} |
| table1.tables = [self.makeSubtable(4,3,1,cmap1)] |
| cmap2 = {0x20: 'space#1', 0xA0: 'uni00A0#1'} |
| table2.tables = [self.makeSubtable(4,3,1,cmap2)] |
| |
| self.merger.duplicateGlyphsPerFont = [{},{}] |
| mergedTable.merge(self.merger, [table1, table2]) |
| |
| expectedCmap = cmap1.copy() |
| self.assertEqual(mergedTable.numSubTables, 1) |
| table = mergedTable.tables[0] |
| self.assertEqual((table.format, table.platformID, table.platEncID, table.language), (4,3,1,0)) |
| self.assertEqual(table.cmap, expectedCmap) |
| self.assertEqual(self.merger.duplicateGlyphsPerFont, [{}, {'space#0': 'space#1'}]) |
| |
| |
| def _compile(ttFont): |
| buf = io.BytesIO() |
| ttFont.save(buf) |
| buf.seek(0) |
| return buf |
| |
| |
| def _make_fontfile_with_OS2(*, version, **kwargs): |
| upem = 1000 |
| glyphOrder = [".notdef", "a"] |
| cmap = {0x61: "a"} |
| glyphs = {gn: Glyph() for gn in glyphOrder} |
| hmtx = {gn: (500, 0) for gn in glyphOrder} |
| names = {"familyName": "TestOS2", "styleName": "Regular"} |
| |
| fb = FontBuilder(unitsPerEm=upem) |
| fb.setupGlyphOrder(glyphOrder) |
| fb.setupCharacterMap(cmap) |
| fb.setupGlyf(glyphs) |
| fb.setupHorizontalMetrics(hmtx) |
| fb.setupHorizontalHeader() |
| fb.setupNameTable(names) |
| fb.setupOS2(version=version, **kwargs) |
| |
| return _compile(fb.font) |
| |
| |
| def _merge_and_recompile(fontfiles, options=None): |
| merger = Merger(options) |
| merged = merger.merge(fontfiles) |
| buf = _compile(merged) |
| return ttLib.TTFont(buf) |
| |
| |
| @pytest.mark.parametrize( |
| "v1, v2", list(itertools.permutations(range(5+1), 2)) |
| ) |
| def test_merge_OS2_mixed_versions(v1, v2): |
| # https://github.com/fonttools/fonttools/issues/1865 |
| fontfiles = [ |
| _make_fontfile_with_OS2(version=v1), |
| _make_fontfile_with_OS2(version=v2), |
| ] |
| merged = _merge_and_recompile(fontfiles) |
| assert merged["OS/2"].version == max(v1, v2) |
| |
| |
| if __name__ == "__main__": |
| import sys |
| sys.exit(unittest.main()) |
