first commit

Author: rafcabezas

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

.swiftpm/xcode/package.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 5.10
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Bark",
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "Bark",
+            targets: ["Bark"]),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "Bark"),
+        .testTarget(
+            name: "BarkTests",
+            dependencies: ["Bark"]),
+    ]
+)

README.md

@@ -0,0 +1,62 @@
+# Bark
+Simple message broadcasting library (similar to NotificationCenter in spirit). It's designed to help you manage a group of dependencies in a container, and easily resolve them when needed, thus helping make your project more modular, testable, and maintainable.
+
+Tree bark won't bark. But `bark` will, and it will allow you to broadcast information across your app in a structured concurrent way.
+
+## Why Bark
+With `bark`, you can register subscriptions that require a concurrency context, and be assured at the point of use that the subscription was
+run when the `await` to the associated post completes. 
+
+This allows you to reason about the order in which tasks associated with subscriptions execute. Making it easier to write testable and understandable code.
+
+## Features
+- **Lightweight and Focused** - Specifically responsible for dealing with message broadcasting.
+- **Swift-native Design** - Bark feels natural and intuitive for Swift developers.
+- **Thread-safe**
+- **Simple** - Very simple syntax
+
+## Installation
+Bark is available through the Swift Package Manager. To install it, simply add the following line to your `Package.swift` file:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/willowtreeapps/bark.git", from: "1.0.0")
+]
+```
+
+## Usage
+Bark allows for structured concurrent message broadcasting. Here's an example from its tests:
+
+### Registration
+
+```swift
+func testPostsOfASingleSubscription() async throws {
+    // Given
+    let subscriptions = Bark.Store()
+    var testNotification1PostCount = 0
+
+    func increaseTheCounter() async {
+        testNotification1PostCount += 1
+    }
+
+    bark.subscribe(.testNotification1, in: subscriptions) { _ in
+        await increaseTheCounter()
+    }
+
+    // When
+    await bark.post(.testNotification1)
+    await bark.post(.testNotification1)
+
+    // Then
+    XCTAssertEqual(testNotification1PostCount, 2)
+}
+```
+
+## Contributing
+Contributions are immensely appreciated. Feel free to submit pull requests or to create issues to discuss any potential bugs or improvements.
+
+## Author
+Grove was created by @rafcabezas at [WillowTree, Inc](https://willowtreeapps.com).
+
+## License
+Grove is available under the [MIT license](https://opensource.org/licenses/MIT).

Sources/Bark/Bark.swift

@@ -0,0 +1,111 @@
+//
+//  Bark.swift
+//
+//
+//  Created by Raf Cabezas on 6/6/24.
+//
+
+import Foundation
+
+public final class Bark: @unchecked Sendable {
+
+    // MARK: - Types
+
+    public typealias Block = (Any?) async -> Void
+
+    public struct Name: Hashable, Equatable {
+        private let value: String
+        public init(_ value: String) {
+            self.value = value
+        }
+
+        public var description: String { value }
+    }
+
+    public final class Store: @unchecked Sendable {
+        struct Handler {
+            let name: Name
+            let block: Block
+        }
+
+        fileprivate let id = UUID()
+        fileprivate var handlers: [Handler] = []
+        private let lock = NSLock()
+
+        public init() {}
+
+        func add(_ block: @escaping Block, for name: Name) {
+            lock.lock()
+            handlers.append(Handler(name: name, block: block))
+            lock.unlock()
+        }
+
+        func blocks(for name: Name) -> [Block] {
+            lock.lock()
+            let blocks = handlers.compactMap { $0.name == name ? $0.block : nil }
+            lock.unlock()
+            return blocks
+        }
+
+        func clear() {
+            lock.lock()
+            handlers.removeAll()
+            lock.unlock()
+        }
+    }
+
+    // MARK: - Properties
+
+    private let lock = NSLock()
+    private struct StoreWrapper {
+        weak var store: Store?
+    }
+    private var stores = [StoreWrapper]()
+
+    // MARK: - Lifecycle
+
+    public init() {
+        /* No-Op */
+    }
+
+    // MARK: - Actions
+
+    public func subscribe(_ name: Name, in store: Store?, block: @escaping Block) {
+        guard let store else { return }
+        lock.lock()
+        store.add(block, for: name)
+        if !stores.contains(where: { $0.store?.id == store.id }) {
+            stores.append(StoreWrapper(store: store))
+        }
+        lock.unlock()
+    }
+
+    public func unsubscribe(_ store: Store?) {
+        guard let store else { return }
+        lock.lock()
+        store.clear()
+        stores.removeAll { $0.store?.id == store.id }
+        lock.unlock()
+    }
+
+    public func post(_ name: Name, data: Any? = nil) async {
+        for block in blocks(for: name) {
+            await block(data)
+        }
+    }
+
+    // MARK: - Helpers
+
+    public func registrationsCount(for name: Name) -> Int {
+        blocks(for: name).count
+    }
+
+    private func blocks(for name: Name) -> [Block] {
+        lock.lock()
+        let blocks = stores
+            .compactMap { $0.store?.blocks(for: name) }
+            .flatMap { $0 }
+        lock.unlock()
+        return blocks
+    }
+}