mirror of
https://github.com/rsms/inter.git
synced 2024-11-23 20:55:33 +03:00
433 lines
13 KiB
Python
Executable File
433 lines
13 KiB
Python
Executable File
#!/usr/bin/env python
|
|
from __future__ import print_function, absolute_import
|
|
|
|
import sys, os
|
|
from os.path import dirname, basename, abspath, relpath, join as pjoin
|
|
sys.path.append(abspath(pjoin(dirname(__file__), 'tools')))
|
|
from common import BASEDIR, VENVDIR, getGitHash, getVersion
|
|
|
|
import argparse
|
|
import datetime
|
|
import glyphsLib
|
|
import logging
|
|
import re
|
|
import signal
|
|
import subprocess
|
|
from fontmake.font_project import FontProject
|
|
from fontTools import designspaceLib
|
|
from glyphsLib.interpolation import apply_instance_data
|
|
from mutatorMath.ufo.document import DesignSpaceDocumentReader
|
|
|
|
|
|
subfamily_re = re.compile(r'^\s*([^\s]+)(?:\s*italic|)\s*$', re.I | re.U)
|
|
|
|
|
|
def sighandler(signum, frame):
|
|
sys.stdout.write('\n')
|
|
sys.stdout.flush()
|
|
sys.exit(1)
|
|
|
|
|
|
def mkdirs(path):
|
|
if not os.access(path, os.F_OK):
|
|
os.makedirs(path)
|
|
|
|
|
|
# setFontInfo patches font.info
|
|
#
|
|
def setFontInfo(font, weight, updateCreated=True):
|
|
#
|
|
# For UFO3 names, see
|
|
# https://github.com/unified-font-object/ufo-spec/blob/gh-pages/versions/
|
|
# ufo3/fontinfo.plist.md
|
|
# For OpenType NAME table IDs, see
|
|
# https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids
|
|
#
|
|
version = getVersion()
|
|
buildtag = getGitHash()
|
|
versionMajor, versionMinor = [int(num) for num in version.split(".")]
|
|
now = datetime.datetime.utcnow()
|
|
family = font.info.familyName # i.e. "Inter UI"
|
|
style = font.info.styleName # e.g. "Medium Italic"
|
|
isitalic = font.info.italicAngle != 0
|
|
|
|
# weight
|
|
font.info.openTypeOS2WeightClass = weight
|
|
|
|
# creation date & time (YYYY/MM/DD HH:MM:SS)
|
|
if updateCreated:
|
|
font.info.openTypeHeadCreated = now.strftime("%Y/%m/%d %H:%M:%S")
|
|
|
|
# version
|
|
font.info.version = version
|
|
font.info.versionMajor = versionMajor
|
|
font.info.versionMinor = versionMinor
|
|
font.info.year = now.year
|
|
font.info.openTypeNameVersion = "%s;%s" % (version, buildtag)
|
|
font.info.openTypeNameUniqueID = "%s %s:%d:%s" % (family, style, now.year, buildtag)
|
|
|
|
# Names
|
|
family_nosp = re.sub(r'\s', '', family)
|
|
style_nosp = re.sub(r'\s', '', style)
|
|
font.info.macintoshFONDName = "%s %s" % (family_nosp, style_nosp)
|
|
font.info.postscriptFontName = "%s-%s" % (family_nosp, style_nosp)
|
|
|
|
# name ID 16 "Typographic Family name"
|
|
font.info.openTypeNamePreferredFamilyName = family
|
|
|
|
# name ID 17 "Typographic Subfamily name"
|
|
subfamily = subfamily_re.sub('\\1', style) # "A Italic" => "A", "A" => "A"
|
|
if len(subfamily) == 0:
|
|
subfamily = "Regular"
|
|
font.info.openTypeNamePreferredSubfamilyName = subfamily
|
|
|
|
# Legacy family name (full name except "italic")
|
|
subfamily_lc = subfamily.lower()
|
|
if subfamily_lc != "regular" and subfamily_lc != "bold":
|
|
font.info.styleMapFamilyName = "%s %s" % (family, subfamily)
|
|
else:
|
|
font.info.styleMapFamilyName = family
|
|
|
|
# Legacy style name. Must be one of these case-sensitive strings:
|
|
# "regular", "italic", "bold", "bold italic"
|
|
font.info.styleMapStyleName = "regular"
|
|
if style.strip().lower().find('bold') != -1:
|
|
if isitalic:
|
|
font.info.styleMapStyleName = "bold italic"
|
|
else:
|
|
font.info.styleMapStyleName = "bold"
|
|
elif isitalic:
|
|
font.info.styleMapStyleName = "italic"
|
|
|
|
|
|
class Main(object):
|
|
|
|
def __init__(self):
|
|
self.tmpdir = pjoin(BASEDIR,'build','tmp')
|
|
|
|
|
|
def main(self, argv):
|
|
# make ^C instantly exit program
|
|
signal.signal(signal.SIGINT, sighandler)
|
|
|
|
argparser = argparse.ArgumentParser(
|
|
description='',
|
|
usage='''
|
|
%(prog)s [options] <command> [<args>]
|
|
|
|
Commands:
|
|
compile Build font files
|
|
glyphsync Generate designspace and UFOs from Glyphs file
|
|
instancegen Generate instance UFOs for designspace
|
|
'''.strip().replace('\n ', '\n'))
|
|
|
|
argparser.add_argument('-v', '--verbose', action='store_true',
|
|
help='Print more details')
|
|
|
|
argparser.add_argument('command', metavar='<command>')
|
|
|
|
args = argparser.parse_args(argv[1:2])
|
|
if args.verbose:
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
else:
|
|
logging.basicConfig(level=logging.ERROR)
|
|
cmd = 'cmd_' + args.command.replace('-', '_')
|
|
if not hasattr(self, cmd):
|
|
print('Unrecognized command %s. Try --help' % args.command,
|
|
file=sys.stderr)
|
|
exit(1)
|
|
getattr(self, cmd)(argv[2:])
|
|
|
|
|
|
|
|
def cmd_compile(self, argv):
|
|
argparser = argparse.ArgumentParser(
|
|
usage='%(prog)s compile [-h] [-o <file>] <ufo>',
|
|
description='Compile font files')
|
|
|
|
argparser.add_argument('ufo', metavar='<ufo>',
|
|
help='UFO source file')
|
|
|
|
argparser.add_argument('-o', '--output', metavar='<fontfile>',
|
|
help='Output font file (.otf, .ttf, .ufo or .gx)')
|
|
|
|
argparser.add_argument('--validate', action='store_true',
|
|
help='Enable ufoLib validation on reading/writing UFO files')
|
|
|
|
# argparser.add_argument('-f', '--formats', nargs='+', metavar='<format>',
|
|
# help='Output formats. Any of %(choices)s. Defaults to "otf".',
|
|
# choices=tuple(all_formats),
|
|
# default=('otf'))
|
|
|
|
args = argparser.parse_args(argv)
|
|
|
|
ext_to_format = {
|
|
'.ufo': 'ufo',
|
|
'.otf': 'otf',
|
|
'.ttf': 'ttf',
|
|
# 'ttf-interpolatable',
|
|
'.gx': 'variable',
|
|
}
|
|
|
|
formats = []
|
|
filename = args.output
|
|
if filename is None or filename == '':
|
|
ufoname = basename(args.ufo)
|
|
name, ext = os.path.splitext(ufoname)
|
|
filename = name + '.otf'
|
|
logging.info('setting --output %r' % filename)
|
|
# for filename in args.output:
|
|
ext = os.path.splitext(filename)[1]
|
|
ext_lc = ext.lower()
|
|
if ext_lc in ext_to_format:
|
|
formats.append(ext_to_format[ext_lc])
|
|
else:
|
|
print('Unsupported output format %s' % ext, file=sys.stderr)
|
|
exit(1)
|
|
|
|
mkdirs(self.tmpdir)
|
|
|
|
project = FontProject(
|
|
timing=None,
|
|
verbose='WARNING',
|
|
validate_ufo=args.validate
|
|
)
|
|
|
|
project.run_from_ufos(
|
|
[args.ufo],
|
|
output_dir=self.tmpdir,
|
|
output=formats
|
|
)
|
|
|
|
# run through ots-sanitize
|
|
# for filename in args.output:
|
|
tmpfile = pjoin(self.tmpdir, basename(filename))
|
|
mkdirs(dirname(filename))
|
|
success = True
|
|
try:
|
|
otssan_res = subprocess.check_output(
|
|
['ots-sanitize', tmpfile, filename],
|
|
shell=False
|
|
).strip()
|
|
# Note: ots-sanitize does not exit with an error in many cases where
|
|
# it fails to sanitize the font.
|
|
success = otssan_res.find('Failed') == -1
|
|
except:
|
|
success = False
|
|
otssan_res = 'error'
|
|
|
|
if success:
|
|
os.unlink(tmpfile)
|
|
else:
|
|
print('ots-sanitize failed for %s: %s' % (
|
|
tmpfile, otssan_res), file=sys.stderr)
|
|
exit(1)
|
|
|
|
|
|
|
|
def cmd_glyphsync(self, argv):
|
|
argparser = argparse.ArgumentParser(
|
|
usage='%(prog)s glyphsync <glyphsfile> [options]',
|
|
description='Generates designspace and UFOs from Glyphs file')
|
|
|
|
argparser.add_argument('glyphsfile', metavar='<glyphsfile>',
|
|
help='Glyphs source file')
|
|
|
|
argparser.add_argument('-o', '--outdir', metavar='<dir>',
|
|
help='''Write output to <dir>. If omitted, designspace and UFOs are
|
|
written to the directory of the glyphs file.
|
|
'''.strip().replace('\n ', ''))
|
|
|
|
args = argparser.parse_args(argv)
|
|
|
|
outdir = args.outdir
|
|
if outdir is None:
|
|
outdir = dirname(args.glyphsfile)
|
|
|
|
# files
|
|
master_dir = outdir
|
|
glyphsfile = args.glyphsfile
|
|
designspace_file = pjoin(outdir, 'Inter-UI.designspace')
|
|
instance_dir = pjoin(BASEDIR, 'build', 'ufo')
|
|
|
|
# load glyphs project file
|
|
print("generating %s from %s" % (
|
|
relpath(designspace_file, os.getcwd()),
|
|
relpath(glyphsfile, os.getcwd())
|
|
))
|
|
font = glyphsLib.GSFont(glyphsfile)
|
|
|
|
# generate designspace from glyphs project
|
|
designspace = glyphsLib.to_designspace(
|
|
font,
|
|
propagate_anchors=False,
|
|
instance_dir=relpath(instance_dir, master_dir)
|
|
)
|
|
|
|
# strip lib data
|
|
designspace.lib.clear()
|
|
|
|
# fixup axes
|
|
for axis in designspace.axes:
|
|
if axis.tag == "wght":
|
|
axis.map = []
|
|
axis.minimum = 100
|
|
axis.maximum = 900
|
|
axis.default = 400
|
|
|
|
# patch and write UFO files
|
|
# TODO: Only write out-of-date UFOs
|
|
for source in designspace.sources:
|
|
# source : fontTools.designspaceLib.SourceDescriptor
|
|
# source.font : defcon.objects.font.Font
|
|
ufo_path = pjoin(master_dir, source.filename.replace('InterUI', 'Inter-UI'))
|
|
# no need to also set the relative 'filename' attribute as that
|
|
# will be auto-updated on writing the designspace document
|
|
|
|
# name "Inter UI Black" => "black"
|
|
source.name = source.styleName.lower().replace(' ', '')
|
|
|
|
# fixup font info
|
|
weight = int(source.location['Weight'])
|
|
setFontInfo(source.font, weight, updateCreated=False)
|
|
|
|
# cleanup lib
|
|
lib = dict()
|
|
for key, value in source.font.lib.iteritems():
|
|
if key.startswith('com.schriftgestaltung'):
|
|
continue
|
|
if key == 'public.postscriptNames':
|
|
continue
|
|
lib[key] = value
|
|
source.font.lib.clear()
|
|
source.font.lib.update(lib)
|
|
|
|
# write UFO file
|
|
source.path = ufo_path
|
|
print("write %s" % relpath(ufo_path, os.getcwd()))
|
|
source.font.save(ufo_path)
|
|
|
|
# patch instance names
|
|
for instance in designspace.instances:
|
|
# name "Inter UI Black Italic" => "blackitalic"
|
|
instance.name = instance.styleName.lower().replace(' ', '')
|
|
instance.filename = instance.filename.replace('InterUI', 'Inter-UI')
|
|
|
|
print("write %s" % relpath(designspace_file, os.getcwd()))
|
|
designspace.write(designspace_file)
|
|
|
|
|
|
|
|
def cmd_instancegen(self, argv):
|
|
argparser = argparse.ArgumentParser(
|
|
description='Generate UFO instances from designspace')
|
|
|
|
argparser.add_argument('designspacefile', metavar='<designspace>',
|
|
help='Designspace file')
|
|
|
|
argparser.add_argument('instances', metavar='<instance-name>', nargs='*',
|
|
help='Style instances to generate. Omit to generate all.')
|
|
|
|
args = argparser.parse_args(argv)
|
|
|
|
instances = set([s.lower() for s in args.instances])
|
|
all_instances = len(instances) == 0
|
|
|
|
# files
|
|
designspace_file = args.designspacefile
|
|
instance_dir = pjoin(BASEDIR, 'build', 'ufo')
|
|
|
|
# DesignSpaceDocumentReader generates UFOs
|
|
gen = DesignSpaceDocumentReader(
|
|
designspace_file,
|
|
ufoVersion=3,
|
|
roundGeometry=True,
|
|
verbose=True
|
|
)
|
|
|
|
designspace = designspaceLib.DesignSpaceDocument()
|
|
designspace.read(designspace_file)
|
|
|
|
# Generate UFOs for instances
|
|
instance_weight = dict()
|
|
instance_files = set()
|
|
for instance in designspace.instances:
|
|
if all_instances or instance.name in instances:
|
|
filebase = basename(instance.filename)
|
|
relname = relpath(
|
|
pjoin(dirname(designspace_file), instance.filename),
|
|
os.getcwd()
|
|
)
|
|
print('generating %s' % relname)
|
|
gen.readInstance(("name", instance.name))
|
|
instance_files.add(instance.filename)
|
|
instance_weight[filebase] = int(instance.location['Weight'])
|
|
if not all_instances:
|
|
instances.remove(instance.name)
|
|
|
|
if len(instances) > 0:
|
|
print('unknown style(s): %s' % ', '.join(list(instances)), file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
ufos = apply_instance_data(designspace_file, instance_files)
|
|
|
|
# patch ufos (list of defcon.Font instances)
|
|
italicAngleKey = 'com.schriftgestaltung.customParameter.' +\
|
|
'InstanceDescriptorAsGSInstance.italicAngle'
|
|
for font in ufos:
|
|
# move italicAngle from lib to info
|
|
italicAngle = font.lib.get(italicAngleKey)
|
|
if italicAngle != None:
|
|
italicAngle = float(italicAngle)
|
|
del font.lib[italicAngleKey]
|
|
font.info.italicAngle = italicAngle
|
|
|
|
# update font info
|
|
weight = instance_weight[basename(font.path)]
|
|
setFontInfo(font, weight)
|
|
|
|
font.save()
|
|
|
|
|
|
|
|
def checkfont(self, fontfile):
|
|
try:
|
|
res = subprocess.check_output(
|
|
['ots-idempotent', fontfile],
|
|
shell=False
|
|
).strip()
|
|
# Note: ots-idempotent does not exit with an error in many cases where
|
|
# it fails to sanitize the font.
|
|
if res.find('Failed') != -1:
|
|
logging.error('[checkfont] ots-idempotent failed for %r: %s' % (
|
|
fontfile, res))
|
|
return False
|
|
except:
|
|
logging.error('[checkfont] ots-idempotent failed for %r' % fontfile)
|
|
return False
|
|
return True
|
|
|
|
|
|
def cmd_checkfont(self, argv):
|
|
argparser = argparse.ArgumentParser(
|
|
usage='%(prog)s checkfont <file> ...',
|
|
description='Verify integrity of font files')
|
|
|
|
argparser.add_argument('files', metavar='<file>', nargs='+',
|
|
help='Font files')
|
|
|
|
args = argparser.parse_args(argv)
|
|
|
|
for fontfile in args.files:
|
|
if not self.checkfont(fontfile):
|
|
sys.exit(1)
|
|
|
|
# could use from multiprocessing import Pool
|
|
# p = Pool(8)
|
|
# p.map(self.checkfont, args.files)
|
|
# p.terminate()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
Main().main(sys.argv)
|