diff options
author | Rasmus Andersson <rasmus@notion.se> | 2018-09-03 22:55:49 +0300 |
---|---|---|
committer | Rasmus Andersson <rasmus@notion.se> | 2018-09-03 22:55:49 +0300 |
commit | c833e252c925e8dd68108660710ca835d95daa6f (patch) | |
tree | 6b2e28264ed45efd7f054e453b622098d0d875b8 /misc/tools/fixup-features.py | |
parent | 8c1a4c181ef12000179dfec541f1af87e9b03122 (diff) | |
download | inter-c833e252c925e8dd68108660710ca835d95daa6f.tar.xz |
Major overhaul, moving from UFO2 to Glyphs and UFO3, plus a brand new and much simpler fontbuild
Diffstat (limited to 'misc/tools/fixup-features.py')
-rwxr-xr-x | misc/tools/fixup-features.py | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/misc/tools/fixup-features.py b/misc/tools/fixup-features.py new file mode 100755 index 000000000..dd4c2658f --- /dev/null +++ b/misc/tools/fixup-features.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python +# encoding: utf8 +from __future__ import print_function +import os, sys, plistlib, re +from collections import OrderedDict +from ConfigParser import RawConfigParser +from argparse import ArgumentParser +from robofab.objects.objectsRF import OpenFont +from fontTools.feaLib.parser import Parser as FeaParser +from fontTools.feaLib.builder import Builder as FeaBuilder +from fontTools.ttLib import TTFont + + +# Regex matching "default" glyph names, like "uni2043" and "u01C5" +uniNameRe = re.compile(r'^u(?:ni)([0-9A-F]{4,8})$') + + +def unicodeForDefaultGlyphName(glyphName): + m = uniNameRe.match(glyphName) + if m is not None: + try: + return int(m.group(1), 16) + except: + pass + return None + + +def canonicalGlyphName(glyphName, uc2names): + uc = unicodeForDefaultGlyphName(glyphName) + if uc is not None: + names = uc2names.get(uc) + if names is not None and len(names) > 0: + return names[0] + return glyphName + + + +def parseGlyphComposition(composite): + c = composite.split("=") + d = c[1].split("/") + glyphName = d[0] + if len(d) == 1: + offset = [0, 0] + else: + offset = [int(i) for i in d[1].split(",")] + accentString = c[0] + accents = accentString.split("+") + baseName = accents.pop(0) + accentNames = [i.split(":") for i in accents] + return (glyphName, baseName, accentNames, offset) + + +def loadGlyphCompositions(filename): # { glyphName => (baseName, accentNames, offset) } + compositions = OrderedDict() + with open(filename, 'r') as f: + for line in f: + line = line.strip() + if len(line) > 0 and line[0] != '#': + glyphName, baseName, accentNames, offset = parseGlyphComposition(line) + compositions[glyphName] = (baseName, accentNames, offset) + return compositions + + +def loadAGL(filename): # -> { 2126: 'Omega', ... } + m = {} + with open(filename, 'r') as f: + for line in f: + # Omega;2126 + # dalethatafpatah;05D3 05B2 # higher-level combinations; ignored + line = line.strip() + if len(line) > 0 and line[0] != '#': + name, uc = tuple([c.strip() for c in line.split(';')]) + if uc.find(' ') == -1: + # it's a 1:1 mapping + m[int(uc, 16)] = name + return m + + +def loadLocalNamesDB(fonts, agl, diacriticComps): + uc2names = None # { 2126: ['Omega', ...], ...} + allNames = set() # set('Omega', ...) + + for font in fonts: + _uc2names = font.getCharacterMapping() # { 2126: ['Omega', ...], ...} + if uc2names is None: + uc2names = _uc2names + else: + for uc, _names in _uc2names.iteritems(): + names = uc2names.setdefault(uc, []) + for name in _names: + if name not in names: + names.append(name) + for g in font: + allNames.add(g.name) + + # agl { 2126: 'Omega', ...} -> { 'Omega': [2126, ...], ...} + aglName2Ucs = {} + for uc, name in agl.iteritems(): + aglName2Ucs.setdefault(name, []).append(uc) + + for glyphName, comp in diacriticComps.iteritems(): + aglUCs = aglName2Ucs.get(glyphName) + if aglUCs is None: + uc = unicodeForDefaultGlyphName(glyphName) + if uc is not None: + glyphName2 = agl.get(uc) + if glyphName2 is not None: + glyphName = glyphName2 + names = uc2names.setdefault(uc, []) + if glyphName not in names: + names.append(glyphName) + allNames.add(glyphName) + else: + allNames.add(glyphName) + for uc in aglUCs: + names = uc2names.get(uc, []) + if glyphName not in names: + names.append(glyphName) + uc2names[uc] = names + + name2ucs = {} # { 'Omega': [2126, ...], ...} + for uc, names in uc2names.iteritems(): + for name in names: + name2ucs.setdefault(name, set()).add(uc) + + return uc2names, name2ucs, allNames + + + +includeRe = re.compile(r'^include\(([^\)]+)\);\s*$') + + +def loadFeaturesFile(filepath): + print('read', filepath) + lines = [] + with open(filepath, 'r') as f: + for line in f: + m = includeRe.match(line) + if m is not None: + includedFilename = m.group(1) + includedPath = os.path.normpath(os.path.join(os.path.dirname(filepath), includedFilename)) + lines = lines + loadFeaturesFile(includedPath) + else: + lines.append(line) + return lines + + +def main(): + argparser = ArgumentParser(description='Fixup features.fea') + + argparser.add_argument( + '-dry', dest='dryRun', action='store_const', const=True, default=False, + help='Do not modify anything, but instead just print what would happen.') + + argparser.add_argument( + 'fontPaths', metavar='<ufofile>', type=str, nargs='+', help='UFO fonts to update') + + args = argparser.parse_args() + dryRun = args.dryRun + + agl = loadAGL('src/glyphlist.txt') # { 2126: 'Omega', ... } + diacriticComps = loadGlyphCompositions('src/diacritics.txt') # {glyphName => (baseName, a, o)} + + # collect glyph names + fonts = [OpenFont(fontPath) for fontPath in args.fontPaths] + uc2names, name2ucs, allNames = loadLocalNamesDB(fonts, agl, diacriticComps) + + includeRe = re.compile(r'^include\(([^\)]+)\);\s*$') + + # open features.fea + featuresLines = loadFeaturesFile(os.path.join(fontPath, 'features.fea')) + + classDefRe = re.compile(r'^@([^\s=]+)\s*=\s*\[([^\]]+)\]\s*;\s*$') + subRe = re.compile(r'^\s*sub\s+(.+)(\'?)\s+by\s+(.+)\s*;\s*$') + sub2Re = re.compile(r'^\s*sub\s+([^\[]+)\s+\[\s*([^\]]+)\s*\](\'?)\s+by\s+(.+)\s*;\s*$') + # sub lmidtilde [uni1ABB uni1ABD uni1ABE]' by uni1ABE.w2; + # sub lmidtilde uni1ABC' by uni1ABC.w2; + spacesRe = re.compile(r'[\s\r\n]+') + + classDefs = {} + featuresLines2 = [] + + for line in featuresLines: + clsM = classDefRe.match(line) + if clsM is not None: + clsName = clsM.group(1) + names = spacesRe.split(clsM.group(2).strip()) + if clsName in classDefs: + raise Exception('duplicate class definition ' + clsName) + # print('classdef', clsName, ' '.join(names)) + # print('classdef', clsName) + names2 = [] + for name in names: + if name == '-': + # e.g. A - Z + names2.append(name) + continue + if name[0] != '@': + canonName = canonicalGlyphName(name, uc2names) + if canonName != name: + # print('renaming ' + name + ' -> ' + canonName) + names2.append(canonName) + elif name not in allNames: + print('skipping unknown glyph ' + name) + else: + names2.append(name) + else: + raise Exception('todo: class-ref ' + name + ' in class-def ' + clsName) + classDefs[clsName] = names2 + line = '@%s = [ %s ];' % (clsName, ' '.join(names2)) + featuresLines2.append(line) + continue + + + # sub2M = sub2Re.match(line) + # if sub2M is not None: + # findNames1 = spacesRe.split(sub2M.group(1)) + # findNames2 = spacesRe.split(sub2M.group(2)) + # apos = sub2M.group(3) + # rightName = sub2M.group(4) + # print('TODO: sub2', findNames1, findNames2, apos, rightName) + # featuresLines2.append(line) + # continue + + + sub2M = sub2Re.match(line) + subM = None + if sub2M is None: + subM = subRe.match(line) + if subM is not None or sub2M is not None: + findNamesStr = '' + findNamesHasBrackets = False + findNames = [] + + findNamesBStr = '' + findNamesBHasBrackets = False + findNamesB = [] + + newNamesStr = '' + newNamesHasBrackets = False + newNames = [] + + apos0 = '' + + if subM is not None: + findNamesStr = subM.group(1) + apos0 = subM.group(2) + newNamesStr = subM.group(3) + else: # sub2M + findNamesStr = sub2M.group(1) + findNamesBStr = sub2M.group(2) + apos0 = sub2M.group(3) + newNamesStr = sub2M.group(4) + + if newNamesStr[0] == '[': + newNamesHasBrackets = True + newNamesStr = newNamesStr.strip('[ ]') + newNames = spacesRe.split(newNamesStr) + + if findNamesStr[0] == '[': + findNamesHasBrackets = True + findNamesStr = findNamesStr.strip('[ ]') + findNames = spacesRe.split(findNamesStr) + + if findNamesBStr != '': + if findNamesBStr[0] == '[': + findNamesBHasBrackets = True + findNamesBStr = findNamesBStr.strip('[ ]') + findNamesB = spacesRe.split(findNamesBStr) + + + names22 = [] + for names in [findNames, findNamesB, newNames]: + names2 = [] + for name in names: + if name[0] == '@': + clsName = name[1:].rstrip("'") + if clsName not in classDefs: + raise Exception('sub: missing target class ' + clsName + ' at\n' + line) + names2.append(name) + else: + apos = name[-1] == "'" + if apos: + name = name[:-1] + if name not in allNames: + canonName = canonicalGlyphName(name, uc2names) + if canonName != name: + print('renaming ' + name + ' -> ' + canonName) + name = canonName + else: + raise Exception('TODO: unknown name', name) + # if we remove names, we also need to remove subs (that become empty), and so on. + if apos: + name += "'" + names2.append(name) + names22.append(names2) + + findNames2, findNamesB2, newNames2 = names22 + + findNamesStr = ' '.join(findNames2) + if findNamesHasBrackets: findNamesStr = '[' + findNamesStr + ']' + + if findNamesBStr != '': + findNamesBStr = ' '.join(findNamesB2) + if findNamesBHasBrackets: findNamesBStr = '[' + findNamesBStr + ']' + + newNamesStr = ' '.join(newNames2) + if newNamesHasBrackets: newNamesStr = '[' + newNamesStr + ']' + + if subM is not None: + line = ' sub %s%s by %s;' % (findNamesStr, apos0, newNamesStr) + else: + # if subM is None: + # sub bbar [uni1ABB uni1ABD uni1ABE]' by uni1ABE.w2; + line = ' sub %s [%s]%s by %s;' % (findNamesStr, findNamesBStr, apos0, newNamesStr) + + featuresLines2.append(line) + + + print('Write', featuresFilename) + if not dryRun: + with open(featuresFilename + '2', 'w') as f: + for line in featuresLines2: + f.write(line + '\n') + + # FeaParser(featuresFilename + '2', allNames).parse() + + # font = TTFont('build/dist-unhinted/Inter-UI-Regular.otf') + # FeaBuilder(font, featuresFilename + '2').build() + + + + + +main() |