Merge pull request #4 from Lickability/new-example-app

Adds New Example Project

Author: mliberatore

Example/API/APIRequest.swift

@@ -0,0 +1,42 @@
+//
+//  APIRequest.swift
+//  ViewStore
+//
+//  Created by Twig on 2/24/22.
+//
+
+import Foundation
+import Provider
+
+/// Represents the requests we can make for content displayed in the app.
+enum APIRequest: ProviderRequest {
+
+    /// Fetches albums of placeholder photo models.
+    case photos
+    
+    // MARK: - ProviderRequest
+
+    var persistenceKey: Key? {
+        switch self {
+        case .photos: return "Photos"
+        }
+    }
+
+    // MARK: - NetworkRequest
+    
+    var path: String {
+        switch self {
+        case .photos:
+            return "/photos"
+        }
+    }
+    
+    var queryParameters: [URLQueryItem] {
+        return [URLQueryItem(name: "_limit", value: "5")]
+    }
+
+    var baseURL: URL {
+        return URL(string: "https://jsonplaceholder.typicode.com")!
+    }
+}
+

Example/Array+Filtering.swift

@@ -0,0 +1,20 @@
+//
+//  Array+Filtering.swift
+//  ViewStore
+//
+//  Created by Michael Liberatore on 7/13/22.
+//
+
+import Foundation
+
+extension Array where Element == Photo {
+
+    /// Filters an array of photos by `searchText` returning only the photos that contain `searchText` in the photo `title` (case insensitive).
+    /// - Parameter searchText: The text to query titles for.
+    func filter(searchText: String) -> [Photo] {
+        guard !searchText.isEmpty else { return self }
+        return filter { photo in
+            photo.title.localizedCaseInsensitiveContains(searchText)
+        }
+    }
+}

Example/Example.swift

@@ -0,0 +1,45 @@
+//
+//  Example.swift
+//  ViewStore
+//
+//  Created by Twig on 2/24/22.
+//
+
+import SwiftUI
+import Provider
+import Networking
+import Persister
+
+/// The entry point into the example app.
+@main
+struct Example: App {
+    
+    @State private var photoProvider: ItemProvider = {
+        let controller = NetworkController()
+        let diskCache = DiskCache(rootDirectoryURL: FileManager.default.applicationSupportDirectoryURL.appendingPathComponent("Photos"))
+        let cache = MemoryCache(capacity: .unlimited, expirationPolicy: .never)
+        let persister = Persister(memoryCache: cache, diskCache: diskCache)
+        
+        return ItemProvider(networkRequestPerformer: controller, cache: persister)
+    }()
+
+    // MARK: - App
+    
+    var body: some Scene {
+        WindowGroup {
+            TabView {
+                PhotoListOriginal(provider: photoProvider)
+                    .tabItem {
+                        Image(systemName: "photo")
+                        Text("Photos (Original)")
+                    }
+                
+                PhotoList(provider: photoProvider)
+                    .tabItem {
+                        Image(systemName: "photo")
+                        Text("Photos")
+                    }
+            }
+        }
+    }
+}

Example/ExampleApp.swift

@@ -0,0 +1,64 @@
+//
+//  MockItemProvider.swift
+//  ViewStore
+//
+//  Created by Michael Liberatore on 7/11/22.
+//
+
+import Foundation
+import Combine
+import Provider
+import Persister
+import Networking
+
+/// A provider meant to be usable by SwiftUI previews and unit tests to provide mocked, successful `Photo`s synchronously.
+final class MockItemProvider: Provider {
+    private let photos: [Photo]
+
+    /// Creates a new `MockItemProvider` with the specified `Photo`s.
+    /// - Parameter photos: the `Photo`s that the provider will "retrieve" synchronously.
+    init(photos: [Photo]) {
+        self.photos = photos
+    }
+
+    /// Creates a new `MockItemProvider` by generating a `Photo` for each `Int` within the range of `(1...photosCount)`.
+    /// - Parameter photosCount: The number of photos to generate. Note that the bundle must contain images named with the pattern "thumbnail-x.png" where x can be all values between `1` and `photosCount` (inclusive).
+    init(photosCount: Int) {
+        self.photos = (1...photosCount).map { index in
+            let url = Bundle.main.url(forResource: "thumbnail-\(index)", withExtension: "png")!
+            return Photo(albumId: 0, id: index, title: "Hello-\(index)", url: url, thumbnailUrl: url)
+        }
+    }
+
+    // MARK: - Provider
+
+    func provide<Item>(request: ProviderRequest, decoder: ItemDecoder, providerBehaviors: [ProviderBehavior], requestBehaviors: [RequestBehavior], handlerQueue: DispatchQueue, allowExpiredItem: Bool, itemHandler: @escaping (Result<Item, ProviderError>) -> Void) where Item : Identifiable, Item : Decodable, Item : Encodable {
+        itemHandler((photos.first as? Item).flatMap { .success($0) } ?? .failure(.networkError(.noData)))
+    }
+
+    func provideItems<Item>(request: ProviderRequest, decoder: ItemDecoder, providerBehaviors: [ProviderBehavior], requestBehaviors: [RequestBehavior], handlerQueue: DispatchQueue, allowExpiredItems: Bool, itemsHandler: @escaping (Result<[Item], ProviderError>) -> Void) where Item : Identifiable, Item : Decodable, Item : Encodable {
+        itemsHandler((photos as? [Item]).flatMap { .success($0) } ?? .failure(.networkError(.noData)))
+    }
+
+    func provide<Item>(request: ProviderRequest, decoder: ItemDecoder, providerBehaviors: [ProviderBehavior], requestBehaviors: [RequestBehavior], allowExpiredItem: Bool) -> AnyPublisher<Item, ProviderError> where Item : Identifiable, Item : Decodable, Item : Encodable {
+        if let item = photos.first as? Item {
+            return Just(item)
+                .setFailureType(to: ProviderError.self)
+                .eraseToAnyPublisher()
+        } else {
+            return Fail(error: ProviderError.networkError(.noData))
+                .eraseToAnyPublisher()
+        }
+    }
+
+    func provideItems<Item>(request: ProviderRequest, decoder: ItemDecoder, providerBehaviors: [ProviderBehavior], requestBehaviors: [RequestBehavior], allowExpiredItems: Bool) -> AnyPublisher<[Item], ProviderError> where Item : Identifiable, Item : Decodable, Item : Encodable {
+        if let items = photos as? [Item] {
+            return Just(items)
+                .setFailureType(to: ProviderError.self)
+                .eraseToAnyPublisher()
+        } else {
+            return Fail(error: ProviderError.networkError(.noData))
+                .eraseToAnyPublisher()
+        }
+    }
+}

