| import logging |
| import os |
| import tempfile |
| import shutil |
| import unittest |
| from pathlib import Path |
| from io import open |
| from .testSupport import getDemoFontGlyphSetPath |
| from fontTools.ufoLib.glifLib import ( |
| GlyphSet, |
| glyphNameToFileName, |
| readGlyphFromString, |
| writeGlyphToString, |
| ) |
| from fontTools.ufoLib.errors import ( |
| GlifLibError, |
| UnsupportedGLIFFormat, |
| UnsupportedUFOFormat, |
| ) |
| from fontTools.misc.etree import XML_DECLARATION |
| from fontTools.pens.recordingPen import RecordingPointPen |
| import pytest |
| |
| GLYPHSETDIR = getDemoFontGlyphSetPath() |
| |
| |
| class GlyphSetTests(unittest.TestCase): |
| def setUp(self): |
| self.dstDir = tempfile.mktemp() |
| os.mkdir(self.dstDir) |
| |
| def tearDown(self): |
| shutil.rmtree(self.dstDir) |
| |
| def testRoundTrip(self): |
| import difflib |
| |
| srcDir = GLYPHSETDIR |
| dstDir = self.dstDir |
| src = GlyphSet( |
| srcDir, ufoFormatVersion=2, validateRead=True, validateWrite=True |
| ) |
| dst = GlyphSet( |
| dstDir, ufoFormatVersion=2, validateRead=True, validateWrite=True |
| ) |
| for glyphName in src.keys(): |
| g = src[glyphName] |
| g.drawPoints(None) # load attrs |
| dst.writeGlyph(glyphName, g, g.drawPoints) |
| # compare raw file data: |
| for glyphName in sorted(src.keys()): |
| fileName = src.contents[glyphName] |
| with open(os.path.join(srcDir, fileName), "r") as f: |
| org = f.read() |
| with open(os.path.join(dstDir, fileName), "r") as f: |
| new = f.read() |
| added = [] |
| removed = [] |
| for line in difflib.unified_diff(org.split("\n"), new.split("\n")): |
| if line.startswith("+ "): |
| added.append(line[1:]) |
| elif line.startswith("- "): |
| removed.append(line[1:]) |
| self.assertEqual( |
| added, removed, "%s.glif file differs after round tripping" % glyphName |
| ) |
| |
| def testContentsExist(self): |
| with self.assertRaises(GlifLibError): |
| GlyphSet( |
| self.dstDir, |
| ufoFormatVersion=2, |
| validateRead=True, |
| validateWrite=True, |
| expectContentsFile=True, |
| ) |
| |
| def testRebuildContents(self): |
| gset = GlyphSet(GLYPHSETDIR, validateRead=True, validateWrite=True) |
| contents = gset.contents |
| gset.rebuildContents() |
| self.assertEqual(contents, gset.contents) |
| |
| def testReverseContents(self): |
| gset = GlyphSet(GLYPHSETDIR, validateRead=True, validateWrite=True) |
| d = {} |
| for k, v in gset.getReverseContents().items(): |
| d[v] = k |
| org = {} |
| for k, v in gset.contents.items(): |
| org[k] = v.lower() |
| self.assertEqual(d, org) |
| |
| def testReverseContents2(self): |
| src = GlyphSet(GLYPHSETDIR, validateRead=True, validateWrite=True) |
| dst = GlyphSet(self.dstDir, validateRead=True, validateWrite=True) |
| dstMap = dst.getReverseContents() |
| self.assertEqual(dstMap, {}) |
| for glyphName in src.keys(): |
| g = src[glyphName] |
| g.drawPoints(None) # load attrs |
| dst.writeGlyph(glyphName, g, g.drawPoints) |
| self.assertNotEqual(dstMap, {}) |
| srcMap = dict(src.getReverseContents()) # copy |
| self.assertEqual(dstMap, srcMap) |
| del srcMap["a.glif"] |
| dst.deleteGlyph("a") |
| self.assertEqual(dstMap, srcMap) |
| |
| def testCustomFileNamingScheme(self): |
| def myGlyphNameToFileName(glyphName, glyphSet): |
| return "prefix" + glyphNameToFileName(glyphName, glyphSet) |
| |
| src = GlyphSet(GLYPHSETDIR, validateRead=True, validateWrite=True) |
| dst = GlyphSet( |
| self.dstDir, myGlyphNameToFileName, validateRead=True, validateWrite=True |
| ) |
| for glyphName in src.keys(): |
| g = src[glyphName] |
| g.drawPoints(None) # load attrs |
| dst.writeGlyph(glyphName, g, g.drawPoints) |
| d = {} |
| for k, v in src.contents.items(): |
| d[k] = "prefix" + v |
| self.assertEqual(d, dst.contents) |
| |
| def testGetUnicodes(self): |
| src = GlyphSet(GLYPHSETDIR, validateRead=True, validateWrite=True) |
| unicodes = src.getUnicodes() |
| for glyphName in src.keys(): |
| g = src[glyphName] |
| g.drawPoints(None) # load attrs |
| if not hasattr(g, "unicodes"): |
| self.assertEqual(unicodes[glyphName], []) |
| else: |
| self.assertEqual(g.unicodes, unicodes[glyphName]) |
| |
| def testReadGlyphInvalidXml(self): |
| """Test that calling readGlyph() to read a .glif with invalid XML raises |
| a library error, instead of an exception from the XML dependency that is |
| used internally. In addition, check that the raised exception describes |
| the glyph by name and gives the location of the broken .glif file.""" |
| |
| # Create a glyph set with three empty glyphs. |
| glyph_set = GlyphSet(self.dstDir) |
| glyph_set.writeGlyph("a", _Glyph()) |
| glyph_set.writeGlyph("b", _Glyph()) |
| glyph_set.writeGlyph("c", _Glyph()) |
| |
| # Corrupt the XML of /c. |
| invalid_xml = b"<abc></def>" |
| Path(self.dstDir, glyph_set.contents["c"]).write_bytes(invalid_xml) |
| |
| # Confirm that reading /a and /b is fine... |
| glyph_set.readGlyph("a", _Glyph()) |
| glyph_set.readGlyph("b", _Glyph()) |
| |
| # ...but that reading /c raises a descriptive library error. |
| expected_message = ( |
| r"GLIF contains invalid XML\.\n" |
| r"The issue is in glyph 'c', located in '.*c\.glif.*\." |
| ) |
| with pytest.raises(GlifLibError, match=expected_message): |
| glyph_set.readGlyph("c", _Glyph()) |
| |
| |
| class FileNameTest: |
| def test_default_file_name_scheme(self): |
| assert glyphNameToFileName("a", None) == "a.glif" |
| assert glyphNameToFileName("A", None) == "A_.glif" |
| assert glyphNameToFileName("Aring", None) == "A_ring.glif" |
| assert glyphNameToFileName("F_A_B", None) == "F__A__B_.glif" |
| assert glyphNameToFileName("A.alt", None) == "A_.alt.glif" |
| assert glyphNameToFileName("A.Alt", None) == "A_.A_lt.glif" |
| assert glyphNameToFileName(".notdef", None) == "_notdef.glif" |
| assert glyphNameToFileName("T_H", None) == "T__H_.glif" |
| assert glyphNameToFileName("T_h", None) == "T__h.glif" |
| assert glyphNameToFileName("t_h", None) == "t_h.glif" |
| assert glyphNameToFileName("F_F_I", None) == "F__F__I_.glif" |
| assert glyphNameToFileName("f_f_i", None) == "f_f_i.glif" |
| assert glyphNameToFileName("AE", None) == "A_E_.glif" |
| assert glyphNameToFileName("Ae", None) == "A_e.glif" |
| assert glyphNameToFileName("ae", None) == "ae.glif" |
| assert glyphNameToFileName("aE", None) == "aE_.glif" |
| assert glyphNameToFileName("a.alt", None) == "a.alt.glif" |
| assert glyphNameToFileName("A.aLt", None) == "A_.aL_t.glif" |
| assert glyphNameToFileName("A.alT", None) == "A_.alT_.glif" |
| assert glyphNameToFileName("Aacute_V.swash", None) == "A_acute_V_.swash.glif" |
| assert glyphNameToFileName(".notdef", None) == "_notdef.glif" |
| assert glyphNameToFileName("con", None) == "_con.glif" |
| assert glyphNameToFileName("CON", None) == "C_O_N_.glif" |
| assert glyphNameToFileName("con.alt", None) == "_con.alt.glif" |
| assert glyphNameToFileName("alt.con", None) == "alt._con.glif" |
| |
| def test_conflicting_case_insensitive_file_names(self, tmp_path): |
| src = GlyphSet(GLYPHSETDIR) |
| dst = GlyphSet(tmp_path) |
| glyph = src["a"] |
| |
| dst.writeGlyph("a", glyph) |
| dst.writeGlyph("A", glyph) |
| dst.writeGlyph("a_", glyph) |
| dst.deleteGlyph("a_") |
| dst.writeGlyph("a_", glyph) |
| dst.writeGlyph("A_", glyph) |
| dst.writeGlyph("i_j", glyph) |
| |
| assert dst.contents == { |
| "a": "a.glif", |
| "A": "A_.glif", |
| "a_": "a_000000000000001.glif", |
| "A_": "A__.glif", |
| "i_j": "i_j.glif", |
| } |
| |
| # make sure filenames are unique even on case-insensitive filesystems |
| assert len({fileName.lower() for fileName in dst.contents.values()}) == 5 |
| |
| |
| class _Glyph: |
| pass |
| |
| |
| class ReadWriteFuncTest: |
| def test_roundtrip(self): |
| glyph = _Glyph() |
| glyph.name = "a" |
| glyph.unicodes = [0x0061] |
| |
| s1 = writeGlyphToString(glyph.name, glyph) |
| |
| glyph2 = _Glyph() |
| readGlyphFromString(s1, glyph2) |
| assert glyph.__dict__ == glyph2.__dict__ |
| |
| s2 = writeGlyphToString(glyph2.name, glyph2) |
| assert s1 == s2 |
| |
| def test_xml_declaration(self): |
| s = writeGlyphToString("a", _Glyph()) |
| assert s.startswith(XML_DECLARATION % "UTF-8") |
| |
| def test_parse_xml_remove_comments(self): |
| s = b"""<?xml version='1.0' encoding='UTF-8'?> |
| <!-- a comment --> |
| <glyph name="A" format="2"> |
| <advance width="1290"/> |
| <unicode hex="0041"/> |
| <!-- another comment --> |
| </glyph> |
| """ |
| |
| g = _Glyph() |
| readGlyphFromString(s, g) |
| |
| assert g.name == "A" |
| assert g.width == 1290 |
| assert g.unicodes == [0x0041] |
| |
| def test_read_invalid_xml(self): |
| """Test that calling readGlyphFromString() with invalid XML raises a |
| library error, instead of an exception from the XML dependency that is |
| used internally.""" |
| |
| invalid_xml = b"<abc></def>" |
| empty_glyph = _Glyph() |
| |
| with pytest.raises(GlifLibError, match="GLIF contains invalid XML"): |
| readGlyphFromString(invalid_xml, empty_glyph) |
| |
| def test_read_unsupported_format_version(self, caplog): |
| s = """<?xml version='1.0' encoding='utf-8'?> |
| <glyph name="A" format="0" formatMinor="0"> |
| <advance width="500"/> |
| <unicode hex="0041"/> |
| </glyph> |
| """ |
| |
| with pytest.raises(UnsupportedGLIFFormat): |
| readGlyphFromString(s, _Glyph()) # validate=True by default |
| |
| with pytest.raises(UnsupportedGLIFFormat): |
| readGlyphFromString(s, _Glyph(), validate=True) |
| |
| caplog.clear() |
| with caplog.at_level(logging.WARNING, logger="fontTools.ufoLib.glifLib"): |
| readGlyphFromString(s, _Glyph(), validate=False) |
| |
| assert len(caplog.records) == 1 |
| assert "Unsupported GLIF format" in caplog.text |
| assert "Assuming the latest supported version" in caplog.text |
| |
| def test_read_allow_format_versions(self): |
| s = """<?xml version='1.0' encoding='utf-8'?> |
| <glyph name="A" format="2"> |
| <advance width="500"/> |
| <unicode hex="0041"/> |
| </glyph> |
| """ |
| |
| # these two calls are are equivalent |
| readGlyphFromString(s, _Glyph(), formatVersions=[1, 2]) |
| readGlyphFromString(s, _Glyph(), formatVersions=[(1, 0), (2, 0)]) |
| |
| # if at least one supported formatVersion, unsupported ones are ignored |
| readGlyphFromString(s, _Glyph(), formatVersions=[(2, 0), (123, 456)]) |
| |
| with pytest.raises( |
| ValueError, match="None of the requested GLIF formatVersions are supported" |
| ): |
| readGlyphFromString(s, _Glyph(), formatVersions=[0, 2001]) |
| |
| with pytest.raises(GlifLibError, match="Forbidden GLIF format version"): |
| readGlyphFromString(s, _Glyph(), formatVersions=[1]) |
| |
| def test_read_ensure_x_y(self): |
| """Ensure that a proper GlifLibError is raised when point coordinates are |
| missing, regardless of validation setting.""" |
| |
| s = """<?xml version='1.0' encoding='utf-8'?> |
| <glyph name="A" format="2"> |
| <outline> |
| <contour> |
| <point x="545" y="0" type="line"/> |
| <point x="638" type="line"/> |
| </contour> |
| </outline> |
| </glyph> |
| """ |
| pen = RecordingPointPen() |
| |
| with pytest.raises(GlifLibError, match="Required y attribute"): |
| readGlyphFromString(s, _Glyph(), pen) |
| |
| with pytest.raises(GlifLibError, match="Required y attribute"): |
| readGlyphFromString(s, _Glyph(), pen, validate=False) |
| |
| |
| def test_GlyphSet_unsupported_ufoFormatVersion(tmp_path, caplog): |
| with pytest.raises(UnsupportedUFOFormat): |
| GlyphSet(tmp_path, ufoFormatVersion=0) |
| with pytest.raises(UnsupportedUFOFormat): |
| GlyphSet(tmp_path, ufoFormatVersion=(0, 1)) |
| |
| |
| def test_GlyphSet_writeGlyph_formatVersion(tmp_path): |
| src = GlyphSet(GLYPHSETDIR) |
| dst = GlyphSet(tmp_path, ufoFormatVersion=(2, 0)) |
| glyph = src["A"] |
| |
| # no explicit formatVersion passed: use the more recent GLIF formatVersion |
| # that is supported by given ufoFormatVersion (GLIF 1 for UFO 2) |
| dst.writeGlyph("A", glyph) |
| glif = dst.getGLIF("A") |
| assert b'format="1"' in glif |
| assert b"formatMinor" not in glif # omitted when 0 |
| |
| # explicit, unknown formatVersion |
| with pytest.raises(UnsupportedGLIFFormat): |
| dst.writeGlyph("A", glyph, formatVersion=(0, 0)) |
| |
| # explicit, known formatVersion but unsupported by given ufoFormatVersion |
| with pytest.raises( |
| UnsupportedGLIFFormat, |
| match="Unsupported GLIF format version .*for UFO format version", |
| ): |
| dst.writeGlyph("A", glyph, formatVersion=(2, 0)) |
