| # coding=utf-8 |
| |
| import os |
| from pathlib import Path |
| import re |
| import shutil |
| |
| import pytest |
| from fontTools import ttLib |
| from fontTools.designspaceLib import ( |
| AxisDescriptor, |
| AxisMappingDescriptor, |
| AxisLabelDescriptor, |
| DesignSpaceDocument, |
| DesignSpaceDocumentError, |
| DiscreteAxisDescriptor, |
| InstanceDescriptor, |
| RuleDescriptor, |
| SourceDescriptor, |
| evaluateRule, |
| posix, |
| processRules, |
| ) |
| from fontTools.designspaceLib.types import Range |
| from fontTools.misc import plistlib |
| |
| from .fixtures import datadir |
| |
| |
| def _axesAsDict(axes): |
| """ |
| Make the axis data we have available in |
| """ |
| axesDict = {} |
| for axisDescriptor in axes: |
| d = { |
| "name": axisDescriptor.name, |
| "tag": axisDescriptor.tag, |
| "minimum": axisDescriptor.minimum, |
| "maximum": axisDescriptor.maximum, |
| "default": axisDescriptor.default, |
| "map": axisDescriptor.map, |
| } |
| axesDict[axisDescriptor.name] = d |
| return axesDict |
| |
| |
| def assert_equals_test_file(path, test_filename): |
| with open(path, encoding="utf-8") as fp: |
| actual = fp.read() |
| |
| test_path = os.path.join(os.path.dirname(__file__), test_filename) |
| with open(test_path, encoding="utf-8") as fp: |
| expected = fp.read() |
| expected = re.sub(r"<!--(.|\n)*?-->", "", expected) |
| expected = re.sub(r"\s*\n+", "\n", expected) |
| |
| assert actual == expected |
| |
| |
| def test_fill_document(tmpdir): |
| tmpdir = str(tmpdir) |
| testDocPath = os.path.join(tmpdir, "test_v4.designspace") |
| testDocPath5 = os.path.join(tmpdir, "test_v5.designspace") |
| masterPath1 = os.path.join(tmpdir, "masters", "masterTest1.ufo") |
| masterPath2 = os.path.join(tmpdir, "masters", "masterTest2.ufo") |
| instancePath1 = os.path.join(tmpdir, "instances", "instanceTest1.ufo") |
| instancePath2 = os.path.join(tmpdir, "instances", "instanceTest2.ufo") |
| doc = DesignSpaceDocument() |
| doc.rulesProcessingLast = True |
| |
| # write some axes |
| a1 = AxisDescriptor() |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| a1.name = "weight" |
| a1.tag = "wght" |
| # note: just to test the element language, not an actual label name recommendations. |
| a1.labelNames["fa-IR"] = "قطر" |
| a1.labelNames["en"] = "Wéíght" |
| doc.addAxis(a1) |
| a2 = AxisDescriptor() |
| a2.minimum = 0 |
| a2.maximum = 1000 |
| a2.default = 15 |
| a2.name = "width" |
| a2.tag = "wdth" |
| a2.map = [(0.0, 10.0), (15.0, 20.0), (401.0, 66.0), (1000.0, 990.0)] |
| a2.hidden = True |
| a2.labelNames["fr"] = "Chasse" |
| doc.addAxis(a2) |
| |
| # add master 1 |
| s1 = SourceDescriptor() |
| s1.filename = os.path.relpath(masterPath1, os.path.dirname(testDocPath)) |
| assert s1.font is None |
| s1.name = "master.ufo1" |
| s1.copyLib = True |
| s1.copyInfo = True |
| s1.copyFeatures = True |
| s1.location = dict(weight=0) |
| s1.familyName = "MasterFamilyName" |
| s1.styleName = "MasterStyleNameOne" |
| s1.mutedGlyphNames.append("A") |
| s1.mutedGlyphNames.append("Z") |
| doc.addSource(s1) |
| # add master 2 |
| s2 = SourceDescriptor() |
| s2.filename = os.path.relpath(masterPath2, os.path.dirname(testDocPath)) |
| s2.name = "master.ufo2" |
| s2.copyLib = False |
| s2.copyInfo = False |
| s2.copyFeatures = False |
| s2.muteKerning = True |
| s2.location = dict(weight=1000) |
| s2.familyName = "MasterFamilyName" |
| s2.styleName = "MasterStyleNameTwo" |
| doc.addSource(s2) |
| # add master 3 from a different layer |
| s3 = SourceDescriptor() |
| s3.filename = os.path.relpath(masterPath2, os.path.dirname(testDocPath)) |
| s3.name = "master.ufo2" |
| s3.copyLib = False |
| s3.copyInfo = False |
| s3.copyFeatures = False |
| s3.muteKerning = False |
| s3.layerName = "supports" |
| s3.location = dict(weight=1000) |
| s3.familyName = "MasterFamilyName" |
| s3.styleName = "Supports" |
| doc.addSource(s3) |
| # add instance 1 |
| i1 = InstanceDescriptor() |
| i1.filename = os.path.relpath(instancePath1, os.path.dirname(testDocPath)) |
| i1.familyName = "InstanceFamilyName" |
| i1.styleName = "InstanceStyleName" |
| i1.name = "instance.ufo1" |
| i1.location = dict( |
| weight=500, spooky=666 |
| ) # this adds a dimension that is not defined. |
| i1.postScriptFontName = "InstancePostscriptName" |
| i1.styleMapFamilyName = "InstanceStyleMapFamilyName" |
| i1.styleMapStyleName = "InstanceStyleMapStyleName" |
| i1.localisedStyleName = dict(fr="Demigras", ja="半ば") |
| i1.localisedFamilyName = dict(fr="Montserrat", ja="モンセラート") |
| i1.localisedStyleMapStyleName = dict(de="Standard") |
| i1.localisedStyleMapFamilyName = dict( |
| de="Montserrat Halbfett", ja="モンセラート SemiBold" |
| ) |
| glyphData = dict(name="arrow", mute=True, unicodes=[0x123, 0x124, 0x125]) |
| i1.glyphs["arrow"] = glyphData |
| i1.lib["com.coolDesignspaceApp.binaryData"] = plistlib.Data(b"<binary gunk>") |
| i1.lib["com.coolDesignspaceApp.specimenText"] = "Hamburgerwhatever" |
| doc.addInstance(i1) |
| # add instance 2 |
| i2 = InstanceDescriptor() |
| i2.filename = os.path.relpath(instancePath2, os.path.dirname(testDocPath)) |
| i2.familyName = "InstanceFamilyName" |
| i2.styleName = "InstanceStyleName" |
| i2.name = "instance.ufo2" |
| # anisotropic location |
| i2.location = dict(weight=500, width=(400, 300)) |
| i2.postScriptFontName = "InstancePostscriptName" |
| i2.styleMapFamilyName = "InstanceStyleMapFamilyName" |
| i2.styleMapStyleName = "InstanceStyleMapStyleName" |
| glyphMasters = [ |
| dict(font="master.ufo1", glyphName="BB", location=dict(width=20, weight=20)), |
| dict(font="master.ufo2", glyphName="CC", location=dict(width=900, weight=900)), |
| ] |
| glyphData = dict(name="arrow", unicodes=[101, 201, 301]) |
| glyphData["masters"] = glyphMasters |
| glyphData["note"] = "A note about this glyph" |
| glyphData["instanceLocation"] = dict(width=100, weight=120) |
| i2.glyphs["arrow"] = glyphData |
| i2.glyphs["arrow2"] = dict(mute=False) |
| doc.addInstance(i2) |
| |
| doc.filename = "suggestedFileName.designspace" |
| doc.lib["com.coolDesignspaceApp.previewSize"] = 30 |
| |
| # write some rules |
| r1 = RuleDescriptor() |
| r1.name = "named.rule.1" |
| r1.conditionSets.append( |
| [ |
| dict(name="axisName_a", minimum=0, maximum=1), |
| dict(name="axisName_b", minimum=2, maximum=3), |
| ] |
| ) |
| r1.subs.append(("a", "a.alt")) |
| doc.addRule(r1) |
| # write the document; without an explicit format it will be 5.0 by default |
| doc.write(testDocPath5) |
| assert os.path.exists(testDocPath5) |
| assert_equals_test_file(testDocPath5, "data/test_v5_original.designspace") |
| # write again with an explicit format = 4.1 |
| doc.formatVersion = "4.1" |
| doc.write(testDocPath) |
| assert os.path.exists(testDocPath) |
| assert_equals_test_file(testDocPath, "data/test_v4_original.designspace") |
| # import it again |
| new = DesignSpaceDocument() |
| new.read(testDocPath) |
| |
| assert new.default.location == {"width": 20.0, "weight": 0.0} |
| assert new.filename == "test_v4.designspace" |
| assert new.lib == doc.lib |
| assert new.instances[0].lib == doc.instances[0].lib |
| |
| # test roundtrip for the axis attributes and data |
| axes = {} |
| for axis in doc.axes: |
| if axis.tag not in axes: |
| axes[axis.tag] = [] |
| axes[axis.tag].append(axis.serialize()) |
| for axis in new.axes: |
| if axis.tag[0] == "_": |
| continue |
| if axis.tag not in axes: |
| axes[axis.tag] = [] |
| axes[axis.tag].append(axis.serialize()) |
| for v in axes.values(): |
| a, b = v |
| assert a == b |
| |
| |
| def test_unicodes(tmpdir): |
| tmpdir = str(tmpdir) |
| testDocPath = os.path.join(tmpdir, "testUnicodes.designspace") |
| testDocPath2 = os.path.join(tmpdir, "testUnicodes_roundtrip.designspace") |
| masterPath1 = os.path.join(tmpdir, "masters", "masterTest1.ufo") |
| masterPath2 = os.path.join(tmpdir, "masters", "masterTest2.ufo") |
| instancePath1 = os.path.join(tmpdir, "instances", "instanceTest1.ufo") |
| instancePath2 = os.path.join(tmpdir, "instances", "instanceTest2.ufo") |
| doc = DesignSpaceDocument() |
| doc.formatVersion = "4.1" # This test about instance glyphs is deprecated in v5 |
| # add master 1 |
| s1 = SourceDescriptor() |
| s1.filename = os.path.relpath(masterPath1, os.path.dirname(testDocPath)) |
| s1.name = "master.ufo1" |
| s1.copyInfo = True |
| s1.location = dict(weight=0) |
| doc.addSource(s1) |
| # add master 2 |
| s2 = SourceDescriptor() |
| s2.filename = os.path.relpath(masterPath2, os.path.dirname(testDocPath)) |
| s2.name = "master.ufo2" |
| s2.location = dict(weight=1000) |
| doc.addSource(s2) |
| # add instance 1 |
| i1 = InstanceDescriptor() |
| i1.filename = os.path.relpath(instancePath1, os.path.dirname(testDocPath)) |
| i1.name = "instance.ufo1" |
| i1.location = dict(weight=500) |
| glyphData = dict(name="arrow", mute=True, unicodes=[100, 200, 300]) |
| i1.glyphs["arrow"] = glyphData |
| doc.addInstance(i1) |
| # now we have sources and instances, but no axes yet. |
| doc.axes = [] # clear the axes |
| # write some axes |
| a1 = AxisDescriptor() |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| a1.name = "weight" |
| a1.tag = "wght" |
| doc.addAxis(a1) |
| # write the document |
| doc.write(testDocPath) |
| assert os.path.exists(testDocPath) |
| # import it again |
| new = DesignSpaceDocument() |
| new.read(testDocPath) |
| new.write(testDocPath2) |
| # compare the file contents |
| with open(testDocPath, "r", encoding="utf-8") as f1: |
| t1 = f1.read() |
| with open(testDocPath2, "r", encoding="utf-8") as f2: |
| t2 = f2.read() |
| assert t1 == t2 |
| # check the unicode values read from the document |
| assert new.instances[0].glyphs["arrow"]["unicodes"] == [100, 200, 300] |
| |
| |
| def test_localisedNames(tmpdir): |
| tmpdir = str(tmpdir) |
| testDocPath = os.path.join(tmpdir, "testLocalisedNames.designspace") |
| testDocPath2 = os.path.join(tmpdir, "testLocalisedNames_roundtrip.designspace") |
| masterPath1 = os.path.join(tmpdir, "masters", "masterTest1.ufo") |
| masterPath2 = os.path.join(tmpdir, "masters", "masterTest2.ufo") |
| instancePath1 = os.path.join(tmpdir, "instances", "instanceTest1.ufo") |
| instancePath2 = os.path.join(tmpdir, "instances", "instanceTest2.ufo") |
| doc = DesignSpaceDocument() |
| # add master 1 |
| s1 = SourceDescriptor() |
| s1.filename = os.path.relpath(masterPath1, os.path.dirname(testDocPath)) |
| s1.name = "master.ufo1" |
| s1.copyInfo = True |
| s1.location = dict(weight=0) |
| doc.addSource(s1) |
| # add master 2 |
| s2 = SourceDescriptor() |
| s2.filename = os.path.relpath(masterPath2, os.path.dirname(testDocPath)) |
| s2.name = "master.ufo2" |
| s2.location = dict(weight=1000) |
| doc.addSource(s2) |
| # add instance 1 |
| i1 = InstanceDescriptor() |
| i1.filename = os.path.relpath(instancePath1, os.path.dirname(testDocPath)) |
| i1.familyName = "Montserrat" |
| i1.styleName = "SemiBold" |
| i1.styleMapFamilyName = "Montserrat SemiBold" |
| i1.styleMapStyleName = "Regular" |
| i1.setFamilyName("Montserrat", "fr") |
| i1.setFamilyName("モンセラート", "ja") |
| i1.setStyleName("Demigras", "fr") |
| i1.setStyleName("半ば", "ja") |
| i1.setStyleMapStyleName("Standard", "de") |
| i1.setStyleMapFamilyName("Montserrat Halbfett", "de") |
| i1.setStyleMapFamilyName("モンセラート SemiBold", "ja") |
| i1.name = "instance.ufo1" |
| i1.location = dict( |
| weight=500, spooky=666 |
| ) # this adds a dimension that is not defined. |
| i1.postScriptFontName = "InstancePostscriptName" |
| glyphData = dict(name="arrow", mute=True, unicodes=[0x123]) |
| i1.glyphs["arrow"] = glyphData |
| doc.addInstance(i1) |
| # now we have sources and instances, but no axes yet. |
| doc.axes = [] # clear the axes |
| # write some axes |
| a1 = AxisDescriptor() |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| a1.name = "weight" |
| a1.tag = "wght" |
| # note: just to test the element language, not an actual label name recommendations. |
| a1.labelNames["fa-IR"] = "قطر" |
| a1.labelNames["en"] = "Wéíght" |
| doc.addAxis(a1) |
| a2 = AxisDescriptor() |
| a2.minimum = 0 |
| a2.maximum = 1000 |
| a2.default = 0 |
| a2.name = "width" |
| a2.tag = "wdth" |
| a2.map = [(0.0, 10.0), (401.0, 66.0), (1000.0, 990.0)] |
| a2.labelNames["fr"] = "Poids" |
| doc.addAxis(a2) |
| # add an axis that is not part of any location to see if that works |
| a3 = AxisDescriptor() |
| a3.minimum = 333 |
| a3.maximum = 666 |
| a3.default = 444 |
| a3.name = "spooky" |
| a3.tag = "spok" |
| a3.map = [(0.0, 10.0), (401.0, 66.0), (1000.0, 990.0)] |
| # doc.addAxis(a3) # uncomment this line to test the effects of default axes values |
| # write some rules |
| r1 = RuleDescriptor() |
| r1.name = "named.rule.1" |
| r1.conditionSets.append( |
| [ |
| dict(name="weight", minimum=200, maximum=500), |
| dict(name="width", minimum=0, maximum=150), |
| ] |
| ) |
| r1.subs.append(("a", "a.alt")) |
| doc.addRule(r1) |
| # write the document |
| doc.write(testDocPath) |
| assert os.path.exists(testDocPath) |
| # import it again |
| new = DesignSpaceDocument() |
| new.read(testDocPath) |
| new.write(testDocPath2) |
| with open(testDocPath, "r", encoding="utf-8") as f1: |
| t1 = f1.read() |
| with open(testDocPath2, "r", encoding="utf-8") as f2: |
| t2 = f2.read() |
| assert t1 == t2 |
| |
| |
| def test_handleNoAxes(tmpdir): |
| tmpdir = str(tmpdir) |
| # test what happens if the designspacedocument has no axes element. |
| testDocPath = os.path.join(tmpdir, "testNoAxes_source.designspace") |
| testDocPath2 = os.path.join(tmpdir, "testNoAxes_recontructed.designspace") |
| masterPath1 = os.path.join(tmpdir, "masters", "masterTest1.ufo") |
| masterPath2 = os.path.join(tmpdir, "masters", "masterTest2.ufo") |
| instancePath1 = os.path.join(tmpdir, "instances", "instanceTest1.ufo") |
| instancePath2 = os.path.join(tmpdir, "instances", "instanceTest2.ufo") |
| |
| # Case 1: No axes element in the document, but there are sources and instances |
| doc = DesignSpaceDocument() |
| |
| for name, value in [("One", 1), ("Two", 2), ("Three", 3)]: |
| a = AxisDescriptor() |
| a.minimum = 0 |
| a.maximum = 1000 |
| a.default = 0 |
| a.name = "axisName%s" % (name) |
| a.tag = "ax_%d" % (value) |
| doc.addAxis(a) |
| |
| # add master 1 |
| s1 = SourceDescriptor() |
| s1.filename = os.path.relpath(masterPath1, os.path.dirname(testDocPath)) |
| s1.name = "master.ufo1" |
| s1.copyLib = True |
| s1.copyInfo = True |
| s1.copyFeatures = True |
| s1.location = dict(axisNameOne=-1000, axisNameTwo=0, axisNameThree=1000) |
| s1.familyName = "MasterFamilyName" |
| s1.styleName = "MasterStyleNameOne" |
| doc.addSource(s1) |
| |
| # add master 2 |
| s2 = SourceDescriptor() |
| s2.filename = os.path.relpath(masterPath2, os.path.dirname(testDocPath)) |
| s2.name = "master.ufo1" |
| s2.copyLib = False |
| s2.copyInfo = False |
| s2.copyFeatures = False |
| s2.location = dict(axisNameOne=1000, axisNameTwo=1000, axisNameThree=0) |
| s2.familyName = "MasterFamilyName" |
| s2.styleName = "MasterStyleNameTwo" |
| doc.addSource(s2) |
| |
| # add instance 1 |
| i1 = InstanceDescriptor() |
| i1.filename = os.path.relpath(instancePath1, os.path.dirname(testDocPath)) |
| i1.familyName = "InstanceFamilyName" |
| i1.styleName = "InstanceStyleName" |
| i1.name = "instance.ufo1" |
| i1.location = dict(axisNameOne=(-1000, 500), axisNameTwo=100) |
| i1.postScriptFontName = "InstancePostscriptName" |
| i1.styleMapFamilyName = "InstanceStyleMapFamilyName" |
| i1.styleMapStyleName = "InstanceStyleMapStyleName" |
| doc.addInstance(i1) |
| |
| doc.write(testDocPath) |
| verify = DesignSpaceDocument() |
| verify.read(testDocPath) |
| verify.write(testDocPath2) |
| |
| |
| def test_pathNameResolve(tmpdir): |
| tmpdir = str(tmpdir) |
| # test how descriptor.path and descriptor.filename are resolved |
| testDocPath1 = os.path.join(tmpdir, "testPathName_case1.designspace") |
| testDocPath2 = os.path.join(tmpdir, "testPathName_case2.designspace") |
| testDocPath3 = os.path.join(tmpdir, "testPathName_case3.designspace") |
| testDocPath4 = os.path.join(tmpdir, "testPathName_case4.designspace") |
| testDocPath5 = os.path.join(tmpdir, "testPathName_case5.designspace") |
| testDocPath6 = os.path.join(tmpdir, "testPathName_case6.designspace") |
| masterPath1 = os.path.join(tmpdir, "masters", "masterTest1.ufo") |
| masterPath2 = os.path.join(tmpdir, "masters", "masterTest2.ufo") |
| instancePath1 = os.path.join(tmpdir, "instances", "instanceTest1.ufo") |
| instancePath2 = os.path.join(tmpdir, "instances", "instanceTest2.ufo") |
| |
| a1 = AxisDescriptor() |
| a1.tag = "TAGA" |
| a1.name = "axisName_a" |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| |
| # Case 1: filename and path are both empty. Nothing to calculate, nothing to put in the file. |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = None |
| s.path = None |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.addSource(s) |
| doc.write(testDocPath1) |
| verify = DesignSpaceDocument() |
| verify.read(testDocPath1) |
| assert verify.sources[0].filename == None |
| assert verify.sources[0].path == None |
| |
| # Case 2: filename is empty, path points somewhere: calculate a new filename. |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = None |
| s.path = masterPath1 |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.addSource(s) |
| doc.write(testDocPath2) |
| verify = DesignSpaceDocument() |
| verify.read(testDocPath2) |
| assert verify.sources[0].filename == "masters/masterTest1.ufo" |
| assert verify.sources[0].path == posix(masterPath1) |
| |
| # Case 3: the filename is set, the path is None. |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = "../somewhere/over/the/rainbow.ufo" |
| s.path = None |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.addSource(s) |
| doc.write(testDocPath3) |
| verify = DesignSpaceDocument() |
| verify.read(testDocPath3) |
| assert verify.sources[0].filename == "../somewhere/over/the/rainbow.ufo" |
| # make the absolute path for filename so we can see if it matches the path |
| p = os.path.abspath( |
| os.path.join(os.path.dirname(testDocPath3), verify.sources[0].filename) |
| ) |
| assert verify.sources[0].path == posix(p) |
| |
| # Case 4: the filename points to one file, the path points to another. The path takes precedence. |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = "../somewhere/over/the/rainbow.ufo" |
| s.path = masterPath1 |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.addSource(s) |
| doc.write(testDocPath4) |
| verify = DesignSpaceDocument() |
| verify.read(testDocPath4) |
| assert verify.sources[0].filename == "masters/masterTest1.ufo" |
| |
| # Case 5: the filename is None, path has a value, update the filename |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = None |
| s.path = masterPath1 |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.addSource(s) |
| doc.write(testDocPath5) # so that the document has a path |
| doc.updateFilenameFromPath() |
| assert doc.sources[0].filename == "masters/masterTest1.ufo" |
| |
| # Case 6: the filename has a value, path has a value, update the filenames with force |
| doc = DesignSpaceDocument() |
| doc.addAxis(a1) |
| s = SourceDescriptor() |
| s.filename = "../somewhere/over/the/rainbow.ufo" |
| s.path = masterPath1 |
| s.copyInfo = True |
| s.location = dict(weight=0) |
| s.familyName = "MasterFamilyName" |
| s.styleName = "MasterStyleNameOne" |
| doc.write(testDocPath5) # so that the document has a path |
| doc.addSource(s) |
| assert doc.sources[0].filename == "../somewhere/over/the/rainbow.ufo" |
| doc.updateFilenameFromPath(force=True) |
| assert doc.sources[0].filename == "masters/masterTest1.ufo" |
| |
| |
| def test_normalise1(): |
| # normalisation of anisotropic locations, clipping |
| doc = DesignSpaceDocument() |
| # write some axes |
| a1 = AxisDescriptor() |
| a1.minimum = -1000 |
| a1.maximum = 1000 |
| a1.default = 0 |
| a1.name = "axisName_a" |
| a1.tag = "TAGA" |
| doc.addAxis(a1) |
| assert doc.normalizeLocation(dict(axisName_a=0)) == {"axisName_a": 0.0} |
| assert doc.normalizeLocation(dict(axisName_a=1000)) == {"axisName_a": 1.0} |
| # clipping beyond max values: |
| assert doc.normalizeLocation(dict(axisName_a=1001)) == {"axisName_a": 1.0} |
| assert doc.normalizeLocation(dict(axisName_a=500)) == {"axisName_a": 0.5} |
| assert doc.normalizeLocation(dict(axisName_a=-1000)) == {"axisName_a": -1.0} |
| assert doc.normalizeLocation(dict(axisName_a=-1001)) == {"axisName_a": -1.0} |
| # anisotropic coordinates normalise to isotropic |
| assert doc.normalizeLocation(dict(axisName_a=(1000, -1000))) == {"axisName_a": 1.0} |
| doc.normalize() |
| r = [] |
| for axis in doc.axes: |
| r.append((axis.name, axis.minimum, axis.default, axis.maximum)) |
| r.sort() |
| assert r == [("axisName_a", -1.0, 0.0, 1.0)] |
| |
| |
| def test_normalise2(): |
| # normalisation with minimum > 0 |
| doc = DesignSpaceDocument() |
| # write some axes |
| a2 = AxisDescriptor() |
| a2.minimum = 100 |
| a2.maximum = 1000 |
| a2.default = 100 |
| a2.name = "axisName_b" |
| doc.addAxis(a2) |
| assert doc.normalizeLocation(dict(axisName_b=0)) == {"axisName_b": 0.0} |
| assert doc.normalizeLocation(dict(axisName_b=1000)) == {"axisName_b": 1.0} |
| # clipping beyond max values: |
| assert doc.normalizeLocation(dict(axisName_b=1001)) == {"axisName_b": 1.0} |
| assert doc.normalizeLocation(dict(axisName_b=500)) == { |
| "axisName_b": 0.4444444444444444 |
| } |
| assert doc.normalizeLocation(dict(axisName_b=-1000)) == {"axisName_b": 0.0} |
| assert doc.normalizeLocation(dict(axisName_b=-1001)) == {"axisName_b": 0.0} |
| # anisotropic coordinates normalise to isotropic |
| assert doc.normalizeLocation(dict(axisName_b=(1000, -1000))) == {"axisName_b": 1.0} |
| assert doc.normalizeLocation(dict(axisName_b=1001)) == {"axisName_b": 1.0} |
| doc.normalize() |
| r = [] |
| for axis in doc.axes: |
| r.append((axis.name, axis.minimum, axis.default, axis.maximum)) |
| r.sort() |
| assert r == [("axisName_b", 0.0, 0.0, 1.0)] |
| |
| |
| def test_normalise3(): |
| # normalisation of negative values, with default == maximum |
| doc = DesignSpaceDocument() |
| # write some axes |
| a3 = AxisDescriptor() |
| a3.minimum = -1000 |
| a3.maximum = 0 |
| a3.default = 0 |
| a3.name = "ccc" |
| doc.addAxis(a3) |
| assert doc.normalizeLocation(dict(ccc=0)) == {"ccc": 0.0} |
| assert doc.normalizeLocation(dict(ccc=1)) == {"ccc": 0.0} |
| assert doc.normalizeLocation(dict(ccc=-1000)) == {"ccc": -1.0} |
| assert doc.normalizeLocation(dict(ccc=-1001)) == {"ccc": -1.0} |
| doc.normalize() |
| r = [] |
| for axis in doc.axes: |
| r.append((axis.name, axis.minimum, axis.default, axis.maximum)) |
| r.sort() |
| assert r == [("ccc", -1.0, 0.0, 0.0)] |
| |
| |
| def test_normalise4(): |
| # normalisation with a map |
| doc = DesignSpaceDocument() |
| # write some axes |
| a4 = AxisDescriptor() |
| a4.minimum = 0 |
| a4.maximum = 1000 |
| a4.default = 0 |
| a4.name = "ddd" |
| a4.map = [(0, 100), (300, 500), (600, 500), (1000, 900)] |
| doc.addAxis(a4) |
| doc.normalize() |
| r = [] |
| for axis in doc.axes: |
| r.append((axis.name, axis.map)) |
| r.sort() |
| assert r == [("ddd", [(0, 0.0), (300, 0.5), (600, 0.5), (1000, 1.0)])] |
| |
| |
| def test_axisMapping(): |
| # note: because designspance lib does not do any actual |
| # processing of the mapping data, we can only check if there data is there. |
| doc = DesignSpaceDocument() |
| # write some axes |
| a4 = AxisDescriptor() |
| a4.minimum = 0 |
| a4.maximum = 1000 |
| a4.default = 0 |
| a4.name = "ddd" |
| a4.map = [(0, 100), (300, 500), (600, 500), (1000, 900)] |
| doc.addAxis(a4) |
| doc.normalize() |
| r = [] |
| for axis in doc.axes: |
| r.append((axis.name, axis.map)) |
| r.sort() |
| assert r == [("ddd", [(0, 0.0), (300, 0.5), (600, 0.5), (1000, 1.0)])] |
| |
| |
| def test_axisMappingsRoundtrip(tmpdir): |
| # tests of axisMappings in a document, roundtripping. |
| |
| tmpdir = str(tmpdir) |
| srcDocPath = (Path(__file__) / "../data/test_avar2.designspace").resolve() |
| testDocPath = os.path.join(tmpdir, "test_avar2.designspace") |
| shutil.copy(srcDocPath, testDocPath) |
| testDocPath2 = os.path.join(tmpdir, "test_avar2_roundtrip.designspace") |
| doc = DesignSpaceDocument() |
| doc.read(testDocPath) |
| assert doc.axisMappings |
| assert len(doc.axisMappings) == 2 |
| assert doc.axisMappings[0].inputLocation == {"Justify": -100.0, "Width": 100.0} |
| |
| # This is a bit of a hack, but it's the only way to make sure |
| # that the save works on Windows if the tempdir and the data |
| # dir are on different drives. |
| for descriptor in doc.sources + doc.instances: |
| descriptor.path = None |
| |
| doc.write(testDocPath2) |
| # verify these results |
| doc2 = DesignSpaceDocument() |
| doc2.read(testDocPath2) |
| assert [mapping.inputLocation for mapping in doc.axisMappings] == [ |
| mapping.inputLocation for mapping in doc2.axisMappings |
| ] |
| assert [mapping.outputLocation for mapping in doc.axisMappings] == [ |
| mapping.outputLocation for mapping in doc2.axisMappings |
| ] |
| assert [mapping.description for mapping in doc.axisMappings] == [ |
| mapping.description for mapping in doc2.axisMappings |
| ] |
| assert [mapping.groupDescription for mapping in doc.axisMappings] == [ |
| mapping.groupDescription for mapping in doc2.axisMappings |
| ] |
| |
| |
| def test_rulesConditions(tmpdir): |
| # tests of rules, conditionsets and conditions |
| r1 = RuleDescriptor() |
| r1.name = "named.rule.1" |
| r1.conditionSets.append( |
| [ |
| dict(name="axisName_a", minimum=0, maximum=1000), |
| dict(name="axisName_b", minimum=0, maximum=3000), |
| ] |
| ) |
| r1.subs.append(("a", "a.alt")) |
| |
| assert evaluateRule(r1, dict(axisName_a=500, axisName_b=0)) == True |
| assert evaluateRule(r1, dict(axisName_a=0, axisName_b=0)) == True |
| assert evaluateRule(r1, dict(axisName_a=1000, axisName_b=0)) == True |
| assert evaluateRule(r1, dict(axisName_a=1000, axisName_b=-100)) == False |
| assert evaluateRule(r1, dict(axisName_a=1000.0001, axisName_b=0)) == False |
| assert evaluateRule(r1, dict(axisName_a=-0.0001, axisName_b=0)) == False |
| assert evaluateRule(r1, dict(axisName_a=-100, axisName_b=0)) == False |
| assert processRules([r1], dict(axisName_a=500, axisName_b=0), ["a", "b", "c"]) == [ |
| "a.alt", |
| "b", |
| "c", |
| ] |
| assert processRules( |
| [r1], dict(axisName_a=500, axisName_b=0), ["a.alt", "b", "c"] |
| ) == ["a.alt", "b", "c"] |
| assert processRules([r1], dict(axisName_a=2000, axisName_b=0), ["a", "b", "c"]) == [ |
| "a", |
| "b", |
| "c", |
| ] |
| |
| # rule with only a maximum |
| r2 = RuleDescriptor() |
| r2.name = "named.rule.2" |
| r2.conditionSets.append([dict(name="axisName_a", maximum=500)]) |
| r2.subs.append(("b", "b.alt")) |
| |
| assert evaluateRule(r2, dict(axisName_a=0)) == True |
| assert evaluateRule(r2, dict(axisName_a=-500)) == True |
| assert evaluateRule(r2, dict(axisName_a=1000)) == False |
| |
| # rule with only a minimum |
| r3 = RuleDescriptor() |
| r3.name = "named.rule.3" |
| r3.conditionSets.append([dict(name="axisName_a", minimum=500)]) |
| r3.subs.append(("c", "c.alt")) |
| |
| assert evaluateRule(r3, dict(axisName_a=0)) == False |
| assert evaluateRule(r3, dict(axisName_a=1000)) == True |
| assert evaluateRule(r3, dict(axisName_a=1000)) == True |
| |
| # rule with only a minimum, maximum in separate conditions |
| r4 = RuleDescriptor() |
| r4.name = "named.rule.4" |
| r4.conditionSets.append( |
| [dict(name="axisName_a", minimum=500), dict(name="axisName_b", maximum=500)] |
| ) |
| r4.subs.append(("c", "c.alt")) |
| |
| assert evaluateRule(r4, dict(axisName_a=1000, axisName_b=0)) == True |
| assert evaluateRule(r4, dict(axisName_a=0, axisName_b=0)) == False |
| assert evaluateRule(r4, dict(axisName_a=1000, axisName_b=1000)) == False |
| |
| |
| def test_rulesDocument(tmpdir): |
| # tests of rules in a document, roundtripping. |
| tmpdir = str(tmpdir) |
| testDocPath = os.path.join(tmpdir, "testRules.designspace") |
| testDocPath2 = os.path.join(tmpdir, "testRules_roundtrip.designspace") |
| doc = DesignSpaceDocument() |
| doc.rulesProcessingLast = True |
| a1 = AxisDescriptor() |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| a1.name = "axisName_a" |
| a1.tag = "TAGA" |
| b1 = AxisDescriptor() |
| b1.minimum = 2000 |
| b1.maximum = 3000 |
| b1.default = 2000 |
| b1.name = "axisName_b" |
| b1.tag = "TAGB" |
| doc.addAxis(a1) |
| doc.addAxis(b1) |
| r1 = RuleDescriptor() |
| r1.name = "named.rule.1" |
| r1.conditionSets.append( |
| [ |
| dict(name="axisName_a", minimum=0, maximum=1000), |
| dict(name="axisName_b", minimum=0, maximum=3000), |
| ] |
| ) |
| r1.subs.append(("a", "a.alt")) |
| # rule with minium and maximum |
| doc.addRule(r1) |
| assert len(doc.rules) == 1 |
| assert len(doc.rules[0].conditionSets) == 1 |
| assert len(doc.rules[0].conditionSets[0]) == 2 |
| assert _axesAsDict(doc.axes) == { |
| "axisName_a": { |
| "map": [], |
| "name": "axisName_a", |
| "default": 0, |
| "minimum": 0, |
| "maximum": 1000, |
| "tag": "TAGA", |
| }, |
| "axisName_b": { |
| "map": [], |
| "name": "axisName_b", |
| "default": 2000, |
| "minimum": 2000, |
| "maximum": 3000, |
| "tag": "TAGB", |
| }, |
| } |
| assert doc.rules[0].conditionSets == [ |
| [ |
| {"minimum": 0, "maximum": 1000, "name": "axisName_a"}, |
| {"minimum": 0, "maximum": 3000, "name": "axisName_b"}, |
| ] |
| ] |
| assert doc.rules[0].subs == [("a", "a.alt")] |
| doc.normalize() |
| assert doc.rules[0].name == "named.rule.1" |
| assert doc.rules[0].conditionSets == [ |
| [ |
| {"minimum": 0.0, "maximum": 1.0, "name": "axisName_a"}, |
| {"minimum": 0.0, "maximum": 1.0, "name": "axisName_b"}, |
| ] |
| ] |
| # still one conditionset |
| assert len(doc.rules[0].conditionSets) == 1 |
| doc.write(testDocPath) |
| # add a stray conditionset |
| _addUnwrappedCondition(testDocPath) |
| doc2 = DesignSpaceDocument() |
| doc2.read(testDocPath) |
| assert doc2.rulesProcessingLast |
| assert len(doc2.axes) == 2 |
| assert len(doc2.rules) == 1 |
| assert len(doc2.rules[0].conditionSets) == 2 |
| doc2.write(testDocPath2) |
| # verify these results |
| # make sure the stray condition is now neatly wrapped in a conditionset. |
| doc3 = DesignSpaceDocument() |
| doc3.read(testDocPath2) |
| assert len(doc3.rules) == 1 |
| assert len(doc3.rules[0].conditionSets) == 2 |
| |
| |
| def _addUnwrappedCondition(path): |
| # only for testing, so we can make an invalid designspace file |
| # older designspace files may have conditions that are not wrapped in a conditionset |
| # These can be read into a new conditionset. |
| with open(path, "r", encoding="utf-8") as f: |
| d = f.read() |
| print(d) |
| d = d.replace( |
| '<rule name="named.rule.1">', |
| '<rule name="named.rule.1">\n\t<condition maximum="22" minimum="33" name="axisName_a" />', |
| ) |
| with open(path, "w", encoding="utf-8") as f: |
| f.write(d) |
| |
| |
| def test_documentLib(tmpdir): |
| # roundtrip test of the document lib with some nested data |
| tmpdir = str(tmpdir) |
| testDocPath1 = os.path.join(tmpdir, "testDocumentLibTest.designspace") |
| doc = DesignSpaceDocument() |
| a1 = AxisDescriptor() |
| a1.tag = "TAGA" |
| a1.name = "axisName_a" |
| a1.minimum = 0 |
| a1.maximum = 1000 |
| a1.default = 0 |
| doc.addAxis(a1) |
| dummyData = dict(a=123, b="äbc", c=[1, 2, 3], d={"a": 123}) |
| dummyKey = "org.fontTools.designspaceLib" |
| doc.lib = {dummyKey: dummyData} |
| doc.write(testDocPath1) |
| new = DesignSpaceDocument() |
| new.read(testDocPath1) |
| assert dummyKey in new.lib |
| assert new.lib[dummyKey] == dummyData |
| |
| |
| def test_updatePaths(tmpdir): |
| doc = DesignSpaceDocument() |
| doc.path = str(tmpdir / "foo" / "bar" / "MyDesignspace.designspace") |
| |
| s1 = SourceDescriptor() |
| doc.addSource(s1) |
| |
| doc.updatePaths() |
| |
| # expect no changes |
| assert s1.path is None |
| assert s1.filename is None |
| |
| name1 = "../masters/Source1.ufo" |
| path1 = posix(str(tmpdir / "foo" / "masters" / "Source1.ufo")) |
| |
| s1.path = path1 |
| s1.filename = None |
| |
| doc.updatePaths() |
| |
| assert s1.path == path1 |
| assert s1.filename == name1 # empty filename updated |
| |
| name2 = "../masters/Source2.ufo" |
| s1.filename = name2 |
| |
| doc.updatePaths() |
| |
| # conflicting filename discarded, path always gets precedence |
| assert s1.path == path1 |
| assert s1.filename == "../masters/Source1.ufo" |
| |
| s1.path = None |
| s1.filename = name2 |
| |
| doc.updatePaths() |
| |
| # expect no changes |
| assert s1.path is None |
| assert s1.filename == name2 |
| |
| |
| def test_read_with_path_object(): |
| source = (Path(__file__) / "../data/test_v4_original.designspace").resolve() |
| assert source.exists() |
| doc = DesignSpaceDocument() |
| doc.read(source) |
| |
| |
| def test_with_with_path_object(tmpdir): |
| tmpdir = str(tmpdir) |
| dest = Path(tmpdir) / "test_v4_original.designspace" |
| doc = DesignSpaceDocument() |
| doc.write(dest) |
| assert dest.exists() |
| |
| |
| def test_findDefault_axis_mapping(): |
| designspace_string = """\ |
| <?xml version='1.0' encoding='UTF-8'?> |
| <designspace format="4.0"> |
| <axes> |
| <axis tag="wght" name="Weight" minimum="100" maximum="800" default="400"> |
| <map input="100" output="20"/> |
| <map input="300" output="40"/> |
| <map input="400" output="80"/> |
| <map input="700" output="126"/> |
| <map input="800" output="170"/> |
| </axis> |
| <axis tag="ital" name="Italic" minimum="0" maximum="1" default="1"/> |
| </axes> |
| <sources> |
| <source filename="Font-Light.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="20"/> |
| <dimension name="Italic" xvalue="0"/> |
| </location> |
| </source> |
| <source filename="Font-Regular.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="80"/> |
| <dimension name="Italic" xvalue="0"/> |
| </location> |
| </source> |
| <source filename="Font-Bold.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="170"/> |
| <dimension name="Italic" xvalue="0"/> |
| </location> |
| </source> |
| <source filename="Font-LightItalic.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="20"/> |
| <dimension name="Italic" xvalue="1"/> |
| </location> |
| </source> |
| <source filename="Font-Italic.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="80"/> |
| <dimension name="Italic" xvalue="1"/> |
| </location> |
| </source> |
| <source filename="Font-BoldItalic.ufo"> |
| <location> |
| <dimension name="Weight" xvalue="170"/> |
| <dimension name="Italic" xvalue="1"/> |
| </location> |
| </source> |
| </sources> |
| </designspace> |
| """ |
| designspace = DesignSpaceDocument.fromstring(designspace_string) |
| assert designspace.findDefault().filename == "Font-Italic.ufo" |
| |
| designspace.axes[1].default = 0 |
| |
| assert designspace.findDefault().filename == "Font-Regular.ufo" |
| |
| |
| def test_loadSourceFonts(): |
| def opener(path): |
| font = ttLib.TTFont() |
| font.importXML(path) |
| return font |
| |
| # this designspace file contains .TTX source paths |
| path = os.path.join( |
| os.path.dirname(os.path.dirname(__file__)), |
| "varLib", |
| "data", |
| "SparseMasters.designspace", |
| ) |
| designspace = DesignSpaceDocument.fromfile(path) |
| |
| # force two source descriptors to have the same path |
| designspace.sources[1].path = designspace.sources[0].path |
| |
| fonts = designspace.loadSourceFonts(opener) |
| |
| assert len(fonts) == 3 |
| assert all(isinstance(font, ttLib.TTFont) for font in fonts) |
| assert fonts[0] is fonts[1] # same path, identical font object |
| |
| fonts2 = designspace.loadSourceFonts(opener) |
| |
| for font1, font2 in zip(fonts, fonts2): |
| assert font1 is font2 |
| |
| |
| def test_loadSourceFonts_no_required_path(): |
| designspace = DesignSpaceDocument() |
| designspace.sources.append(SourceDescriptor()) |
| |
| with pytest.raises(DesignSpaceDocumentError, match="no 'path' attribute"): |
| designspace.loadSourceFonts(lambda p: p) |
| |
| |
| def test_addAxisDescriptor(): |
| ds = DesignSpaceDocument() |
| |
| axis = ds.addAxisDescriptor( |
| name="Weight", tag="wght", minimum=100, default=400, maximum=900 |
| ) |
| |
| assert ds.axes[0] is axis |
| assert isinstance(axis, AxisDescriptor) |
| assert axis.name == "Weight" |
| assert axis.tag == "wght" |
| assert axis.minimum == 100 |
| assert axis.default == 400 |
| assert axis.maximum == 900 |
| |
| |
| def test_addAxisDescriptor(): |
| ds = DesignSpaceDocument() |
| |
| mapping = ds.addAxisMappingDescriptor( |
| inputLocation={"weight": 900, "width": 150}, outputLocation={"weight": 870} |
| ) |
| |
| assert ds.axisMappings[0] is mapping |
| assert isinstance(mapping, AxisMappingDescriptor) |
| assert mapping.inputLocation == {"weight": 900, "width": 150} |
| assert mapping.outputLocation == {"weight": 870} |
| |
| |
| def test_addSourceDescriptor(): |
| ds = DesignSpaceDocument() |
| |
| source = ds.addSourceDescriptor(name="TestSource", location={"Weight": 400}) |
| |
| assert ds.sources[0] is source |
| assert isinstance(source, SourceDescriptor) |
| assert source.name == "TestSource" |
| assert source.location == {"Weight": 400} |
| |
| |
| def test_addInstanceDescriptor(): |
| ds = DesignSpaceDocument() |
| |
| instance = ds.addInstanceDescriptor( |
| name="TestInstance", |
| location={"Weight": 400}, |
| styleName="Regular", |
| styleMapStyleName="regular", |
| ) |
| |
| assert ds.instances[0] is instance |
| assert isinstance(instance, InstanceDescriptor) |
| assert instance.name == "TestInstance" |
| assert instance.location == {"Weight": 400} |
| assert instance.styleName == "Regular" |
| assert instance.styleMapStyleName == "regular" |
| |
| |
| def test_addRuleDescriptor(tmp_path): |
| ds = DesignSpaceDocument() |
| |
| rule = ds.addRuleDescriptor( |
| name="TestRule", |
| conditionSets=[ |
| [ |
| dict(name="Weight", minimum=100, maximum=200), |
| dict(name="Weight", minimum=700, maximum=900), |
| ] |
| ], |
| subs=[("a", "a.alt")], |
| ) |
| |
| assert ds.rules[0] is rule |
| assert isinstance(rule, RuleDescriptor) |
| assert rule.name == "TestRule" |
| assert rule.conditionSets == [ |
| [ |
| dict(name="Weight", minimum=100, maximum=200), |
| dict(name="Weight", minimum=700, maximum=900), |
| ] |
| ] |
| assert rule.subs == [("a", "a.alt")] |
| |
| # Test it doesn't crash. |
| ds.write(tmp_path / "test.designspace") |
| |
| |
| def test_deepcopyExceptFonts(): |
| ds = DesignSpaceDocument() |
| ds.addSourceDescriptor(font=object()) |
| ds.addSourceDescriptor(font=object()) |
| |
| ds_copy = ds.deepcopyExceptFonts() |
| |
| assert ds.tostring() == ds_copy.tostring() |
| assert ds.sources[0].font is ds_copy.sources[0].font |
| assert ds.sources[1].font is ds_copy.sources[1].font |
| |
| |
| def test_Range_post_init(): |
| # test min and max are sorted and default is clamped to either min/max |
| r = Range(minimum=2, maximum=-1, default=-2) |
| assert r.minimum == -1 |
| assert r.maximum == 2 |
| assert r.default == -1 |
| |
| |
| def test_get_axes(datadir: Path) -> None: |
| ds = DesignSpaceDocument.fromfile(datadir / "test_v5.designspace") |
| |
| assert ds.getAxis("Width") is ds.getAxisByTag("wdth") |
| assert ds.getAxis("Italic") is ds.getAxisByTag("ital") |
