new check: GF family_name compliance

Renamed check ID on Google Fonts profile:
com.google.fonts/check/metadata/fontname_not_camel_cased
=> com.google.fonts/check/name/family_name_compliance

(issue fonttools#4049)

Author: yanone

CHANGELOG.md

@@ -45,6 +45,11 @@ A more detailed list of changes is available in the corresponding milestones for
   - **[com.google.fonts/check/empty_glyph_on_gid1_for_colrv0]:** Ensure that GID 1 is empty to work around Windows 10 rendering bug ([gftools issue #609](https://github.com/googlefonts/gftools/issues/609))
   - **[com.google.fonts/check/metadata/valid_nameid25]:** Check Name ID 25 for VF Italics (issue #3024)
   - **[com.google.fonts/check/metadata/consistent_repo_urls]:** Check URL on copyright string is the same as in repository_url field. (issue #4056)
+  - **[com.google.fonts/check/name/family_name_compliance]:** Expanded and revised version of `metadata/fontname_not_camel_cased` check (issue #4049)
+
+### Renamed check IDs
+#### On Google Fonts profile
+  - **[com.google.fonts/check/metadata/fontname_not_camel_cased]** => com.google.fonts/check/name/family_name_compliance
 
 ### Deprecated checks
 #### Removed from the Open Type and Adobe Profiles

Lib/fontbakery/data/googlefonts/abbreviations_familyname_exceptions.txt

@@ -0,0 +1,10 @@
+# In general, we would not like to have abbreviations
+# font family names in the Google Fonts collection
+# but there are a few exceptions to that rule,
+# that we keep listed here, for now.
+
+SIL
+PT
+IBM
+STIX
+VT

Lib/fontbakery/profiles/googlefonts.py

@@ -74,7 +74,6 @@
     'com.google.fonts/check/metadata/filenames',
     'com.google.fonts/check/metadata/italic_style',
     'com.google.fonts/check/metadata/normal_style',
-    'com.google.fonts/check/metadata/fontname_not_camel_cased',
     'com.google.fonts/check/metadata/match_name_familyname',
     'com.google.fonts/check/metadata/canonical_weight_value',
     'com.google.fonts/check/metadata/os2_weightclass',
@@ -120,7 +119,8 @@
     'com.google.fonts/check/name/license_url',
     'com.google.fonts/check/name/family_and_style_max_length',
     'com.google.fonts/check/name/line_breaks',
-    'com.google.fonts/check/name/rfn'
+    'com.google.fonts/check/name/rfn',
+    'com.google.fonts/check/name/family_name_compliance',
 ]
 
 
@@ -2755,32 +2755,6 @@ def com_google_fonts_check_metadata_nameid_family_and_full_names(ttFont, font_me
                      " match corresponding name table entries.")
 
 
-@check(
-    id = 'com.google.fonts/check/metadata/fontname_not_camel_cased',
-    rationale = """
-        We currently have a policy of avoiding camel-cased font family names other
-        than in a very small set of exceptions.
-        
-        If you want to have your family name added to the exceptions list, please read
-        the instructions at https://github.com/googlefonts/fontbakery/issues/3270
-    """,
-    conditions = ['font_metadata',
-                  'not camelcased_familyname_exception'],
-    proposal = 'legacy:check/109'
-)
-def com_google_fonts_check_metadata_fontname_not_camel_cased(font_metadata):
-    """METADATA.pb: Check if fontname is not camel cased."""
-    import re
-    if bool(re.match(r'([A-Z][a-z]+){2,}', font_metadata.name)):
-        yield FAIL,\
-              Message("camelcase",
-                      f'METADATA.pb: "{font_metadata.name}" is a CamelCased name.'
-                      f' To solve this, simply use spaces'
-                      f' instead in the font name.')
-    else:
-        yield PASS, "Font name is not camel-cased."
-
-
 @check(
     id = 'com.google.fonts/check/metadata/match_name_familyname',
     conditions = ['family_metadata', # that's the family-wide metadata!
@@ -4377,6 +4351,113 @@ def com_google_fonts_check_name_rfn(ttFont, familyname):
         yield PASS, 'None of the name table strings contain "Reserved Font Name".'
 
 
+@check(
+    id = 'com.google.fonts/check/name/family_name_compliance',
+    rationale = """
+        Checks the family name for compliance with the Google Fonts Guide.
+        https://googlefonts.github.io/gf-guide/onboarding.html#new-fonts
+        
+        If you want to have your family name added to the CamelCase
+        exceptions list, please submit a pull request to the
+        camelcased_familyname_exceptions.txt file.
+
+        Similarly, abbreviations can be submitted to the
+        abbreviations_familyname_exceptions.txt file.
+
+        These are located in the Lib/fontbakery/data/googlefonts/ directory
+        of the FontBakery source code currently hosted at
+        https://github.com/googlefonts/fontbakery/
+    """,
+    conditions = [],
+    proposal = "https://github.com/googlefonts/fontbakery/issues/4049"
+)
+def com_google_fonts_check_name_family_name_compliance(ttFont):
+    """Check family name for GF Guide compliance."""
+    import re
+    from pkg_resources import resource_filename
+    from fontbakery.utils import get_name_entries
+    camelcase_exceptions_txt = 'data/googlefonts/camelcased_familyname_exceptions.txt'
+    abbreviations_exceptions_txt = 'data/googlefonts/abbreviations_familyname_exceptions.txt'
+    passed = True
+
+    if get_name_entries(ttFont, NameID.TYPOGRAPHIC_FAMILY_NAME):
+        family_name = get_name_entries(ttFont, NameID.TYPOGRAPHIC_FAMILY_NAME)[0].toUnicode()
+    else:
+        family_name = get_name_entries(ttFont, NameID.FONT_FAMILY_NAME)[0].toUnicode()
+
+    # CamelCase
+    if bool(re.match(r'([A-Z][a-z]+){2,}', family_name)):
+        known_exception = False
+
+        # Process exceptions
+        filename = resource_filename('fontbakery', camelcase_exceptions_txt)
+        for exception in open(filename, "r").readlines():
+            exception = exception.split('#')[0].strip()
+            if exception == "":
+                continue
+            if exception in family_name:
+                known_exception = True
+                yield PASS,\
+                      Message("known-camelcase-exception",
+                              "Family name is a known exception"
+                              " to the CamelCase rule.")
+                break
+        
+        if not known_exception:
+            passed = False
+            yield FAIL,\
+                  Message("camelcase",
+                          f'"{family_name}" is a CamelCased name.'
+                          f' To solve this, simply use spaces'
+                          f' instead in the font name.')
+
+    # Abbreviations
+    if bool(re.match(r'([A-Z]){2,}', family_name)):
+        known_exception = False
+
+        # Process exceptions
+        filename = resource_filename('fontbakery', abbreviations_exceptions_txt)
+        for exception in open(filename, "r").readlines():
+            exception = exception.split('#')[0].strip()
+            if exception == "":
+                continue
+            if exception in family_name:
+                known_exception = True
+                yield PASS,\
+                      Message("known-abbreviation-exception",
+                              "Family name is a known exception"
+                              " to the abbreviation rule.")
+                break
+        
+        if not known_exception:
+            # Allow SC ending
+            if not family_name.endswith("SC"):
+                passed = False
+                yield FAIL,\
+                      Message("abbreviation",
+                              f'"{family_name}" contains an abbreviation.')
+
+    # Allowed characters
+    forbidden_characters = re.findall(r'[^a-zA-Z0-9 ]', family_name)
+    if forbidden_characters:
+        forbidden_characters = "".join(sorted(list(set(forbidden_characters))))
+        passed = False
+        yield FAIL,\
+              Message("forbidden-characters",
+                      f'"{family_name}" contains the following characters'
+                      f' which are not allowed: "{forbidden_characters}".')
+
+    # Starts with uppercase
+    if not bool(re.match(r'^[A-Z]', family_name)):
+        passed = False
+        yield FAIL,\
+              Message("starts-with-not-uppercase",
+                      f'"{family_name}" doesn\'t start with an uppercase letter.')
+
+    if passed:
+        yield PASS, "Font name looks good."
+
+
 @check(
     id = 'com.google.fonts/check/family/control_chars',
     conditions = ['are_ttf'],

Lib/fontbakery/profiles/googlefonts_conditions.py

@@ -426,29 +426,6 @@ def font_familyname(font_familynames):
     return font_familynames[0]
 
 
-# TODO: Design special case handling mechanism:
-# https://github.com/googlefonts/fontbakery/issues/1540
-# TODO: Improve camelcase check result explanation and whitelisting process:
-#https://github.com/googlefonts/fontbakery/issues/3270
-@condition
-def camelcased_familyname_exception(familyname):
-    '''In general, we would not like to have camel-cased
-       familynames but there are a few exceptions to that
-       rule, that we keep listed here, for now.
-    '''
-    from pkg_resources import resource_filename
-
-    camelcase_exceptions_txt = 'data/googlefonts/camelcased_familyname_exceptions.txt'
-    filename = resource_filename('fontbakery', camelcase_exceptions_txt)
-    for exception in open(filename, "r").readlines():
-        exception = exception.split('#')[0].strip()
-        if exception == "":
-            continue
-
-        if exception in familyname:
-            return True
-
-
 @condition
 def rfn_exception(familyname):
     '''These are the very few font families where we accept usage of

tests/profiles/googlefonts_test.py

@@ -491,6 +491,84 @@ def test_check_name_rfn():
     assert "(FooBar)" in msg
 
 
+def test_check_name_family_name_compliance():
+    """Check family name for GF Guide compliance."""
+    check = CheckTester(googlefonts_profile,
+                        "com.google.fonts/check/name/family_name_compliance")
+
+    def set_name(font, nameID, string):
+        for record in font["name"].names:
+            if record.nameID == nameID:
+                old_string = record.toUnicode()
+                if string != old_string:
+                    font["name"].setName(
+                        string,
+                        record.nameID,
+                        record.platformID,
+                        record.platEncID,
+                        record.langID,
+                    )
+
+    # CAMEL CASE
+    ttFont = TTFont(TEST_FILE("cabin/Cabin-Regular.ttf"))
+    assert_PASS(check(ttFont),
+                'with a good font...')
+
+    # FAIL with a CamelCased name:
+    set_name(ttFont, 1, "GollyGhost")
+    assert_results_contain(check(ttFont),
+                           FAIL, 'camelcase',
+                           'with a bad font name (CamelCased)...')
+    set_name(ttFont, 1, "KonKhmer_SleokChher")
+    assert_results_contain(check(ttFont),
+                           FAIL, 'camelcase',
+                           'with a bad font name (CamelCased)...')
+
+    # PASS with a known CamelCased exception:
+    set_name(ttFont, 1, "KoHo")
+    assert_results_contain(check(ttFont),
+                           PASS, 'known-camelcase-exception',
+                           'with a bad font name (CamelCased)...')
+
+    # ABBREVIATIONS
+    set_name(ttFont, 1, "DTL Prokyon")
+    assert_results_contain(check(ttFont),
+                           FAIL, 'abbreviation',
+                           'with a bad font name')
+    set_name(ttFont, 1, "PT Sans")
+    assert_results_contain(check(ttFont),
+                           PASS, 'known-abbreviation-exception',
+                           'with a bad font name')
+    # Allow SC ending
+    set_name(ttFont, 1, "Amatic SC")
+    assert_PASS(check(ttFont),
+                'with a good font...')
+
+    # FORBIDDEN CHARACTERS
+    set_name(ttFont, 1, "KonKhmer_SleokChher")
+    message = assert_results_contain(check(ttFont),
+                           FAIL, 'forbidden-characters',
+                           'with a bad font name')
+    assert message == '"KonKhmer_SleokChher" contains the following characters which are not allowed: "_".'
+    set_name(ttFont, 1, "Kon*Khmer_Sleok-Chher")
+    message = assert_results_contain(check(ttFont),
+                           FAIL, 'forbidden-characters',
+                           'with a bad font name')
+    assert message == '"Kon*Khmer_Sleok-Chher" contains the following characters which are not allowed: "*-_".'
+
+    # STARTS WITH UPPERCASE
+    set_name(ttFont, 1, "cabin")
+    message = assert_results_contain(check(ttFont),
+                           FAIL, 'starts-with-not-uppercase',
+                           'with a bad font name')
+
+
+    # # And we also make sure the check PASSes with a few known good names:
+    set_name(ttFont, 1, "VT323")
+    assert_PASS(check(ttFont),
+                'with a good font...')
+
+        
 def test_check_metadata_parses():
     """ Check METADATA.pb parse correctly. """
     check = CheckTester(googlefonts_profile,
@@ -2053,38 +2131,6 @@ def test_check_metadata_nameid_family_and_full_names():
             ttFont['name'].names[i].string = backup
 
 
-def test_check_metadata_fontname_not_camel_cased():
-    """ METADATA.pb: Check if fontname is not camel cased. """
-    check = CheckTester(googlefonts_profile,
-                        "com.google.fonts/check/metadata/fontname_not_camel_cased")
-
-    # Our reference Cabin Regular is known to be good
-    font = TEST_FILE("cabin/Cabin-Regular.ttf")
-    assert_PASS(check(font),
-                'with a good font...')
-
-    # Then we FAIL with a CamelCased name:
-    md = check["font_metadata"]
-    md.name = "GollyGhost"
-    assert_results_contain(check(font, {"font_metadata": md}),
-                           FAIL, 'camelcase',
-                           'with a bad font name (CamelCased)...')
-
-    # Real-world case:
-    md.name = "KonKhmer_SleokChher"
-    assert_results_contain(check(font, {"font_metadata": md}),
-                           FAIL, 'camelcase',
-                           'with a bad font name (CamelCased)...')
-
-    # And we also make sure the check PASSes with a few known good names:
-    for good_name in ["VT323",
-                      "PT Sans",
-                      "Amatic SC"]:
-        md.name = good_name
-        assert_PASS(check(font, {"font_metadata": md}),
-                    f'with a good font name "{good_name}"...')
-
-
 def test_check_metadata_match_name_familyname():
     """ METADATA.pb: Check font name is the same as family name. """
     check = CheckTester(googlefonts_profile,