Changeset 422

Timestamp:

02/03/09 19:09:30 (4 years ago)

Author:

tal

Message:

Significantly revised the way features are handled.

File:

• packages/ufo2fdk/trunk/Lib/ufo2fdk/makeotfParts.py (modified) (20 diffs)

packages/ufo2fdk/trunk/Lib/ufo2fdk/makeotfParts.py

@@ -5 +5 @@
 from outlineOTF import OutlineOTFCompiler
 from featureTableWriter import FeatureTableWriter, winStr, macStr
+from kernFeatureWriter import KernFeatureWriter
 
 
@@ -192 +193 @@
     def setupFile_features(self, path):
         """
-        Make the features source file.
+        Make the features source file. If any tables
+        or the kern feature are defined in the font's
+        features, they will not be overwritten.
 
         **This should not be called externally.** Subclasses
@@ -199 +202 @@
         """
         # force absolute includes into the features
+        existingFeaturePath = os.path.join(self.font.path, "features.fea")
         existing = forceAbsoluteIncludesInFeatures(self.font.features.text, self.font.path)
         # break the features into parts
-        initialText, features, tables = breakFeaturesAndTables(existing)
-        # extract the relevant parts from the features and tables
-        gsubGpos = [initialText]
-        kernFeature = None
-        for name, text in features:
-            if name == "kern":
-                kernFeature = text
-            else:
-                gsubGpos.append(text)
-        gsubGpos = "\n".join(gsubGpos).strip()
-        if not gsubGpos:
-            gsubGpos = None
-        unknownTables = []
-        headTable = None
-        hheaTable = None
-        os2Table = None
-        nameTable = None
-        for name, text in tables:
-            if name == "head":
-                headTable = text
-            elif name == "hhea":
-                hheaTable = text
-            elif name == "OS/2":
-                os2Table = text
-            elif name == "name":
-                nameTable = text
-            else:
-                unknownTables.append(text)
-        unknownTables = "\n".join(unknownTables)
-        # compile the new features
-        features = [
-            self.writeFeatures_basic(gsubGpos),
-            "",
-            self.writeFeatures_kern(kernFeature),
-            "",
-            self.writeFeatures_head(headTable),
-            "",
-            self.writeFeatures_hhea(hheaTable),
-            "",
-            self.writeFeatures_OS2(os2Table),
-            "",
-            self.writeFeatures_name(nameTable),
-            "",
-            unknownTables
-        ]
-        features = "\n".join(features)
+        features, tables = extractFeaturesAndTables(existing, scannedFiles=[existingFeaturePath])
+        # build tables that are not in the existing features
+        autoTables = {}
+        if "head" not in tables:
+            autoTables["head"] = self.writeFeatures_head()
+        if "hhea" not in tables:
+            autoTables["hhea"] = self.writeFeatures_hhea()
+        if "OS/2" not in tables:
+            autoTables["OS/2"] = self.writeFeatures_OS2()
+        if "name" not in tables:
+            autoTables["name"] = self.writeFeatures_name()
+        # build the kern feature if necessary
+        autoFeatures = {}
+        if "kern" not in features and len(self.font.kerning):
+            autoFeatures["kern"] = self.writeFeatures_kern()
+        # write the features
+        features = [existing]
+        for name, text in sorted(autoFeatures.items()):
+            features.append(text)
+        for name, text in sorted(autoTables.items()):
+            features.append(text)
+        features = "\n\n".join(features)
         # write the result
         f = open(path, "wb")
@@ -252 +232 @@
         f.close()
 
-    def writeFeatures_basic(self, existing):
-        """
-        Write the GSUB and GPOS features, excluding kern,
-        to a string and return it. *existing* will be
-        the existing GSUB and GPOS features in the font
-        excluding kern.
+    def writeFeatures_kern(self):
+        """
+        Write the kern feature to a string and return it.
 
         **This should not be called externally.** Subclasses
