fonttools 4.56.0__cp312-cp312-musllinux_1_2_aarch64.whl → 4.58.0__cp312-cp312-musllinux_1_2_aarch64.whl

fontTools/designspaceLib/statNames.py

@@ -12,14 +12,13 @@ instance:
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
+from typing import Dict, Literal, Optional, Tuple, Union
 import logging
 
 from fontTools.designspaceLib import (
     AxisDescriptor,
     AxisLabelDescriptor,
     DesignSpaceDocument,
-    DesignSpaceDocumentError,
     DiscreteAxisDescriptor,
     SimpleLocationDict,
     SourceDescriptor,
@@ -27,9 +26,13 @@ from fontTools.designspaceLib import (
 
 LOGGER = logging.getLogger(__name__)
 
-# TODO(Python 3.8): use Literal
-# RibbiStyleName = Union[Literal["regular"], Literal["bold"], Literal["italic"], Literal["bold italic"]]
-RibbiStyle = str
+RibbiStyleName = Union[
+    Literal["regular"],
+    Literal["bold"],
+    Literal["italic"],
+    Literal["bold italic"],
+]
+
 BOLD_ITALIC_TO_RIBBI_STYLE = {
     (False, False): "regular",
     (False, True): "italic",
@@ -46,7 +49,7 @@ class StatNames:
     styleNames: Dict[str, str]
     postScriptFontName: Optional[str]
     styleMapFamilyNames: Dict[str, str]
-    styleMapStyleName: Optional[RibbiStyle]
+    styleMapStyleName: Optional[RibbiStyleName]
 
 
 def getStatNames(
@@ -61,6 +64,10 @@ def getStatNames(
     localized names will be empty (family and style names), or the name will be
     None (PostScript name).
 
+    Note: this method does not consider info attached to the instance, like
+    family name. The user needs to override all names on an instance that STAT
+    information would compute differently than desired.
+
     .. versionadded:: 5.0
     """
     familyNames: Dict[str, str] = {}
@@ -201,7 +208,7 @@ def _getAxisLabelsForUserLocation(
 
 def _getRibbiStyle(
     self: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> Tuple[RibbiStyle, SimpleLocationDict]:
+) -> Tuple[RibbiStyleName, SimpleLocationDict]:
     """Compute the RIBBI style name of the given user location,
     return the location of the matching Regular in the RIBBI group.
 

fontTools/feaLib/ast.py

@@ -337,6 +337,76 @@ class AnonymousBlock(Statement):
         return res
 
 
+def _upgrade_mixed_subst_statements(statements):
+    # https://github.com/fonttools/fonttools/issues/612
+    # A multiple substitution may have a single destination, in which case
+    # it will look just like a single substitution. So if there are both
+    # multiple and single substitutions, upgrade all the single ones to
+    # multiple substitutions. Similarly, a ligature substitution may have a
+    # single source glyph, so if there are both ligature and single
+    # substitutions, upgrade all the single ones to ligature substitutions.
+
+    has_single = False
+    has_multiple = False
+    has_ligature = False
+    for s in statements:
+        if isinstance(s, SingleSubstStatement):
+            has_single = not any([s.prefix, s.suffix, s.forceChain])
+        elif isinstance(s, MultipleSubstStatement):
+            has_multiple = not any([s.prefix, s.suffix, s.forceChain])
+        elif isinstance(s, LigatureSubstStatement):
+            has_ligature = not any([s.prefix, s.suffix, s.forceChain])
+
+    to_multiple = False
+    to_ligature = False
+
+    # If we have mixed single and multiple substitutions,
+    # upgrade all single substitutions to multiple substitutions.
+    if has_single and has_multiple and not has_ligature:
+        to_multiple = True
+
+    # If we have mixed single and ligature substitutions,
+    # upgrade all single substitutions to ligature substitutions.
+    elif has_single and has_ligature and not has_multiple:
+        to_ligature = True
+
+    if to_multiple or to_ligature:
+        ret = []
+        for s in statements:
+            if isinstance(s, SingleSubstStatement):
+                glyphs = s.glyphs[0].glyphSet()
+                replacements = s.replacements[0].glyphSet()
+                if len(replacements) == 1:
+                    replacements *= len(glyphs)
+                for glyph, replacement in zip(glyphs, replacements):
+                    if to_multiple:
+                        ret.append(
+                            MultipleSubstStatement(
+                                s.prefix,
+                                glyph,
+                                s.suffix,
+                                [replacement],
+                                s.forceChain,
+                                location=s.location,
+                            )
+                        )
+                    elif to_ligature:
+                        ret.append(
+                            LigatureSubstStatement(
+                                s.prefix,
+                                [GlyphName(glyph)],
+                                s.suffix,
+                                replacement,
+                                s.forceChain,
+                                location=s.location,
+                            )
+                        )
+            else:
+                ret.append(s)
+        return ret
+    return statements
+
+
 class Block(Statement):
     """A block of statements: feature, lookup, etc."""
 
@@ -348,7 +418,8 @@ class Block(Statement):
         """When handed a 'builder' object of comparable interface to
         :class:`fontTools.feaLib.builder`, walks the statements in this
         block, calling the builder callbacks."""
-        for s in self.statements:
+        statements = _upgrade_mixed_subst_statements(self.statements)
+        for s in statements:
             s.build(builder)
 
     def asFea(self, indent=""):
@@ -382,8 +453,7 @@ class FeatureBlock(Block):
     def build(self, builder):
         """Call the ``start_feature`` callback on the builder object, visit
         all the statements in this feature, and then call ``end_feature``."""
-        # TODO(sascha): Handle use_extension.
-        builder.start_feature(self.location, self.name)
+        builder.start_feature(self.location, self.name, self.use_extension)
         # language exclude_dflt statements modify builder.features_
         # limit them to this block with temporary builder.features_
         features = builder.features_
@@ -433,8 +503,7 @@ class LookupBlock(Block):
         self.name, self.use_extension = name, use_extension
 
     def build(self, builder):
-        # TODO(sascha): Handle use_extension.
-        builder.start_lookup_block(self.location, self.name)
+        builder.start_lookup_block(self.location, self.name, self.use_extension)
         Block.build(self, builder)
         builder.end_lookup_block()
 
@@ -753,7 +822,7 @@ class ChainContextPosStatement(Statement):
             if len(self.suffix):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
-            res += " ".join(map(asFea, self.glyph))
+            res += " ".join(map(asFea, self.glyphs))
         res += ";"
         return res
 
@@ -811,7 +880,7 @@ class ChainContextSubstStatement(Statement):
             if len(self.suffix):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
-            res += " ".join(map(asFea, self.glyph))
+            res += " ".join(map(asFea, self.glyphs))
         res += ";"
         return res
 
@@ -1512,7 +1581,9 @@ class SinglePosStatement(Statement):
                 res += " ".join(map(asFea, self.prefix)) + " "
             res += " ".join(
                 [
-                    asFea(x[0]) + "'" + ((" " + x[1].asFea()) if x[1] else "")
+                    asFea(x[0])
+                    + "'"
+                    + ((" " + x[1].asFea()) if x[1] is not None else "")
                     for x in self.pos
                 ]
             )
@@ -1520,7 +1591,10 @@ class SinglePosStatement(Statement):
                 res += " " + " ".join(map(asFea, self.suffix))
         else:
             res += " ".join(
-                [asFea(x[0]) + " " + (x[1].asFea() if x[1] else "") for x in self.pos]
+                [
+                    asFea(x[0]) + " " + (x[1].asFea() if x[1] is not None else "")
+                    for x in self.pos
+                ]
             )
         res += ";"
         return res
@@ -1828,15 +1902,16 @@ class BaseAxis(Statement):
     """An axis definition, being either a ``VertAxis.BaseTagList/BaseScriptList``
     pair or a ``HorizAxis.BaseTagList/BaseScriptList`` pair."""
 
-    def __init__(self, bases, scripts, vertical, location=None):
+    def __init__(self, bases, scripts, vertical, minmax=None, location=None):
         Statement.__init__(self, location)
         self.bases = bases  #: A list of baseline tag names as strings
         self.scripts = scripts  #: A list of script record tuplets (script tag, default baseline tag, base coordinate)
         self.vertical = vertical  #: Boolean; VertAxis if True, HorizAxis if False
+        self.minmax = []  #: A set of minmax record
 
     def build(self, builder):
         """Calls the builder object's ``set_base_axis`` callback."""
-        builder.set_base_axis(self.bases, self.scripts, self.vertical)
+        builder.set_base_axis(self.bases, self.scripts, self.vertical, self.minmax)
 
     def asFea(self, indent=""):
         direction = "Vert" if self.vertical else "Horiz"
@@ -1844,9 +1919,13 @@ class BaseAxis(Statement):
             "{} {} {}".format(a[0], a[1], " ".join(map(str, a[2])))
             for a in self.scripts
         ]
+        minmaxes = [
+            "\n{}Axis.MinMax {} {} {}, {};".format(direction, a[0], a[1], a[2], a[3])
+            for a in self.minmax
+        ]
         return "{}Axis.BaseTagList {};\n{}{}Axis.BaseScriptList {};".format(
             direction, " ".join(self.bases), indent, direction, ", ".join(scripts)
-        )
+        ) + "\n".join(minmaxes)
 
 
 class OS2Field(Statement):
@@ -2098,7 +2177,7 @@ class VariationBlock(Block):
     def build(self, builder):
         """Call the ``start_feature`` callback on the builder object, visit
         all the statements in this feature, and then call ``end_feature``."""
-        builder.start_feature(self.location, self.name)
+        builder.start_feature(self.location, self.name, self.use_extension)
         if (
             self.conditionset != "NULL"
             and self.conditionset not in builder.conditionsets_

fontTools/feaLib/builder.py

@@ -126,6 +126,7 @@ class Builder(object):
         self.script_ = None
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = False
         self.language_systems = set()
         self.seen_non_DFLT_script_ = False
         self.named_lookups_ = {}
@@ -141,6 +142,7 @@ class Builder(object):
         self.aalt_features_ = []  # [(location, featureName)*], for 'aalt'
         self.aalt_location_ = None
         self.aalt_alternates_ = {}
+        self.aalt_use_extension_ = False
         # for 'featureNames'
         self.featureNames_ = set()
         self.featureNames_ids_ = {}
@@ -247,6 +249,7 @@ class Builder(object):
         result = builder_class(self.font, location)
         result.lookupflag = self.lookupflag_
         result.markFilterSet = self.lookupflag_markFilterSet_
+        result.extension = self.use_extension_
         self.lookups_.append(result)
         return result
 
@@ -272,6 +275,7 @@ class Builder(object):
         self.cur_lookup_ = builder_class(self.font, location)
         self.cur_lookup_.lookupflag = self.lookupflag_
         self.cur_lookup_.markFilterSet = self.lookupflag_markFilterSet_
+        self.cur_lookup_.extension = self.use_extension_
         self.lookups_.append(self.cur_lookup_)
         if self.cur_lookup_name_:
             # We are starting a lookup rule inside a named lookup block.
@@ -323,7 +327,7 @@ class Builder(object):
         }
         old_lookups = self.lookups_
         self.lookups_ = []
-        self.start_feature(self.aalt_location_, "aalt")
+        self.start_feature(self.aalt_location_, "aalt", self.aalt_use_extension_)
         if single:
             single_lookup = self.get_lookup_(location, SingleSubstBuilder)
             single_lookup.mapping = single
@@ -341,6 +345,7 @@ class Builder(object):
             table = self.font["head"] = newTable("head")
             table.decompile(b"\0" * 54, self.font)
             table.tableVersion = 1.0
+            table.magicNumber = 0x5F0F3CF5
             table.created = table.modified = 3406620153  # 2011-12-13 11:22:33
         table.fontRevision = self.fontRevision_
 
@@ -727,10 +732,16 @@ class Builder(object):
         result.table = base
         return result
 
+    def buildBASECoord(self, c):
+        coord = otTables.BaseCoord()
+        coord.Format = 1
+        coord.Coordinate = c
+        return coord
+
     def buildBASEAxis(self, axis):
         if not axis:
             return
-        bases, scripts = axis
+        bases, scripts, minmax = axis
         axis = otTables.Axis()
         axis.BaseTagList = otTables.BaseTagList()
         axis.BaseTagList.BaselineTag = bases
@@ -739,19 +750,35 @@ class Builder(object):
         axis.BaseScriptList.BaseScriptRecord = []
         axis.BaseScriptList.BaseScriptCount = len(scripts)
         for script in sorted(scripts):
+            minmax_for_script = [
+                record[1:] for record in minmax if record[0] == script[0]
+            ]
             record = otTables.BaseScriptRecord()
             record.BaseScriptTag = script[0]
             record.BaseScript = otTables.BaseScript()
-            record.BaseScript.BaseLangSysCount = 0
             record.BaseScript.BaseValues = otTables.BaseValues()
             record.BaseScript.BaseValues.DefaultIndex = bases.index(script[1])
             record.BaseScript.BaseValues.BaseCoord = []
             record.BaseScript.BaseValues.BaseCoordCount = len(script[2])
+            record.BaseScript.BaseLangSysRecord = []
+
             for c in script[2]:
-                coord = otTables.BaseCoord()
-                coord.Format = 1
-                coord.Coordinate = c
-                record.BaseScript.BaseValues.BaseCoord.append(coord)
+                record.BaseScript.BaseValues.BaseCoord.append(self.buildBASECoord(c))
+            for language, min_coord, max_coord in minmax_for_script:
+                minmax_record = otTables.MinMax()
+                minmax_record.MinCoord = self.buildBASECoord(min_coord)
+                minmax_record.MaxCoord = self.buildBASECoord(max_coord)
+                minmax_record.FeatMinMaxCount = 0
+                if language == "dflt":
+                    record.BaseScript.DefaultMinMax = minmax_record
+                else:
+                    lang_record = otTables.BaseLangSysRecord()
+                    lang_record.BaseLangSysTag = language
+                    lang_record.MinMax = minmax_record
+                    record.BaseScript.BaseLangSysRecord.append(lang_record)
+            record.BaseScript.BaseLangSysCount = len(
+                record.BaseScript.BaseLangSysRecord
+            )
             axis.BaseScriptList.BaseScriptRecord.append(record)
         return axis
 
@@ -1031,15 +1058,22 @@ class Builder(object):
         else:
             return frozenset({("DFLT", "dflt")})
 
-    def start_feature(self, location, name):
+    def start_feature(self, location, name, use_extension=False):
+        if use_extension and name != "aalt":
+            raise FeatureLibError(
+                "'useExtension' keyword for feature blocks is allowed only for 'aalt' feature",
+                location,
+            )
         self.language_systems = self.get_default_language_systems_()
         self.script_ = "DFLT"
         self.cur_lookup_ = None
         self.cur_feature_name_ = name
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = use_extension
         if name == "aalt":
             self.aalt_location_ = location
+            self.aalt_use_extension_ = use_extension
 
     def end_feature(self):
         assert self.cur_feature_name_ is not None
@@ -1048,8 +1082,9 @@ class Builder(object):
         self.cur_lookup_ = None
         self.lookupflag_ = 0
         self.lookupflag_markFilterSet_ = None
+        self.use_extension_ = False
 
-    def start_lookup_block(self, location, name):
+    def start_lookup_block(self, location, name, use_extension=False):
         if name in self.named_lookups_:
             raise FeatureLibError(
                 'Lookup "%s" has already been defined' % name, location
@@ -1063,6 +1098,7 @@ class Builder(object):
         self.cur_lookup_name_ = name
         self.named_lookups_[name] = None
         self.cur_lookup_ = None
+        self.use_extension_ = use_extension
         if self.cur_feature_name_ is None:
             self.lookupflag_ = 0
             self.lookupflag_markFilterSet_ = None
@@ -1071,6 +1107,7 @@ class Builder(object):
         assert self.cur_lookup_name_ is not None
         self.cur_lookup_name_ = None
         self.cur_lookup_ = None
+        self.use_extension_ = False
         if self.cur_feature_name_ is None:
             self.lookupflag_ = 0
             self.lookupflag_markFilterSet_ = None
@@ -1235,11 +1272,11 @@ class Builder(object):
     def add_cv_character(self, character, tag):
         self.cv_characters_[tag].append(character)
 
-    def set_base_axis(self, bases, scripts, vertical):
+    def set_base_axis(self, bases, scripts, vertical, minmax=[]):
         if vertical:
-            self.base_vert_axis_ = (bases, scripts)
+            self.base_vert_axis_ = (bases, scripts, minmax)
         else:
-            self.base_horiz_axis_ = (bases, scripts)
+            self.base_horiz_axis_ = (bases, scripts, minmax)
 
     def set_size_parameters(
         self, location, DesignSize, SubfamilyID, RangeStart, RangeEnd
@@ -1448,7 +1485,9 @@ class Builder(object):
         lookup = self.get_lookup_(location, PairPosBuilder)
         v1 = self.makeOpenTypeValueRecord(location, value1, pairPosContext=True)
         v2 = self.makeOpenTypeValueRecord(location, value2, pairPosContext=True)
-        lookup.addClassPair(location, glyphclass1, v1, glyphclass2, v2)
+        cls1 = tuple(sorted(set(glyphclass1)))
+        cls2 = tuple(sorted(set(glyphclass2)))
+        lookup.addClassPair(location, cls1, v1, cls2, v2)
 
     def add_specific_pair_pos(self, location, glyph1, value1, glyph2, value2):
         if not glyph1 or not glyph2: