fonttools 4.57.0__cp39-cp39-macosx_10_9_universal2.whl → 4.58.1__cp39-cp39-macosx_10_9_universal2.whl

fontTools/voltLib/__main__.py

@@ -0,0 +1,206 @@
+import argparse
+import logging
+import sys
+from io import StringIO
+from pathlib import Path
+
+from fontTools import configLogger
+from fontTools.feaLib.builder import addOpenTypeFeaturesFromString
+from fontTools.feaLib.error import FeatureLibError
+from fontTools.feaLib.lexer import Lexer
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.ttLib import TTFont, TTLibError
+from fontTools.voltLib.parser import Parser
+from fontTools.voltLib.voltToFea import TABLES, VoltToFea
+
+log = logging.getLogger("fontTools.feaLib")
+
+SUPPORTED_TABLES = TABLES + ["cmap"]
+
+
+def invalid_fea_glyph_name(name):
+    """Check if the glyph name is valid according to FEA syntax."""
+    if name[0] not in Lexer.CHAR_NAME_START_:
+        return True
+    if any(c not in Lexer.CHAR_NAME_CONTINUATION_ for c in name[1:]):
+        return True
+    return False
+
+
+def sanitize_glyph_name(name):
+    """Sanitize the glyph name to ensure it is valid according to FEA syntax."""
+    sanitized = ""
+    for i, c in enumerate(name):
+        if i == 0 and c not in Lexer.CHAR_NAME_START_:
+            sanitized += "a" + c
+        elif c not in Lexer.CHAR_NAME_CONTINUATION_:
+            sanitized += "_"
+        else:
+            sanitized += c
+
+    return sanitized
+
+
+def main(args=None):
+    """Build tables from a MS VOLT project into an OTF font"""
+    parser = argparse.ArgumentParser(
+        description="Use fontTools to compile MS VOLT projects."
+    )
+    parser.add_argument(
+        "input",
+        metavar="INPUT",
+        help="Path to the input font/VTP file to process",
+        type=Path,
+    )
+    parser.add_argument(
+        "-f",
+        "--font",
+        metavar="INPUT_FONT",
+        help="Path to the input font (if INPUT is a VTP file)",
+        type=Path,
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        metavar="OUTPUT",
+        help="Path to the output font.",
+        type=Path,
+    )
+    parser.add_argument(
+        "-t",
+        "--tables",
+        metavar="TABLE_TAG",
+        choices=SUPPORTED_TABLES,
+        nargs="+",
+        help="Specify the table(s) to be built.",
+    )
+    parser.add_argument(
+        "-F",
+        "--debug-feature-file",
+        help="Write the generated feature file to disk.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--ship",
+        help="Remove source VOLT tables from output font.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        help="Increase the logger verbosity. Multiple -v options are allowed.",
+        action="count",
+        default=0,
+    )
+    parser.add_argument(
+        "-T",
+        "--traceback",
+        help="show traceback for exceptions.",
+        action="store_true",
+    )
+    options = parser.parse_args(args)
+
+    levels = ["WARNING", "INFO", "DEBUG"]
+    configLogger(level=levels[min(len(levels) - 1, options.verbose)])
+
+    output_font = options.output or Path(
+        makeOutputFileName(options.font or options.input)
+    )
+    log.info(f"Compiling MS VOLT to '{output_font}'")
+
+    file_or_path = options.input
+    font = None
+
+    # If the input is a font file, extract the VOLT data from the "TSIV" table
+    try:
+        font = TTFont(file_or_path)
+        if "TSIV" in font:
+            file_or_path = StringIO(font["TSIV"].data.decode("utf-8"))
+        else:
+            log.error('"TSIV" table is missing')
+            return 1
+    except TTLibError:
+        pass
+
+    # If input is not a font file, the font must be provided
+    if font is None:
+        if not options.font:
+            log.error("Please provide an input font")
+            return 1
+        font = TTFont(options.font)
+
+    # FEA syntax does not allow some glyph names that VOLT accepts, so if we
+    # found such glyph name we will temporarily rename such glyphs.
+    glyphOrder = font.getGlyphOrder()
+    tempGlyphOrder = None
+    if any(invalid_fea_glyph_name(n) for n in glyphOrder):
+        tempGlyphOrder = []
+        for n in glyphOrder:
+            if invalid_fea_glyph_name(n):
+                n = sanitize_glyph_name(n)
+                existing = set(tempGlyphOrder) | set(glyphOrder)
+                while n in existing:
+                    n = "a" + n
+            tempGlyphOrder.append(n)
+        font.setGlyphOrder(tempGlyphOrder)
+
+    doc = Parser(file_or_path).parse()
+
+    log.info("Converting VTP data to FEA")
+    converter = VoltToFea(doc, font)
+    try:
+        fea = converter.convert(options.tables, ignore_unsupported_settings=True)
+    except NotImplementedError as e:
+        if options.traceback:
+            raise
+        location = getattr(e.args[0], "location", None)
+        message = f'"{e}" is not supported'
+        if location:
+            path, line, column = location
+            log.error(f"{path}:{line}:{column}: {message}")
+        else:
+            log.error(message)
+        return 1
+
+    fea_filename = options.input
+    if options.debug_feature_file:
+        fea_filename = output_font.with_suffix(".fea")
+        log.info(f"Writing FEA to '{fea_filename}'")
+        with open(fea_filename, "w") as fp:
+            fp.write(fea)
+
+    log.info("Compiling FEA to OpenType tables")
+    try:
+        addOpenTypeFeaturesFromString(
+            font,
+            fea,
+            filename=fea_filename,
+            tables=options.tables,
+        )
+    except FeatureLibError as e:
+        if options.traceback:
+            raise
+        log.error(e)
+        return 1
+
+    if options.ship:
+        for tag in ["TSIV", "TSIS", "TSIP", "TSID"]:
+            if tag in font:
+                del font[tag]
+
+    # Restore original glyph names.
+    if tempGlyphOrder:
+        import io
+
+        f = io.BytesIO()
+        font.save(f)
+        font = TTFont(f)
+        font.setGlyphOrder(glyphOrder)
+        font["post"].extraNames = []
+
+    font.save(output_font)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fontTools/voltLib/ast.py