Example/ExampleView.swift

@@ -0,0 +1,34 @@
+//
+//  Photo.swift
+//  ViewStore
+//
+//  Created by Twig on 2/24/22.
+//
+
+import Foundation
+import Provider
+
+/// Represents a remote image.
+struct Photo: Codable, Identifiable, Swift.Identifiable {
+
+    /// The unique identifier associated with the album to which this photo belongs.
+    let albumId: Int
+
+    /// The unique identifier of this photo.
+    let id: Int
+
+    /// Descriptive text that is associated with the image, i.e. what it is called.
+    let title: String
+
+    /// The URL at which the full image data can be retrieved.
+    let url: URL
+
+    /// THe URL at which a lower resolution version of the image data can be retrieved.
+    let thumbnailUrl: URL
+    
+    // MARK: - Identifiable
+    
+    var identifier: Key {
+        return "\(id)"
+    }
+}

Example/ExampleViewStore.swift

@@ -0,0 +1,74 @@
+//
+//  PhotoList.swift
+//  ViewStore
+//
+//  Created by Twig on 2/24/22.
+//
+
+import SwiftUI
+import Provider
+
+/// Displays a list of photos retrieved from an API. Uses a `ViewStore` for coordination with the data source.
+struct PhotoList: View {
+    
+    @StateObject private var store: PhotoListViewStore
+
+    /// Creates a new `PhotoList`.
+    /// - Parameters:
+    ///   - provider: The provider responsible for fetching photos.
+    ///   - scheduler: Determines how state updates are scheduled to be delivered in the view store. Defaults to `default`, which asynchronously schedules updates on the main queue.
+    init(provider: Provider, scheduler: MainQueueScheduler = .init(type: .default)) {
+        self._store = StateObject(wrappedValue: PhotoListViewStore(provider: provider, scheduler: scheduler))
+    }
+
+    // MARK: - View
+
+    var body: some View {
+        NavigationView {
+            ZStack {
+                switch store.viewState.status {
+                case .loading:
+                    ProgressView()
+                        .progressViewStyle(.circular)
+                        .scaleEffect(x: 2, y: 2)
+                case let .content(photos):
+                    List {
+                        Section {
+                            ForEach(photos) { photo in
+                                HStack {
+                                    AsyncImage(url: photo.thumbnailUrl) { image in
+                                        image.resizable()
+                                            .aspectRatio(contentMode: .fit)
+                                    } placeholder: {
+                                        ProgressView()
+                                    }
+                                    .frame(width: 150, height: 150)
+                                    
+                                    Text(photo.title)
+                                }
+                            }
+                        } header: {
+                            Toggle("Show Count", isOn: store.showsPhotoCount)
+                                .animation(.easeInOut, value: store.viewState.showsPhotoCount)
+                        }
+                    }
+                case let .error(error):
+                    VStack {
+                        Image(systemName: "xmark.octagon")
+                        Text(error.localizedDescription)
+                    }
+                }
+
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .navigationTitle(store.viewState.navigationTitle)
+            .searchable(text: store.searchText, placement: .navigationBarDrawer(displayMode: .always))
+        }
+    }
+}
+
+struct PhotoList_Previews: PreviewProvider {
+    static var previews: some View {
+        PhotoList(provider: MockItemProvider(photosCount: 3), scheduler: .init(type: .synchronous))
+    }
+}