Support Glyphs3 RTL kerning

Lib/glyphsLib/builder/groups.py

@@ -17,7 +17,7 @@
 import os
 import re
 
-from glyphsLib import classes
+from glyphsLib import classes, glyphdata
 from .constants import GLYPHLIB_PREFIX
 from .glyph import BRACKET_GLYPH_RE
 
@@ -140,12 +140,28 @@ def _to_glyphs_kerning_group(self, name, glyphs):
 
 def _glyph_kerning_attr(glyph, side):
     """Return leftKerningGroup or rightKerningGroup depending on the UFO
-    group's side (1 or 2).
+    group's side (1 or 2) and writing script.
     """
-    if int(side) == 1:
-        return "rightKerningGroup"
-    else:
-        return "leftKerningGroup"
+    if glyph.parent.format_version > 2:  # Glyphs 3
+        glyph_data = glyphdata.get_glyph(glyph.name)
+        if (
+            glyph_data.script in ("arabic", "hebrew")
+            and glyph_data.category != "Number"
+        ):
+            if int(side) == 1:
+                return "leftKerningGroup"
+            else:
+                return "rightKerningGroup"
+        else:
+            if int(side) == 1:
+                return "rightKerningGroup"
+            else:
+                return "leftKerningGroup"
+    else:  # Glyphs 2
+        if int(side) == 1:
+            return "rightKerningGroup"
+        else:
+            return "leftKerningGroup"
 
 
 def _assert_groups_are_identical(self, reference_ufo, ufo):

Lib/glyphsLib/builder/kerning.py

@@ -24,25 +24,34 @@ def to_ufo_kerning(self):
     for master in self.font.masters:
         master_id = master.id
         kerning_source = master.metricsSource.id  # Maybe be a linked master
-        if kerning_source in self.font.kerning:
-            kerning = self.font.kerning[kerning_source]
+        if kerning_source in self.font.kerningLTR:
+            kerning = self.font.kerningLTR[kerning_source]
             _to_ufo_kerning(self, self._sources[master_id].font, kerning)
+        if kerning_source in self.font.kerningRTL:
+            kerning = self.font.kerningRTL[kerning_source]
+            _to_ufo_kerning(self, self._sources[master_id].font, kerning, "RTL")
 
 
-def _to_ufo_kerning(self, ufo, kerning_data):
+def _to_ufo_kerning(self, ufo, kerning_data, direction="LTR"):
     """Add .glyphs kerning to an UFO."""
 
     warning_msg = "Non-existent glyph class %s found in kerning rules."
 
     for left, pairs in kerning_data.items():
-        match = re.match(r"@MMK_L_(.+)", left)
+        if direction == "LTR":
+            match = re.match(r"@MMK_L_(.+)", left)
+        elif direction == "RTL":
+            match = re.match(r"@MMK_R_(.+)", left)
         left_is_class = bool(match)
         if left_is_class:
             left = "public.kern1.%s" % match.group(1)
             if left not in ufo.groups:
                 self.logger.warning(warning_msg % left)
         for right, kerning_val in pairs.items():
-            match = re.match(r"@MMK_R_(.+)", right)
+            if direction == "LTR":
+                match = re.match(r"@MMK_R_(.+)", right)
+            elif direction == "RTL":
+                match = re.match(r"@MMK_L_(.+)", right)
             right_is_class = bool(match)
             if right_is_class:
                 right = "public.kern2.%s" % match.group(1)

Lib/glyphsLib/classes.py

@@ -4643,8 +4643,8 @@ def settings(self):
         {"plist_name": "features", "type": GSFeature},
         {"plist_name": "fontMaster", "object_name": "masters", "type": GSFontMaster},
         {"plist_name": "kerning", "object_name": "_kerningLTR", "type": OrderedDict},
-        {"plist_name": "kerningLTR", "type": OrderedDict},
-        {"plist_name": "kerningRTL", "type": OrderedDict},
+        {"plist_name": "kerningLTR", "object_name": "_kerningLTR", "type": OrderedDict},
+        {"plist_name": "kerningRTL", "object_name": "_kerningRTL", "type": OrderedDict},
         {"plist_name": "kerningVertical", "type": OrderedDict},
         {"plist_name": "date", "converter": parse_datetime},
         {"plist_name": "disablesAutomaticAlignment", "converter": bool},

Lib/glyphsLib/glyphdata.py

@@ -131,8 +131,10 @@ def get_glyph(glyph_name, data=None, unicodes=None):
     if category is None:
         category, sub_category = _construct_category(glyph_name, data)
 
-    # TODO: Determine script in ligatures.
     script = attributes.get("script")
