RouteComposer

Some rules require specific Swift versions. If not specified, they may be disabled.

Swift Compiler Version:

1. Use the --swift-version command-line argument.
2. Add --swift-version to your .swiftformat file.
3. Add a .swift-version file to your project directory (this takes precedence over the --swift-version argument).

Swift Language Mode: This is distinct from the compiler version (e.g., using Swift 6.0 compiler with Swift 5 language mode). Use --language-mode in CLI or .swiftformat files. If not specified, it defaults to the default mode of the specified compiler version (usually Swift 5.x).

--swift-version 5.9
--language-mode 6

RouteComposer is built around three main entities that the host application must define to support navigation:

1. Factory: Responsible for building view controllers.
2. Finder: Responsible for finding the appropriate destination or state.
3. Action: Responsible for executing the navigation transition.

Each of these entities uses two associatedtype parameters:

• ViewController: The type of view controller being managed (e.g., UINavigationController, CustomViewController).
• Context: A payload object passed from the router to the view controllers. It is not a View Model or Presenter; it is the minimal information required to identify or configure the view (e.g., a UUID for a productID). It answers: "What do I need to present this view?" and "Am I already presenting this view for this specific context?"

Options control the behavior of rules. You can configure them via command-line arguments, a .swiftformat configuration file, or inline comments.

Command Line: Use --[option_name] [value]. To see all available options, use --options.

Configuration File: Create a .swiftformat file in your project directory. Each line should contain one option.

Inline Comments: Use // swiftformat:options to set options for a specific file or range. You can use modifiers to target specific lines:

• :this: The current line.
• :next: The next line.
• :previous: The previous line.

// Apply to the whole file
// swiftformat:options --indent 2 --allman true

// Apply only to this line
let indexUrl: URL // swiftformat:options:this --preserve-acronyms url

// Apply to the next line
// swiftformat:options:next --semicolons inline
doTheThing(); print("Did the thing")

RouteComposer manages navigation within ContainerViewControllers (such as UINavigationController, UITabBarController, and UISplitViewController). Because each container has unique methods for interacting with its children, RouteComposer uses ContainerAdapters to abstract these interactions.

• Built-in Adapters: RouteComposer includes built-in adapters for standard UIKit container view controllers.
• Custom Adapters: If you use custom container view controllers or those from third-party libraries, you must implement your own ContainerAdapter to allow RouteComposer to switch tabs or manage visibility correctly.

Refer to the ContainerAdapter protocol documentation for implementation details.

// Refer to the ContainerAdapter protocol for implementation details
// https://ekazaev.github.io/route-composer/Protocols/ContainerAdapter.html

The Router processes a chain of steps sequentially. For each step, it uses a Finder to check if the target UIViewController exists.

1. Search Phase: The Router iterates through the chain until a Finder successfully locates the described UIViewController.
2. Construction Phase: Once found, the Router moves backwards through the chain, using each step's Factory to create the required UIViewController and applying its associated Action to integrate it into the navigation stack.

Mental Model: Think of configuration as defining a path for a user who could be anywhere in the app (e.g., arriving via a Universal Link) to reach a specific destination.

To ensure that upgrading SwiftFormat doesn't introduce new formatting rules that surprise you, use the --rules argument. By providing an exclusive list of rules in your SwiftFormat configuration, only those specified rules will be executed, and any new rules added in newer versions of SwiftFormat will be ignored.

# Example usage of specifying an exclusive list of rules
swiftformat --rules rule1,rule2,rule3 /path/to/code

In addition to the core entities, RouteComposer provides three helping entities that you can implement to handle specific logic during the routing lifecycle:

• RoutingInterceptor: Used to intercept and potentially modify the routing process.
• ContextTask: Used to handle tasks related to the Context during routing.
• PostRoutingTask: Used to execute actions after a routing operation has completed.