def test_normalizes_curved_quotes_in_names(self): self.master.customParameters = [ GSCustomParameter(name="‘bad’", value=1), GSCustomParameter(name="“also bad”", value=2), ] self.set_custom_params() self.assertIn(MASTER_CUSTOM_PARAM_PREFIX + "'bad'", self.ufo.lib) self.assertIn(MASTER_CUSTOM_PARAM_PREFIX + '"also bad"', self.ufo.lib)
def test_normalizes_curved_quotes_in_names(self): master = GSFontMaster() master.customParameters = [ GSCustomParameter(name='‘bad’', value=1), GSCustomParameter(name='“also bad”', value=2) ] set_custom_params(self.ufo, data=master) self.assertIn(GLYPHS_PREFIX + "'bad'", self.ufo.lib) self.assertIn(GLYPHS_PREFIX + '"also bad"', self.ufo.lib)
def test_set_fsSelection_flags(self): self.assertEqual(self.ufo.info.openTypeOS2Selection, None) self.master.customParameters["Has WWS Names"] = False self.set_custom_params() self.assertEqual(self.ufo.info.openTypeOS2Selection, None) self.master.customParameters["Use Typo Metrics"] = True self.set_custom_params() self.assertEqual(self.ufo.info.openTypeOS2Selection, [7]) self.ufo = Font() self.master.customParameters = [ GSCustomParameter(name="Use Typo Metrics", value=True), GSCustomParameter(name="Has WWS Names", value=True), ] self.set_custom_params() self.assertEqual(self.ufo.info.openTypeOS2Selection, [7, 8])
def __init__(self, descriptor): self._descriptor = descriptor # Having a simple list is enough because `to_ufo_custom_params` does # not use the fake dictionary interface. self.customParameters = [] if CUSTOM_PARAMETERS_KEY in descriptor.lib: for name, value in descriptor.lib[CUSTOM_PARAMETERS_KEY]: self.customParameters.append(GSCustomParameter(name, value))
def test_parse_glyphs_filter(self, mock_parse_glyphs_filter): pre_filter = 'AddExtremes' filter1 = 'Transformations;OffsetX:40;OffsetY:60;include:uni0334,uni0335' filter2 = 'Transformations;OffsetX:10;OffsetY:-10;exclude:uni0334,uni0335' self.master.customParameters.extend([ GSCustomParameter(name='PreFilter', value=pre_filter), GSCustomParameter(name='Filter', value=filter1), GSCustomParameter(name='Filter', value=filter2), ]) self.set_custom_params() self.assertEqual(mock_parse_glyphs_filter.call_count, 3) self.assertEqual(mock_parse_glyphs_filter.call_args_list[0], mock.call(pre_filter, is_pre=True)) self.assertEqual(mock_parse_glyphs_filter.call_args_list[1], mock.call(filter1, is_pre=False)) self.assertEqual(mock_parse_glyphs_filter.call_args_list[2], mock.call(filter2, is_pre=False))
def to_glyphs_instances(self): if self.designspace is None: return for ufo_instance in self.designspace.instances: instance = self.glyphs_module.GSInstance() try: instance.active = ufo_instance.lib[EXPORT_KEY] except KeyError: # If not specified, the default is to export all instances instance.active = True instance.name = ufo_instance.styleName for axis_def in get_axis_definitions(self.font): design_loc = None try: design_loc = ufo_instance.location[axis_def.name] axis_def.set_design_loc(instance, design_loc) except KeyError: # The location does not have this axis? pass if axis_def.tag in ('wght', 'wdth'): # Retrieve the user location (weightClass/widthClass) # Generic way: read the axis mapping backwards. user_loc = design_loc mapping = None for axis in self.designspace.axes: if axis.tag == axis_def.tag: mapping = axis.map if mapping: reverse_mapping = [(dl, ul) for ul, dl in mapping] user_loc = interp(reverse_mapping, design_loc) if user_loc is not None: axis_def.set_user_loc(instance, user_loc) try: # Restore the original weight name when there is an ambiguity based # on the value, e.g. Thin, ExtraLight, UltraLight all map to 250. # No problem with width, because 1:1 mapping in WIDTH_CODES. weight = ufo_instance.lib[WEIGHT_KEY] # Only use the lib value if: # 1. we don't have a weight for the instance already # 2. the value from lib is not "stale", i.e. it still maps to # the current userLocation of the instance. This is in case the # user changes the instance location of the instance by hand but # does not update the weight value in lib. if (not instance.weight or WEIGHT_CODES[instance.weight] == WEIGHT_CODES[weight]): instance.weight = weight except KeyError: # FIXME: what now pass try: if not instance.width: instance.width = ufo_instance.lib[WIDTH_KEY] except KeyError: # FIXME: what now pass if ufo_instance.familyName is not None: if ufo_instance.familyName != self.font.familyName: instance.familyName = ufo_instance.familyName smfn = ufo_instance.styleMapFamilyName if smfn is not None: if smfn.startswith(ufo_instance.familyName): smfn = smfn[len(ufo_instance.familyName):].strip() instance.linkStyle = smfn if ufo_instance.styleMapStyleName is not None: style = ufo_instance.styleMapStyleName instance.isBold = ('bold' in style) instance.isItalic = ('italic' in style) if ufo_instance.postScriptFontName is not None: instance.fontName = ufo_instance.postScriptFontName try: instance.manualInterpolation = ufo_instance.lib[ MANUAL_INTERPOLATION_KEY] except KeyError: pass try: instance.instanceInterpolations = ufo_instance.lib[ INSTANCE_INTERPOLATIONS_KEY] except KeyError: # TODO: (jany) compute instanceInterpolations from the location # if instance.manualInterpolation: warn about data loss pass if CUSTOM_PARAMETERS_KEY in ufo_instance.lib: for name, value in ufo_instance.lib[CUSTOM_PARAMETERS_KEY]: instance.customParameters.append(GSCustomParameter( name, value)) if self.minimize_ufo_diffs: instance.customParameters[ FULL_FILENAME_KEY] = ufo_instance.filename # FIXME: (jany) cannot `.append()` because no proxy => no parent self.font.instances = self.font.instances + [instance]
def test_replace_prefix(self): self.ufo.features.text = dedent( """\ # Prefix: AAA include(../aaa.fea); # Prefix: FOO # foo # Prefix: ZZZ include(../zzz.fea); # Prefix: BAR # bar feature liga { sub f i by f_i; } liga; table GDEF { GlyphClassDef [f i], # Base [f_i], # Liga , # Mark ; } GDEF; """ ) self.master.customParameters.append( GSCustomParameter("Replace Prefix", "FOO; include(../foo.fea);") ) self.master.customParameters.append( GSCustomParameter("Replace Prefix", "BAR; include(../bar.fea);") ) self.set_custom_params() self.assertEqual( self.ufo.features.text, dedent( """\ # Prefix: AAA include(../aaa.fea); # Prefix: FOO include(../foo.fea); # Prefix: ZZZ include(../zzz.fea); # Prefix: BAR include(../bar.fea); table GDEF { GlyphClassDef [f i], # Base [f_i], # Liga , # Mark ; } GDEF; feature liga { sub f i by f_i; } liga; """ ), )