+    if script is None:
+        script = _construct_script(glyph_name, data=data)
+
     description = attributes.get("description")
 
     return Glyph(
@@ -254,6 +256,42 @@ def _construct_category(glyph_name, data):
     return None, None
 
 
+def _construct_script(glyph_name, data):
+    """Derive script of a glyph name."""
+    # Glyphs creates glyphs that start with an underscore as "non-exportable" glyphs or
+    # construction helpers without a category.
+    if glyph_name.startswith("_"):
+        return None
+
+    # Glyph variants (e.g. "fi.alt") don't have their own entry, so we strip e.g. the
+    # ".alt" and try a second lookup with just the base name. A variant is hopefully in
+    # the same category as its base glyph.
+    base_name = glyph_name.split(".", 1)[0]
+    base_attribute = data.names.get(base_name) or {}
+    if base_attribute:
+        script = base_attribute.get("script")
+        return script
+
+    # Detect ligatures.
+    if "_" in base_name:
+        base_names = base_name.split("_")
+        # The last name has a suffix, add it to all the names.
+        if "-" in base_names[-1]:
+            _, s = base_names[-1].rsplit("-", 1)
+            base_names = [
+                (n if n.endswith(f"-{s}") else f"{n}-{s}") for n in base_names
+            ]
+        base_names_attributes = [_lookup_attributes(name, data) for name in base_names]
+        first_attribute = base_names_attributes[0]
+
+        # If the first part is a Letter...
+        if first_attribute.get("category") == "Letter":
+            script = first_attribute.get("script")
+            return script
+
+    return None
+
+
 def _translate_category(glyph_name, unicode_category):
     """Return a translation from Unicode category letters to Glyphs
     categories."""

tests/data/RTL_kerning_v2.glyphs

@@ -0,0 +1,183 @@
+{
+.appVersion = "1352";
+DisplayStrings = (
+"/alef-hb/bet-hb",
+"/reh-ar/hah-ar.init.swsh/hah-ar.init"
+);
+date = "2022-02-09 20:07:11 +0000";
+familyName = "RTL kerning";
+fontMaster = (
+{
+ascender = 800;
+capHeight = 700;
+descender = -200;
+id = m01;
+xHeight = 500;
+}
+);
+glyphs = (
+{
+glyphname = A;
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+unicode = 0041;
+},
+{
+glyphname = B;
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+unicode = 0042;
+},
+{
+glyphname = C;
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+unicode = 0043;
+},
+{
+glyphname = "hah-ar.init";
+lastChange = "2022-02-21 17:09:37 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+leftKerningGroup = "hah-ar.init";
+unicode = FEA3;
+},
+{
+glyphname = "hah-ar.init.swsh";
+lastChange = "2022-02-21 17:25:40 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+leftKerningGroup = "hah-ar.init.swsh";
+},
+{
+glyphname = "reh-ar";
+lastChange = "2022-02-21 17:09:13 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+rightKerningGroup = "reh-ar";
+unicode = 0631;
+},
+{
+glyphname = "alef-hb";
+lastChange = "2022-02-21 11:17:22 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+rightKerningGroup = leftAlef;
+unicode = 05D0;
+},
+{
+glyphname = "bet-hb";
+lastChange = "2022-02-21 11:17:26 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+leftKerningGroup = rightBet;
+unicode = 05D1;
+},
+{
+glyphname = "he-hb";
+lastChange = "2022-02-17 09:36:21 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+unicode = 05D4;
+},
+{
+glyphname = "one-ar";
+lastChange = "2022-02-21 14:41:56 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+leftKerningGroup = "left-one-ar";
+unicode = 0661;
+},
+{
+glyphname = "one-ar.wide.ss16.calt";
+lastChange = "2022-02-21 14:59:56 +0000";
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+leftKerningGroup = "left-one-ar";
+},
+{
+glyphname = space;
+layers = (
+{
+layerId = m01;
+width = 600;
+}
+);
+unicode = 0020;
+}
+);
+instances = (
+{
+instanceInterpolations = {
+m01 = 1;
+};
+name = Regular;
+}
+);
+kerning = {
+m01 = {
+"@MMK_L_leftAlef" = {
+"@MMK_R_rightBet" = -20;
+"he-hb" = 4;
+};
+"@MMK_L_leftBet" = {
+"@MMK_R_rightAlef" = 20;
+};
+"@MMK_L_reh-ar" = {
+"@MMK_R_hah-ar.init" = -50;
+"@MMK_R_hah-ar.init.swsh" = -50;
+};
+"he-hb" = {
+"@MMK_R_rightAlef" = -2;
+"he-hb" = -21;
+};
+};
+};
+unitsPerEm = 1000;
+versionMajor = 1;
+versionMinor = 0;
+}