Use Your Loaf - iOS Development News & Tips

Format Swift with a Git Commit Hook

Mon, 24 Nov 2025 10:29:58 +0000

How do you automatically format your Swift code every time you commit it to your Git repository?

Swift Format

There are several Swift formatting tools. Xcode 16 shipped with swift-format included in the toolchain:

$ xcrun --find swift-format
/Applications/Xcode.app/Contents/Developer/Toolchains/
XcodeDefault.xctoolchain/usr/bin/swift-format

To run the formatter:

$ swift format MyFile.swift

Note: This runs the swift-format bundled with the active Xcode development directory (beta or release).

Configuring swift-format

The Xcode settings let you configure various formatting options including indentation but I prefer to use an external configuration file for swift-format.

By default, swift-format looks for a configuration file named .swift-format in the same directory as the files you are formatting. If there isn’t one it looks in each successive parent directory. If it doesn’t find a configuration file it uses a default configuration. You can dump the default configuration to get started:

$ swift format dump-configuration > swift-format

Modify the configuration file to meet your own code style:

{
  "fileScopedDeclarationPrivacy" : {
    "accessLevel" : "private"
  },
  "indentConditionalCompilationBlocks" : true,
  "indentSwitchCaseLabels" : false,
  "indentation" : {
  ...

I keep my default configuration file in my base Developer directory:

$ mv swift-format ~\Developer\.swift-format

When needed, I can override the defaults by placing a modified configuration file in the project-specific root directory.

Note: Don’t forget to prefix the configuration file with a .

Git Commit Hooks

Git Hooks are a way to run custom scripts when different Git actions occur. A pre-commit hook runs when you commit changes to a repository. Here’s the pre-commit script I’m using to run swift-format:

#!/bin/bash

GIT=/usr/bin/git
GREP=/usr/bin/grep
SWIFT=/usr/bin/swift

# Staged (cached) added/copied/modified/renamed files
FILES=$($GIT diff --cached --name-only --diff-filter=ACMR | $GREP '\.swift$')

# Exit early if no staged files
if [ -z "$FILES" ]; then
  exit 0
fi

$SWIFT format --in-place --parallel $FILES
$GIT add $FILES

Notes:

The git diff command returns the names of any staged (cached) swift files (A)dded, (C)hanged, (M)oved, or (R)enamed compared to HEAD.
I run the swift format command on the staged files in one go, modifying the files in-place.
Since formatting the files can change them I need to add the modified files back to the staging area.
Exiting the script with a non-zero value cancels the commit.

Installing the Git pre-commit script

Git stores hook scripts in the hooks subdirectory of the Git directory in the project root. To install my pre-commit script I need to copy it to the hooks folder and make it executable:

$ cp pre-commit ~/Developer/Repositories/MyProject/.git/hooks
$ chmod +x ~/Developer/Repositories/MyProject/.git/hooks/pre-commit

Note:

This is a client-side hook so I have to install it each time I create or clone a new repository.

Bypass the pre-commit script with the --no-verify flag:

$ git commit --no-verify

Learn More

Format Swift with a Git Commit Hook was originally posted 24 Nov 2025 on useyourloaf.com.

Want this direct to your inbox? Sign up and get my free WWDC viewing guide PDF.

SwiftUI Custom URL Schemes

Mon, 27 Oct 2025 11:26:47 +0000

Create a custom URL scheme handler for SwiftUI WebViews.

Custom URL schemes

Apple introduced both WebView and WebPage SwiftUI views in iOS 26. These provide similar WebKit functionality to the UIKit WKWebView APIs. This includes being able to register custom URL schemes to load local resources.

Suppose I have an App that loads quotations from the local App bundle. My URL scheme uses the format:

quotes://001.html

There are a few steps to support a custom URL scheme:

Create a custom URL scheme handler that knows how to load the local resources.
Register the scheme handler in a WebPage configuration.
Have the WebView load and display the web page.

Let’s look at each of those steps.

URLSchemeHandler (iOS 26)

The URLSchemeHandler is a protocol with a reply method to return an async sequence of results. The AsyncSequence expects us to either yield a URLResponse and some data or throw an error.

struct QuoteSchemeHandler: URLSchemeHandler {
  static let scheme = "quotes"

  func reply(for request: URLRequest) -> some AsyncSequence<
        URLSchemeTaskResult, any Error
    > {
        AsyncThrowingStream { continuation in
           ...
        }
    }
}

The reply method provides us with the URLRequest. I start by extracting the URL and checking it matches our quotes scheme:

guard let url = request.url else {
  continuation.finish(throwing: QuoteError.missingURL)
  return
}

guard url.scheme == QuoteSchemeHandler.scheme else {
  continuation.finish(throwing: QuoteError.invalidScheme)
  return
}

To construct the URL response I need the mime type and length of the data. I first extract the filename from the URL, determine the mime type from the file extension, and then load the data:

do {
  let file = try filename(for: url)
  let mimeType = try mimeType(for: file)
  let data = try Data(contentsOf: file)

I can then build the URLResponse:

  let response = URLResponse(
      url: url,
      mimeType: mimeType,
      expectedContentLength: data.count,
      textEncodingName: "utf-8"
  )

If nothing has gone wrong I then add the response and the data to the AsyncSequence and finish the stream:

  continuation.yield(.response(response))
  continuation.yield(.data(data))
  continuation.finish()

If any of those steps went wrong I finish the stream with the error:

} catch {
  continuation.finish(throwing: error)
}

I extract the filename from the hostname section of the URL and then locate the URL of the html file in the main App bundle:

private func filename(for url: URL) throws -> URL {
  guard let resource = url.host(percentEncoded: false) else {
    throw QuoteError.missingHost
  }
        
  guard let file = Bundle.main.url(
    forResource: resource,
    withExtension: nil
  ) else {
    throw QuoteError.fileNotFound
  }
  
  return file
}

I lookup the mime type using the file extension:

private func mimeType(for file: URL) throws -> String {
  guard let mimeType = UTType(filenameExtension: file.pathExtension)?
    .preferredMIMEType
  else {
    throw QuoteError.unknownFileType
  }
  return mimeType
}

This returns “text\html” for .html files. The complete reply method:

func reply(for request: URLRequest) 
  -> some AsyncSequence<URLSchemeTaskResult, any Error> {
    AsyncThrowingStream { continuation in
    guard let url = request.url else {
      continuation.finish(throwing: QuoteError.missingURL)
      return
    }

    guard url.scheme == QuoteSchemeHandler.scheme else {
      continuation.finish(throwing: QuoteError.invalidScheme)
      return
    }

    do {
      let file = try filename(for: url)
      let mimeType = try mimeType(for: file)
      let data = try Data(contentsOf: file)
      let response = URLResponse(
        url: url,
        mimeType: mimeType,
        expectedContentLength: data.count,
        textEncodingName: "utf-8"
      )

      continuation.yield(.response(response))
      continuation.yield(.data(data))
      continuation.finish()
    } catch {
      continuation.finish(throwing: error)
    }
  }
}

Registering the Scheme Handler

To register the scheme handler we create a page configuration and add our scheme handler. I’m doing that in an Observable object responsible for loading the quotes:

@Observable final class QuoteStore {
  var page: WebPage

  init() {
    guard let scheme = URLScheme(QuoteSchemeHandler.scheme) else {
        fatalError("Invalid URLScheme")
    }
    
    let handler = QuoteSchemeHandler()
    var configuration = WebPage.Configuration()
    configuration.urlSchemeHandlers[scheme] = handler
    
    self.page = WebPage(configuration: configuration)
  }
}

Then to load a URL:

  func loadQuote(_ url: URL) async {
    do {
      let events = page.load(url)
      for try await event in events { ...
      }
    } catch {
      self.error = error
    }
  }

The WebPage load method returns an async sequence you can use to track progress if needed.

Loading the Page

Finally, to load and display the page:

extension QuoteStore {
  static let quote1 = URL(string: "quotes://001.html")!
  ...
}

struct ContentView: View {
  @State private var store = QuoteStore()

  var body: some View {
    WebView(store.page)
    .task {
      await store.loadQuote(QuoteStore.quote1)
    }
  }
}

Learn More

WWDC25 Meet WebKit for SwiftUI

SwiftUI Custom URL Schemes was originally posted 27 Oct 2025 on useyourloaf.com.

Want this direct to your inbox? Sign up and get my free WWDC viewing guide PDF.

iPhone 17 Screen Sizes

Mon, 13 Oct 2025 10:44:39 +0100

There’s less variation this year with the base iPhone 17 and Pro models sharing a display. The Plus model is gone but we get a new iPhone Air. Here’s what you need to know about the iPhone 17 models.

The New Models in a Nutshell

There’s no iPhone 17 Plus model this year. Instead the iPhone 17 gets the same 6.3" display as the iPhone 17 Pro. The Pro Max keeps the 6.9" display from last year. Finally, we have the new iPhone Air with a 6.5" display. Apple continues to sell the base iPhone 16, 16 Plus, and the iPhone 16e.

That gives this years models three different screen sizes:

The 6.3" display in the iPhone 17 and 17 Pro has almost the same specs as the iPhone 16 Pro. That brings features such as ProMotion and the Always-on display to the base iPhone 17. The only difference I can see is an increased peak brightness of 3,000 nits (up from 2,000 nits). The Titanium frame of last years Pro models is replaced with an Aluminium unibody. The base iPhone 17 has an Aluminium frame but the iPhone Air has a Titanium frame.

Support for USB-3 (10Gbp/s) transfer speeds is still limited to the Pro models.

iPhone 17

The base iPhone 17 display upgrades to a spec comparable to the iPhone 16 Pro 6.3" display with ProMotion and Always-on, along with the A19 chip.

A19 chip (6-core CPU, 5-core GPU with Neural Accelerators, 16-core Neural Engine)
Display: 6.3" Super Retina XDR OLED with ProMotion, Always-On display, and Dynamic Island
Screen resolution (points): 402 x 874
Native resolution (pixels): 1206 x 2622 (460 ppi)
Native Scale factor: 3x
Portrait size classes: w: Compact, h: Regular
Landscape size classes: w: Compact, h: Compact

The status bar is 54 points high with a top safe area inset of 62 points which gives the following safe area insets:

Safe Area Insets (portrait): top: 62, bottom: 34, left: 0, right: 0
Safe Area Insets (landscape): top: 20, bottom: 20, left: 62, right: 62

Note: In landscape there’s now a top safe area inset of 20 points.

iPhone 17 Pro

The iPhone 17 Pro is fractionally larger than the iPhone 16 Pro but keeps a 6.3" display. It has the Pro version of the A19 chip:

A19 Pro chip (6-core CPU, 6-core GPU with Neural Accelerators, 16-core Neural Engine).
Display: 6.3" Super Retina XDR OLED with ProMotion, Always-On display, and Dynamic Island.
Screen resolution (points): 402 x 874
Native resolution (pixels): 1206 x 2622 (460 ppi)
Native Scale factor: 3x
Portrait size classes: w: Compact, h: Regular
Landscape size classes: w: Compact, h: Compact

The status bar is 54 points high with a top safe area inset of 62 points which gives the following safe area insets:

Safe Area Insets (portrait): top: 62, bottom: 34, left: 0, right: 0
Safe Area Insets (landscape): top: 20, bottom: 20, left: 62, right: 62

Note: In landscape there’s now a top safe area inset of 20 points.

iPhone 17 Pro Max

The iPhone 17 Pro Max is fractionally larger than the iPhone 16 Pro Max. It keeps a 6.9" display, and it has the Pro version of the A19 chip:

A19 Pro chip (6-core CPU, 6-core GPU with Neural Accelerators, 16-core Neural Engine).
Display: 6.9" Super Retina XDR OLED with ProMotion, Always-On display, and Dynamic Island.
Screen resolution (points): 440 x 956
Native resolution (pixels): 1320 x 2868 (460 ppi)
Scale factor: 3x
Portrait size classes: w: Compact, h: Regular
Landscape size classes: w: Regular, h: Compact

The status bar is 54 points high with a top safe area inset of 62 points which gives the following safe area insets:

Safe Area Insets (portrait): top: 62, bottom: 34, left: 0, right: 0
Safe Area Insets (landscape): top: 20, bottom: 20, left: 62, right: 62

Note: In landscape there’s now a top safe area inset of 20 points.

iPhone Air

The iPhone Air makes some compromises to be thin and light. It has a depth of just 5.64mm and weighs 165 grams but has a single 48MP rear camera. It does get the A19 Pro chip:

A19 Pro chip (6-core CPU, 5-core GPU with Neural Accelerators, 16-core Neural Engine)
Display: 6.5" Super Retina XDR OLED with ProMotion, Always-On display, and Dynamic Island.
Screen resolution (points): 420 x 912
Native resolution (pixels): 1260 x 2736 (460 ppi)
Scale factor: 3x
Portrait size classes: w: Compact, h: Regular
Landscape size classes: w: Regular, h: Compact

The status bar is 54 points high with a top safe area inset of 68 points which gives the following safe area insets:

Safe Area Insets (portrait): top: 68, bottom: 34, left: 0, right: 0
Safe Area Insets (landscape): top: 20, bottom: 29, left: 68, right: 68

The Complete List of iPhones (and an iPod)

Apple didn’t add any new screen sizes this year, but the iPhone Air 6.5" display does have a slightly higher resolution than the previous 6.5" models. Here’s the complete list of iPhone screen sizes supporting a minimum deployment target of iOS 15 (new models in bold):

6.9" (440 x 956 points at @3x)
iPhone 17 Pro Max, iPhone 16 Pro Max
6.7" (430 x 932 points @3x)
iPhone 16 Plus, iPhone 15 Pro Max, iPhone 15 Plus, iPhone 14 Pro Max
6.7" (428 x 926 points @3x)
iPhone 14 Plus, iPhone 13 Pro Max, iPhone 12 Pro Max
6.5" (420 x 912 points @3x)
iPhone Air
6.5" (414 x 896 points @3x)
iPhone 11 Pro Max, iPhone XS Max
6.3" (402 x 874 points at @3x)
iPhone 17, iPhone 17 Pro, iPhone 16 Pro
6.1" (393 x 852 points @3x)
iPhone 16, iPhone 15 Pro, iPhone 15, iPhone 14 Pro
6.1" (390 x 844 points @3x)
iPhone 16e, iPhone 14, iPhone 13 Pro, iPhone 13, iPhone 12 Pro, iPhone 12
6.1" (414 x 896 points @2x)
iPhone 11, iPhone XR
5.8" (375 x 812 points @3x)
iPhone 11 Pro, iPhone XS, iPhone X
5.5" (414 x 736 points @3x)
iPhone 8 Plus, iPhone 7 Plus, iPhone 6S Plus
5.4" (375 x 812 points @3x)
iPhone 13 mini, iPhone 12 mini
4.7" (375 x 667 points @2x)
iPhone SE (3rd & 2nd Gen), iPhone 8, iPhone 7, iPhone 6S
4" (320 x 568 @2x)
iPhone SE (1st Gen), iPod Touch (7th Gen)

App Store Screenshots

Nothing has changed this year. App Store Connect requires one set of screenshots for iPhone (and one for iPad). That screenshot can be for either the 6.9" or 6.5" iPhone display.

You can upload either of the following sizes for the 6.9" display (portrait sizes, reverse for landscape):

6.9" 1320 x 2868 pixels (iPhone 17 Pro Max)
6.7" 1290 x 2796 pixels (iPhone 16 Plus)

If you don’t upload screenshots for the 6.9" display you can provide either of the following for the 6.5" display:

6.7" 1284 x 2778 pixels (iPhone 14 Plus)
6.5" 1242 x 2688 pixels (iPhone 11 Pro Max)

All other iPhone display sizes can use scaled versions of the above.

Want To Learn More?

If you’re struggling to build layouts with UIKit that work across the growing range of iOS devices you might like my book - Modern Auto Layout.

iPhone 17 Screen Sizes was originally posted 13 Oct 2025 on useyourloaf.com.

Want this direct to your inbox? Sign up and get my free WWDC viewing guide PDF.

Swift Default Value in String Interpolations

Sun, 07 Sep 2025 09:51:46 +0100

Swift 6.2 makes it easier to interpolate strings with optional values.

What’s The Problem?

In this SwiftUI view I need to create a text string from an optional integer value:

struct CounterView: View {
  let count: Int?
    
  var body: some View {
    Text("The count is \(count)")
  }
}

The compiler warns about the optional value:

String interpolation produces a debug description for an optional value; did you mean to make this explicit?

The compiler suggests either providing a default value or to use String(describing:) to silence the warning.

Using the nil-coalescing operator to provide a default value removes the warning but is not ideal. The default value has to match the type of the optional value. That can work when dealing with an optional string. In this example I have an optional Int and there may not be a sensible default value for the nil case. For example, I could use zero:

// The count is 0
Text("The count is \(count ?? 0)")

The alternative of using the String(describing:) approach is both clumsy and ends up showing the nil value:

// The count is nil
Text("The count is \(String(describing: count))")

What I want is a way to provide a default string regardless of the type of the optional value.

Default Value Parameter

In Swift 6.2, String interpolation has a new default value parameter that accepts a string regardless of the type of the optional value:

// The count is not set
Text("The count is \(count, default: "not set")")

That’s an improvement over outputting nil.

Localization

One issue is that I’ve been unable to get this to work with localization. The problem seems to be that LocalizedStringKey doesn’t support the default value parameter. So this doesn’t work:

// Not Supported
let key = LocalizedStringKey("The count is: \(count, default: "not set")")

Learn More

SE-0477 Default Value in String Interpolations

Swift Default Value in String Interpolations was originally posted 07 Sep 2025 on useyourloaf.com.

Want this direct to your inbox? Sign up and get my free WWDC viewing guide PDF.

Treating Warnings As Errors In Swift Packages

Mon, 01 Sep 2025 12:02:15 +0100

In Swift 6.2, Swift Packages give us control over which compiler warnings to treat as errors.

Finer-grained Controls for Compiler Warnings

The Swift compiler has options to treat all warnings as errors or suppress all warnings:

-warnings-as-errors
-suppress-warnings

In Xcode, you add those compiler flags to the build settings for a target. In the “Swift Compiler - Custom Flags” section add the options to the “Other Swift Flags” setting:

What if you only want to treat some warnings as errors?

In Swift 6.1, compiler options allow you to treat a specific diagnostic groups as warnings or errors:

-Wwarning <group>
-Werror <group>

For example, to treat the DeprecatedDeclaration diagnostic group as an error:

-Werror DeprecatedDeclaration

The order you add the controls is important. For example, if we default to treating all warnings as errors, but want to keep the DeprecatedDeclaration group as a warning:

-warnings-as-errors
-Wwarning DeprecatedDeclaration

Note that when adding this to the build settings in Xcode you add the diagnostic group on a new line:

Xcode adds a link to the documentation when showing the warning/error in the source code editor:

Clicking on the question mark opens a link to the Swift documentation for the relevant diagnostic group.

That’s great. The problem was that Swift 6.1 did not support these controls in Swift Packages. Apple fixed that problem in Swift 6.2 which shipped with Xcode 26.

Warning Controls for Swift Packages

First you need to update your Swift tools version to 6.2 in your Package.swift file:

// swift-tools-version: 6.2

You then have access to some new swiftSettings:

treatAllWarnings(as: .error)
treatAllWarnings(as: .warning)
treatWarning("group", as: .error)
treatWarning("group", as: .warning)

Modifying a target to treat all warnings as errors, except the DeprecatedDeclaration group:

.target(
  name: "MyFeature",
  swiftSettings: [
    .treatAllWarnings(as: .error),
    .treatWarning("DeprecatedDeclaration", as: .warning)
  ]
),

The warning control settings only apply when the package is built directly. They are ignored if the package is used as a remote dependency.

To apply the controls to all targets in a Swift Package. Add the following to the end of the Package.swift file:

for target in package.targets {
  var settings = target.swiftSettings ?? []
  settings.append(contentsOf: [
    .treatAllWarnings(as: .error),
    .treatWarning("DeprecatedDeclaration", as: .warning)
  ])
  target.swiftSettings = settings
}

Learn More

Treating Warnings As Errors In Swift Packages was originally posted 01 Sep 2025 on useyourloaf.com.

Want this direct to your inbox? Sign up and get my free WWDC viewing guide PDF.

Use Your Loaf - iOS Development News & Tips

Format Swift with a Git Commit Hook

Swift Format

Configuring swift-format

Git Commit Hooks

Installing the Git pre-commit script

Learn More

SwiftUI Custom URL Schemes

Custom URL schemes

URLSchemeHandler (iOS 26)

Registering the Scheme Handler

Loading the Page

Learn More

iPhone 17 Screen Sizes

The New Models in a Nutshell

iPhone 17

iPhone 17 Pro

iPhone 17 Pro Max

iPhone Air

The Complete List of iPhones (and an iPod)

App Store Screenshots

See Also

Want To Learn More?

Swift Default Value in String Interpolations

What’s The Problem?

Default Value Parameter

Localization

Learn More

Treating Warnings As Errors In Swift Packages

Finer-grained Controls for Compiler Warnings

Warning Controls for Swift Packages

Learn More