Link

https://nemecek.be/blog/106/new-approach-to-formatters-in-ios-15

Because of a11y localisation, we had to add a new case of date formatting: shortTimeMediumDate

Actual behaviour

Right now one project that uses SHDateFormatter has a format that defines a special order of date components in SHDateformatter+Extensions.swift, like:

let weekdayString = string(from: date, format: .shortWeekday, timeZone: timeZone)
let dateString = string(from: date, format: .noTimeShortDateNoYear, timeZone: timeZone)
let timeString = string(from: date, format: .shortTimeNoDate, timeZone: timeZone)
return weekdayString + ", " + dateString + " - " + timeString

This doesn't work in other languages like Arabic.

Expected behaviour

For these cases Apple has defined a method that uses template date format strings and changes (reorders) them for the specified language. To make that work we have to either add a custom date format to SHDateFormatter which takes a string OR put that special date format in the enum and handle the custom format in SHDateFormatter, like:

I guess the latter is the better option!

Don't forget to update the tests…

• FormatStyle Date Example
• FormatStyle Measurement Example

https://sarunw.com/posts/how-expensive-is-dateformatter

When using Apple's style like in

case .noTimeLongDate:
            SHDateFormatter.formatter.timeStyle = .none
            SHDateFormatter.formatter.dateStyle = .long

provide the style via enum parameters. This ensures that the number of assignments will get lower which will decrease the code complexity. This also reduces the number of cases since we only need one case for all of the current format cases in SHDateFormatter.

Enable Mudule Stability by setting BUILD_LIBRARY_FOR_DISTRIBUTION to YES and SKIP_INSTALL to NO for release builds. See https://www.donnywals.com/what-is-module-stability-in-swift-and-why-should-you-care/

Then you can use a version of the framework compiled using Swift 5.1+ in every app compiled with Swift 5.1+ without recompiling the framework with that specific Swift version.

Expected behaviour

Tests should be designed in a way that makes it easy to add a new language/date. It can then also serve as a nice and compact documentation:

typealias ExpectationsData = (date: Date, expectationsForLocale: [(locale: Locale, expectations: [(format: SHDateFormat, expectedResult: String)])])
let ignorePlaceholder = "IGNORE"

let expectations: [ExpectationsData] = [
    (Date(), [
        (deDELocale, [
            (SHDateFormat.shortWeekday, "Sa"),
            (SHDateFormat.longWeekday, "Samstag"),
            (SHDateFormat.shortMonth, "Jan"),
            (SHDateFormat.longMonth, "Januar"),
            (SHDateFormat.shortYear, "00"),
            (SHDateFormat.longYear, "2000"),
            (SHDateFormat.shortTimeNoDate, "00:00"),
            (SHDateFormat.shortTimeMediumDate, "01.01.2000, 00:00"),
            (SHDateFormat.noTimeShortDateNoYear, "1.1."),
            (SHDateFormat.noTimeShortDate, "01.01.00"),
            (SHDateFormat.noTimeLongDate, "1. Januar 2000"),
            (SHDateFormat.ISO8601, "2000-01-01T00:00:00Z")
        ])
    ])
]

func testExpectedStringFormatting() {

    for item in expectations {
        for expectationForLocale in item.expectationsForLocale {
            for expectation in expectationForLocale.expectations {
                let result = SHDateFormatter.shared.string(from: item.date,
                                                           format: expectation.format,
                                                           locale: expectationForLocale.locale,
                                                           timeZone: gmtZone)
                XCTAssertEqual(result, expectation.expectedResult,
                               message: "\(date) - \(expectationForLocale.locale.identifier) - \(expectation.format) expected \"\(expectation.expectedResult)\" but got \"\(result)\"")
            }
        }
    }
}

In the end we'll only have one test function that should describe the problem as exact as possible so we can identify the problematic item from the test data array.

Links

• https://developer.apple.com/documentation/foundation/relativedatetimeformatter
• https://nshipster.com/formatter/#relativedatetimeformatter

Since this is currently not supported by Apple we have to implement this ourselves using a localized dateFormat string á la HH Uhr mm for German or hh mm a for 12h USA English.

In every case this is testable by setttting the devices language and 12/24 h format and let the device speak the time.

Expected behaviour

The is a super user friendly way to format dates into strings. We need one extension for each Date format (or one with 2 parameters, date and format):

extension String.StringInterpolation {
    mutating func appendInterpolation(date: Date, format: SHDateFormat) {
       let string = SHDateFormatter.shared.string(from: date, format: format)
       appendLiteral(string)
    }
}
// "Your time is \(date: Date(), format: .shortTimeNoDate)" <-- automatically compatible to new formats

OR

extension String.StringInterpolation {
    mutating func appendInterpolation(shortTimeNoDate date: Date) {
       let string = SHDateFormatter.shared.string(from: date, format: .shortTimeNoDate)
       appendLiteral(string)
    }
}
// "Your time is \(shortTimeNoDate: Date())" <-- a bit shorter but needs a new extension for each new format

[...]

Actual behaviour

Right now, to formt a string, a user has to use:

let time = SHDateFormatter.shared.string(from: Date(), format: .shortTimeNoDate)
let string = "Now is \(time)"

Current Behaviour

If the phone is using 12h time format with English UK, the date will be formatted with 24h format.
If the phone is using 24h time format with English US, the date will be formatted with 12h format.

Steps to reproduce

1. Put your phone in English US with 24h format
2. Try to book a ride

Expected behaviour

The date formatting should not be based on the lang but on the time format settings.

The following code behaves correctly:

import UIKit
import SHDateFormatter

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let sIsoDate = "2019-07-31T12:09:23Z"

        let calendar = Calendar(identifier: .gregorian)
        let formatter = DateFormatter()
        formatter.calendar = calendar
        formatter.formatterBehavior = .default
        formatter.doesRelativeDateFormatting = false
        formatter.timeStyle = .none
        formatter.dateStyle = .none
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = TimeZone(secondsFromGMT: 0)

        formatter.dateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"

        let dateNoMs = formatter.date(from: sIsoDate)

        formatter.timeStyle = .short
        formatter.locale = Locale.current
        print(formatter.string(from: dateNoMs!))

        print("Is 24h: \(DateFormatter.is24h)")

        let isoDate = SHDateFormatter.shared.date(from: sIsoDate, format: .ISO8601)!
        let converted = SHDateFormatter.shared.string(from: isoDate, format: .shortTimeNoDate, locale: Locale.current)
        print(converted)

    }
}

extension DateFormatter {
    static var is24h: Bool {
        return DateFormatter.dateFormat(fromTemplate: "j", options: 0, locale: .current)?.contains("a") == false
    }
}

It seems that the locale isn't reset properly to Locale.current. Right now it is reset to Locale(identifier: Locale.preferredLanguages[0]) which might be wrong.