swift-dependencies

Introduction to Swift-Dependencies

Introduction

Swift-Dependencies is a robust dependency management library inspired by the environment system of SwiftUI. It was designed by the developers at Point-Free, who explored its concepts in a series focusing on functional programming and the Swift language. This library aims to simplify managing dependencies in your Swift application, offering solutions to common problems faced during app development.

Overview

In application development, dependencies refer to components and functions requiring interaction with elements outside your control. Typical examples include network requests, date and time functions, unique identifiers (UUID), and local data storage. While you might not need a robust dependency management system at the start of a project, as an app grows, unmanaged dependencies can cause significant issues:

• Testing challenges: Dependencies like network and file system resources make it hard to write fast, reliable tests.
• Preview issues: SwiftUI previews can be problematic with particular dependencies like location managers, creating friction in design iteration.
• Compile-time performance: Dependencies from third-party libraries can slow down your build times.

Managing these dependencies is crucial to developing scalable and maintainable Swift applications. With Swift-Dependencies, developers can control their application's dependencies, leading to improved testing capabilities, faster development cycles, and enhanced preview experiences.

Quick Start

Swift-Dependencies provides a straightforward way to control dependencies within your application. The library comes with many built-in controllable dependencies, but it also allows you to register your own. For instance, to manage common dependencies such as Date, UUID, or Task scheduling, you can use control mechanisms provided by the library:

@Observable
final class FeatureModel {
  var items: [Item] = []

  @ObservationIgnored
  @Dependency(\.continuousClock) var clock  
  @ObservationIgnored
  @Dependency(\.date.now) var now           
  @ObservationIgnored
  @Dependency(\.mainQueue) var mainQueue   
  @ObservationIgnored
  @Dependency(\.uuid) var uuid             

  // ...
}

With the setup, you can inject controlled dependencies into your application logic. This helps make tests predictable and previews responsive.

Testing and Previews

Controlling dependencies significantly enhances the reliability of tests. Using the withDependencies function, you can override dependencies in a test environment, creating determinate conditions for testing application logic:

@Test
func add() async throws {
  let model = withDependencies {
    $0.clock = .immediate
    $0.date.now = Date(timeIntervalSinceReferenceDate: 1234567890)
    $0.uuid = .incrementing
  } operation: {
    FeatureModel()
  }
  
  try await model.addButtonTapped()
  #expect(model.items == [
    Item(
      id: UUID(uuidString: "00000000-0000-0000-0000-000000000000")!,
      name: "",
      createdAt: Date(timeIntervalSinceReferenceDate: 1234567890)
    )
  ])
}

For SwiftUI previews, you can use the .dependencies preview trait to inject custom dependencies, enabling faster and more dynamic UI updates:

#Preview( 
  traits: .dependencies {
    $0.continuousClock = .immediate
  }
) {
  FeatureView(model: FeatureModel())
}

Installation

To integrate Swift-Dependencies into an Xcode project, add the package via the following URL:

https://github.com/pointfreeco/swift-dependencies

For SwiftPM (Swift Package Manager) projects, include it in your Package.swift file:

dependencies: [
  .package(url: "https://github.com/pointfreeco/swift-dependencies", from: "1.0.0")
]

Community and Extensions

Engage with a community of developers using and improving Swift-Dependencies through discussions on GitHub or join the Point-Free Community Slack.

Various extensions build upon Swift-Dependencies, offering additional functionality. These include:

• Dependencies Additions
• Dependencies Protocol Extras

Conclusion

Swift-Dependencies offers an elegant solution to managing application dependencies in Swift. It addresses common issues like testing, previews, and compile-time efficiency. Whether you're starting a new project or refactoring an existing one, integrating Swift-Dependencies helps maintain clean, efficient, and testable code. For further information and detailed guides, refer to the official documentation and explore real-world examples such as the modernized Scrumdinger app.