[Issue-60] Add HelveticaNeue font family

Author: Mark Pospesel

Sources/YMatterType/Typography/FontFamily/FontFamily.swift

@@ -108,7 +108,12 @@ extension FontFamily {
         let useBoldFont = isBoldTextEnabled(compatibleWith: traitCollection)
         let actualWeight = useBoldFont ? accessibilityBoldWeight(for: weight) : weight
         let weightName = weightName(for: actualWeight)
-        return "\(familyName)-\(weightName)\(fontNameSuffix)"
+        let suffix = fontNameSuffix
+        if weightName.isEmpty && suffix.isEmpty {
+            // don't use "-" if nothing will follow it
+            return familyName
+        }
+        return "\(familyName)-\(weightName)\(suffix)"
     }
 
     /// Returns default name for each weight

Sources/YMatterType/Typography/FontFamily/HelveticaNeueFontFamily.swift

@@ -0,0 +1,65 @@
+//
+//  HelveticaNeueFontFamily.swift
+//  YMatterType
+//
+//  Created by Mark Pospesel on 3/2/23.
+//  Copyright © 2023 Y Media Labs. All rights reserved.
+//
+
+import UIKit
+
+public extension Typography {
+    /// HelveticaNeue font family
+    static let helveticaNeue = HelveticaNeueFontFamily(style: .regular)
+    /// HelveticaNeue Italic font family
+    static let helveticaNeueItalic = HelveticaNeueFontFamily(style: .italic)
+}
+
+/// Information about the Helvetica Neue family of fonts
+public struct HelveticaNeueFontFamily: FontFamily {
+    /// Font family root name
+    public let familyName: String = "HelveticaNeue"
+
+    /// Font style, e.g. regular or italic
+    public let style: Typography.FontStyle
+
+    /// Initialize a `HelveticaNeueFontFamily` object
+    /// - Parameter style: font style (default = `.regular`)
+    public init(style: Typography.FontStyle = .regular) {
+        self.style = style
+    }
+
+    /// HelveticaNeue supports 6 font weights (nothing heavier than bold)
+    public var supportedWeights: [Typography.FontWeight] {
+        [.ultralight, .thin, .light, .regular, .medium, .bold]
+    }
+
+    public func weightName(for weight: Typography.FontWeight) -> String {
+        // Default font name suffix by weight
+        switch weight {
+        case .ultralight:
+            return "UltraLight"
+        case .thin:
+            return "Thin"
+        case .light:
+            return "Light"
+        case .regular:
+            return "" // HelveticaNeue skips the weight name for regular
+        case .medium:
+            return "Medium"
+        case .bold:
+            return "Bold"
+        case .semibold, .heavy, .black:
+            return "" // HelveticaNeue does not support these weights
+        }
+    }
+
+    /// Optional suffix to use for the font name.
+    ///
+    /// Used by `FontFamily.fontName(for:compatibleWith:)`
+    /// e.g. "Italic" is a typical suffix for italic fonts.
+    /// default = ""
+    public var fontNameSuffix: String {
+        (style == .italic) ? DefaultFontFamily.italicSuffix : ""
+    }
+}

Tests/YMatterTypeTests/Typography/FontFamily/FontFamilyTests.swift

@@ -112,6 +112,30 @@ final class FontFamilyTests: XCTestCase {
         // given traitCollection is nil, it should return the system setting
         XCTAssertEqual(sut.isBoldTextEnabled(compatibleWith: nil), UIAccessibility.isBoldTextEnabled)
     }
+
+    func test_fontNameWithoutWeightOrSuffix_isFamilyName() {
+        let sut = WeightlessFontFamily()
+        var name: String
+
+        // If there's a weight name then we will append it
+        sut.weightName = "Regular"
+        name = sut.fontName(for: .regular, compatibleWith: nil)
+        XCTAssertNotEqual(name, sut.familyName)
+        XCTAssertTrue(name.hasSuffix("-" + sut.weightName))
+
+        // If there's a suffix then we will append it
+        sut.weightName = ""
+        sut.fontNameSuffix = "Italic"
+        name = sut.fontName(for: .regular, compatibleWith: nil)
+        XCTAssertNotEqual(name, sut.familyName)
+        XCTAssertTrue(name.hasSuffix("-" + sut.fontNameSuffix))
+
+        // If there's neither then we just return the family name
+        sut.fontNameSuffix = ""
+        name = sut.fontName(for: .regular, compatibleWith: nil)
+        XCTAssertEqual(name, sut.familyName)
+        XCTAssertNil(name.firstIndex(of: "-"))
+    }
 }
 
 // We use large tuples in makeSUT()
@@ -146,3 +170,11 @@ final class MockFontFamily: FontFamily {
 
     var supportedWeights: [Typography.FontWeight] = Typography.FontWeight.allCases
 }
+
+final class WeightlessFontFamily: FontFamily {
+    let familyName: String = "Weightless"
+    var weightName: String = ""
+    var fontNameSuffix: String = ""
+
+    func weightName(for weight: Typography.FontWeight) -> String { weightName }
+}

Tests/YMatterTypeTests/Typography/FontFamily/HelveticaNeueFontFamilyTests.swift

@@ -0,0 +1,57 @@
+//
+//  HelveticaNeueFontFamilyTests.swift
+//  YMatterTypeTests
+//
+//  Created by Mark Pospesel on 3/2/23.
+//  Copyright © 2023 Y Media Labs. All rights reserved.
+//
+
+import XCTest
+@testable import YMatterType
+
+final class HelveticaNeueFontFamilyTests: XCTestCase {
+    func testFont() {
+        let (families, traitCollections) = makeSUT()
+        for family in families {
+            for weight in family.supportedWeights {
+                for traitCollection in traitCollections {
+                    let pointSize = CGFloat(Int.random(in: 10...32))
+                    let font = family.font(for: weight, pointSize: pointSize, compatibleWith: traitCollection)
+                    XCTAssertEqual(font.familyName, "Helvetica Neue")
+                    XCTAssertEqual(font.pointSize, pointSize)
+                }
+            }
+        }
+    }
+
+    func testRegular() {
+        let (families, _) = makeSUT()
+        for family in families {
+            XCTAssertTrue(family.weightName(for: .regular).isEmpty)
+        }
+    }
+
+    func testUnsupportedWeights() {
+        let (families, _) = makeSUT()
+        for family in families {
+            let unsupported = Typography.FontWeight.allCases.filter { !family.supportedWeights.contains($0) }
+            for weight in unsupported {
+                XCTAssertTrue(family.weightName(for: weight).isEmpty)
+            }
+        }
+    }
+}
+
+private extension HelveticaNeueFontFamilyTests {
+    func makeSUT() -> ([FontFamily], [UITraitCollection?]) {
+        super.setUp()
+        let families: [FontFamily] = [Typography.helveticaNeue, Typography.helveticaNeueItalic]
+        let traitCollections: [UITraitCollection?] = [
+            nil,
+            UITraitCollection(legibilityWeight: .unspecified),
+            UITraitCollection(legibilityWeight: .regular),
+            UITraitCollection(legibilityWeight: .bold)
+        ]
+        return (families, traitCollections)
+    }
+}