@@ -317,6 +317,10 @@ class SubstitutionLigatureDefinition(SubstitutionDefinition):
     pass
 
 
+class SubstitutionAlternateDefinition(SubstitutionDefinition):
+    pass
+
+
 class SubstitutionReverseChainingSingleDefinition(SubstitutionDefinition):
     pass
 

fontTools/voltLib/parser.py

@@ -313,19 +313,27 @@ class Parser(object):
         self.expect_keyword_("END_SUBSTITUTION")
         max_src = max([len(cov) for cov in src])
         max_dest = max([len(cov) for cov in dest])
+
         # many to many or mixed is invalid
-        if (max_src > 1 and max_dest > 1) or (
-            reversal and (max_src > 1 or max_dest > 1)
-        ):
+        if max_src > 1 and max_dest > 1:
             raise VoltLibError("Invalid substitution type", location)
+
         mapping = dict(zip(tuple(src), tuple(dest)))
         if max_src == 1 and max_dest == 1:
-            if reversal:
-                sub = ast.SubstitutionReverseChainingSingleDefinition(
-                    mapping, location=location
-                )
+            # Alternate substitutions are represented by adding multiple
+            # substitutions for the same glyph, so we detect that here
+            glyphs = [x.glyphSet() for cov in src for x in cov]  # flatten src
+            if len(set(glyphs)) != len(glyphs):  # src has duplicates
+                sub = ast.SubstitutionAlternateDefinition(mapping, location=location)
             else:
-                sub = ast.SubstitutionSingleDefinition(mapping, location=location)
+                if reversal:
+                    # Reversal is valid only for single glyph substitutions
+                    # and VOLT ignores it otherwise.
+                    sub = ast.SubstitutionReverseChainingSingleDefinition(
+                        mapping, location=location
+                    )
+                else:
+                    sub = ast.SubstitutionSingleDefinition(mapping, location=location)
         elif max_src == 1 and max_dest > 1:
             sub = ast.SubstitutionMultipleDefinition(mapping, location=location)
         elif max_src > 1 and max_dest == 1: