Implement Paging model

TestableDesignExample/MvcArchitecture/Paging/PageEndDetectionStrategy.swift

@@ -0,0 +1,56 @@
+protocol PageEndDetectionStrategyContract {
+    associatedtype Element
+
+    func isPageEnd(
+        fetching pageNumber: Int,
+        to direction: PageEndDirection,
+        storedCollection: [Element],
+        fetchedCollection: [Element]
+    ) -> Bool
+}
+
+
+
+extension PageEndDetectionStrategyContract {
+    func asAny() -> AnyPageEndDetectionStrategy<Element> {
+        return AnyPageEndDetectionStrategy<Element>(wrapping: self)
+    }
+}
+
+
+
+class AnyPageEndDetectionStrategy<T>: PageEndDetectionStrategyContract {
+    typealias Element = T
+
+
+    private let _isPageEnd: (Int, PageEndDirection, [Element], [Element]) -> Bool
+
+
+    init<WrappedStrategy: PageEndDetectionStrategyContract>(
+        wrapping wrappedStrategy: WrappedStrategy
+    ) where WrappedStrategy.Element == Element {
+        self._isPageEnd = { (pageNumber, direction, storedCollection, fetchedCollection) in
+            return wrappedStrategy.isPageEnd(
+                fetching: pageNumber,
+                to: direction,
+                storedCollection: storedCollection,
+                fetchedCollection: fetchedCollection
+            )
+        }
+    }
+
+
+    func isPageEnd(
+        fetching pageNumber: Int,
+        to direction: PageEndDirection,
+        storedCollection: [Element],
+        fetchedCollection: [Element]
+    ) -> Bool {
+        return self._isPageEnd(
+            pageNumber,
+            direction,
+            storedCollection,
+            fetchedCollection
+        )
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PageEndDetectionStrategyStub.swift

@@ -0,0 +1,27 @@
+@testable import TestableDesignExample
+
+
+
+class PageEndDetectionStrategyStub<T>: PageEndDetectionStrategyContract {
+    typealias Element = T
+
+
+    private let range: Range<Int>
+
+
+    init(
+        whereCursorMovingOn range: Range<Int>
+    ) {
+        self.range = range
+    }
+
+
+    func isPageEnd(
+        fetching pageNumber: Int,
+        to direction: PageEndDirection,
+        storedCollection: [Element],
+        fetchedCollection: [Element]
+    ) -> Bool {
+        return !(range ~= pageNumber)
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PageEndDirection.swift

@@ -0,0 +1,4 @@
+enum PageEndDirection {
+    case next
+    case previous
+}

TestableDesignExample/MvcArchitecture/Paging/PageRepository.swift

@@ -0,0 +1,40 @@
+import PromiseKit
+
+
+
+protocol PageRepositoryContract {
+    associatedtype Element: Hashable
+
+    func fetch(pageOf pageNumber: Int) -> Promise<[Element]>
+}
+
+
+
+extension PageRepositoryContract {
+    func asAny() -> AnyPageRepository<Element> {
+        return AnyPageRepository<Element>(wrapping: self)
+    }
+}
+
+
+
+class AnyPageRepository<T: Hashable>: PageRepositoryContract {
+    typealias Element = T
+
+
+    private let _fetch: (Int) -> Promise<[Element]>
+
+
+    init<WrappedRepository: PageRepositoryContract>(
+        wrapping wrappedRepository: WrappedRepository
+    ) where WrappedRepository.Element == Element {
+        self._fetch = { pageNumber in
+            return wrappedRepository.fetch(pageOf: pageNumber)
+        }
+    }
+
+
+    func fetch(pageOf pageNumber: Int) -> Promise<[Element]> {
+        return self._fetch(pageNumber)
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PageRepositorySpy.swift

@@ -0,0 +1,15 @@
+import PromiseKit
+@testable import TestableDesignExample
+
+
+
+class PageRepositorySpy<T: Hashable>: PageRepositoryStub<T> {
+    private(set) var calledArguments = [Int]()
+
+
+    override func fetch(pageOf pageNumber: Int) -> Promise<[Element]> {
+        self.calledArguments.append(pageNumber)
+
+        return super.fetch(pageOf: pageNumber)
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PageRepositoryStub.swift

@@ -0,0 +1,21 @@
+import PromiseKit
+@testable import TestableDesignExample
+
+
+
+class PageRepositoryStub<T: Hashable>: PageRepositoryContract {
+    typealias Element = T
+
+
+    private let block: (Int) -> Promise<[Element]>
+
+
+    init(willReturn block: @escaping (Int) -> Promise<[Element]>) {
+        self.block = block
+    }
+
+
+    func fetch(pageOf pageNumber: Int) -> Promise<[Element]> {
+        return self.block(pageNumber)
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PagedElementCollection.swift

@@ -0,0 +1,16 @@
+enum PagedElementCollection {
+    static func append<Element: Hashable>(_ storedElements: [Element], and fetchedElements: [Element]) -> [Element] {
+        var result = storedElements
+        let set = Set(storedElements)
+
+        fetchedElements.forEach { element in
+            guard !set.contains(element) else {
+                return
+            }
+
+            result.append(element)
+        }
+
+        return result
+    }
+}

TestableDesignExample/MvcArchitecture/Paging/PagingCursor.swift

@@ -0,0 +1,85 @@
+protocol PagingCursorContract {
+    var nextPage: Int { get }
+    var previousPage: Int { get }
+
+    func reset()
+    func fetchingNextPageDidSucceed(isPageEnd: Bool)
+    func fetchingPreviousPageDidSucceed(isPageEnd: Bool)
+}
+
+
+
+extension PagingCursorContract {
+    func getPageNumber(of direction: PageEndDirection) -> Int {
+        switch direction {
+        case .previous:
+            return self.previousPage
+        case .next:
+            return self.nextPage
+        }
+    }
+
+
+    func fetchingDidSucceed(for direction: PageEndDirection, isPageEnd: Bool) {
+        switch direction {
+        case .previous:
+            self.fetchingPreviousPageDidSucceed(isPageEnd: isPageEnd)
+        case .next:
+            self.fetchingNextPageDidSucceed(isPageEnd: isPageEnd)
+        }
+    }
+}
+
+
+
+class PagingCursor: PagingCursorContract {
+    private(set) var nextPage: Int
+    private(set) var previousPage: Int
+
+
+    typealias Domain = (upperBound: Int, lowerBound: Int)
+    private let domain: Domain
+    private let initialNextPage = 1
+    private let initialPreviousPage = 1
+
+
+    init(whereMovingOn domain: Domain) {
+        self.domain = domain
+        self.nextPage = self.initialNextPage
+        self.previousPage = self.initialPreviousPage
+    }
+
+
+    func reset() {
+        self.nextPage = self.initialNextPage
+        self.previousPage = self.initialPreviousPage
+    }
+
+
+    func fetchingNextPageDidSucceed(isPageEnd: Bool) {
+        let isReachingDomainBound = self.domain.upperBound <= self.nextPage
+
+        if isPageEnd || isReachingDomainBound {
+            return
+        }
+
+        self.nextPage += 1
+    }
+
+
+    func fetchingPreviousPageDidSucceed(isPageEnd: Bool) {
+        let isReachingDomainBound = self.domain.lowerBound >= self.nextPage
+
+        if isPageEnd || isReachingDomainBound {
+            return
+        }
+
+        self.previousPage += 1
+    }
+
+
+    static let standardDomain: Domain = (
+        upperBound: Int.max,
+        lowerBound: 1
+    )
+}