swift-dependencies_skill

Overview

This skill documents swift-dependencies, a lightweight dependency management library for Swift that makes dependencies explicit, testable, and swappable. It presents progressive guides from quick start to advanced topics, plus a converter for DocC-formatted documentation. The material helps teams design, register, override, and test dependencies in Swift applications.

How this skill works

The documentation explains how to register dependencies into a central container and access them where needed, similar in spirit to SwiftUI’s environment. It shows how to provide multiple implementations (live, preview, test), control dependency lifetimes, and override implementations at runtime or during tests. The content is organized so readers can start with basics and progressively adopt advanced patterns like single-entry-point systems.

When to use it

• When you want to make side-effecting services explicit and injectable instead of using globals.
• When you need to swap implementations for previews, tests, or platform-specific behavior.
• When writing unit or integration tests that require deterministic, stubbed, or mocked dependencies.
• When structuring an app with a single-entry-point or modular architecture.
• When you need to manage lifetime and scope of shared services across an app.

Best practices

• Start with the Quick Start and What Are Dependencies articles to align team understanding.
• Design dependencies as small, focused protocols or structs to encourage easy swapping and testing.
• Register live, preview, and test implementations consistently so switching contexts is predictable.
• Prefer overriding dependencies at well-defined boundaries (e.g., app entry point or test setup) instead of ad-hoc global mutation.
• Document lifetime expectations for each dependency to avoid unexpected retention or recreation.

Example use cases

• Injecting a network client and providing a fast in-memory stub for unit tests.
• Swapping persistence implementations between Core Data, SQLite, or an in-memory store for previews.
• Providing a deterministic clock or scheduler in tests to simplify timing-related assertions.
• Overriding analytics or feature-flag services during UI previews to avoid external calls.
• Using a single-entry-point pattern to compose app modules with explicit dependency wiring.