@@ -263 +240 @@
         in a different way if desired.
         """
-        if existing is None:
-            return ""
-        return existing
-
-    def writeFeatures_kern(self, existing):
-        """
-        Write the kern feature to a string and return it.
-        *existing* will be the existing kern feature in the font.
-
-        **This should not be called externally.** Subclasses
-        may override this method to handle the string creation
-        in a different way if desired.
-        """
-        if existing is not None:
-            return existing
-        font = self.font
-        if not font.kerning.items():
-            return ""
-        neededLeftGroups = set()
-        neededRightGroups = set()
-        noGroup = {}
-        leftGroup = {}
-        rightGroup = {}
-        bothGroup = {}
-        for (left, right), value in font.kerning.items():
-            if left.startswith("@") and right.startswith("@"):
-                bothGroup[left, right] = _roundInt(value)
-                neededLeftGroups.add(left)
-                neededRightGroups.add(right)
-            elif left.startswith("@"):
-                leftGroup[left, right] = _roundInt(value)
-                neededLeftGroups.add(left)
-            elif right.startswith("@"):
-                rightGroup[left, right] = _roundInt(value)
-                neededRightGroups.add(right)
-            else:
-                noGroup[left, right] = _roundInt(value)
-        lines = ["feature kern {"]
-        emptyGroups = set()
-        for groupName in sorted(neededLeftGroups):
-            contents = font.groups.get(groupName, [])
-            if not contents:
-                emptyGroups.add(groupName)
-                continue
-            lines.append("    %s = [%s];" % (groupName, " ".join(contents)))
-        for groupName in sorted(neededRightGroups):
-            contents = font.groups.get(groupName, [])
-            if not contents:
-                emptyGroups.add(groupName)
-                continue
-            lines.append("    %s = [%s];" % (groupName, " ".join(contents)))
-        for (left, right), value in sorted(noGroup.items()):
-            lines.append("    pos %s %s %d;" % (left, right, value))
-        for (left, right), value in sorted(leftGroup.items()):
-            if left in emptyGroups:
-                continue
-            lines.append("    pos %s %s %d;" % (left, right, value))
-        for (left, right), value in sorted(rightGroup.items()):
-            if right in emptyGroups:
-                continue
-            lines.append("    pos %s %s %d;" % (left, right, value))
-        for (left, right), value in sorted(bothGroup.items()):
-            if left in emptyGroups or right in emptyGroups:
-                continue
-            lines.append("    pos %s %s %d;" % (left, right, value))
-        lines.append("} kern;")
-        return "\n".join(lines)
-
-    def writeFeatures_head(self, existing):
+        writer = KernFeatureWriter(self.font)
+        return writer.write()
+
+    def writeFeatures_head(self):
         """
         Write the head to a string and return it.
-        *existing* will be the existing head table in the font.
 
         This gets the values for the file using the fallback
@@ -347 +258 @@
         in a different way if desired.
         """
-        if existing is not None:
-            return existing
         versionMajor = getattr(self.font.info, "versionMajor")
         versionMinor = getattr(self.font.info, "versionMinor")
@@ -356 +265 @@
         return writer.write()
 
-    def writeFeatures_hhea(self, existing):
+    def writeFeatures_hhea(self):
         """
         Write the hhea to a string and return it.
-        *existing* will be the existing hhea table in the font.
 
         This gets the values for the file using the fallback
@@ -375 +283 @@
         in a different way if desired.
         """
-        if existing is not None:
-            return existing
         ascender = getAttrWithFallback(self.font.info, "openTypeHheaAscender")
         descender = getAttrWithFallback(self.font.info, "openTypeHheaDescender")
@@ -388 +294 @@
         return writer.write()
 
-    def writeFeatures_name(self, existing):
+    def writeFeatures_name(self):
         """
         Write the name to a string and return it.
-        *existing* will be the existing name table in the font.
 
         This gets the values for the file using the fallback
@@ -413 +318 @@
         in a different way if desired.
         """
-        if existing is not None:
-            return existing
         idToAttr = [
             (0  , "copyright"),
@@ -444 +347 @@
         return writer.write()
 
-    def writeFeatures_OS2(self, existing):
+    def writeFeatures_OS2(self):
         """
         Write the OS/2 to a string and return it.
-        *existing* will be the existing OS/2 table in the font.
 
         This gets the values for the file using the fallback
@@ -473 +375 @@
         in a different way if desired.
         """
-        if existing is not None:
-            return existing
         codePageBitTranslation = {
             0  : "1252",
@@ -537 +437 @@
 
 
+includeRE = re.compile(
+    "include"
+    "\("
+    "([^\)]+)"
+    "\)"
+    )
+
 def forceAbsoluteIncludesInFeatures(text, directory):
     """
@@ -542 +449 @@
     to absolute includes.
     """
-    includeRE = re.compile(
-        "include"
-        "\("
-        "([^\)]+)"
-        "\)"
-        )
     for includePath in includeRE.findall(text):
         currentDirectory = directory
@@ -605 +506 @@
 )
 
-def breakFeaturesAndTables(text):
+def extractFeaturesAndTables(text, scannedFiles=[]):
     # strip all comments
     decommentedLines = [line.split("#")[0] for line in text.splitlines()]
@@ -622 +523 @@
         destringedLines.append(line)
     text = "\n".join(destringedLines)
+    # extract all includes
+    includes = includeRE.findall(text)
     # slice off the text that comes before
     # the first feature/table definition
@@ -636 +539 @@
     broken = _textBreakRecurse(text)
     # organize into tables and features
-    features = []
-    tables = []
+    features = {}
+    tables = {}
     for text in broken:
         text = text.strip()
@@ -652 +555 @@
         featureMatch = featureNameRE.search(text)
         if featureMatch is not None:
-            features.append((featureMatch.group(1), finalText))
+            features[featureMatch.group(1)] = finalText
         else:
             tableMatch = tableNameRE.search(text)
-            tables.append((tableMatch.group(1), finalText))
-    return precedingText, features, tables
+            tables[tableMatch.group(1)] = finalText
+    # scan all includes
+    for path in includes:
+        if path in scannedFiles:
+            continue
+        scannedFiles.append(path)
+        if os.path.exists(path):
+            f = open(path, "r")
+            text = f.read()
+            f.close()
+            f, t = extractFeaturesAndTables(text, scannedFiles)
+            features.update(f)
+            tables.update(t)
+    return features, tables
 
 def _textBreakRecurse(text):
@@ -690 +605 @@
 
 
-breakFeaturesAndTablesTestText = """
+extractFeaturesAndTablesTestText = """
 @foo = [bar];
 
@@ -707 +622 @@
 """
 
-breakFeaturesAndTablesTestResult = ('@foo = [bar];',
- [('fts2', 'feature fts2 {\n    sub foo by bar;\n} fts2;'),
-  ('fts3', 'feature fts3 { sub a by b;} fts3;')],
- [('tts1',
-   'table tts1 {\n    nameid 1 "feature this { is not really a \\"feature that { other thing is";\n} tts1;')])
+#extractFeaturesAndTablesTestResult = ('@foo = [bar];',
+# [('fts2', 'feature fts2 {\n    sub foo by bar;\n} fts2;'),
+#  ('fts3', 'feature fts3 { sub a by b;} fts3;')],
+# [('tts1',
+#   'table tts1 {\n    nameid 1 "feature this { is not really a \\"feature that { other thing is";\n} tts1;')])
+
+extractFeaturesAndTablesTestResult = (
+    {
+        'fts2': 'feature fts2 {\n    sub foo by bar;\n} fts2;',
+        'fts3': 'feature fts3 { sub a by b;} fts3;'
+    },
+    {
+        'tts1': 'table tts1 {\n    nameid 1 "feature this { is not really a \\"feature that { other thing is";\n} tts1;'
+    }
+)
 
 def testBreakFeaturesAndTables():
     """
-    >>> r = breakFeaturesAndTables(breakFeaturesAndTablesTestText)
-    >>> r == breakFeaturesAndTablesTestResult
+    >>> r = extractFeaturesAndTables(extractFeaturesAndTablesTestText)
+    >>> r == extractFeaturesAndTablesTestResult
     True
     """