release: 2.9.0

.github/workflows/deploy.yml

@@ -8,10 +8,14 @@ on:
 
 jobs:
   deploy:
-    runs-on: macos-latest
+    runs-on: macos-12
     steps:
       - uses: actions/checkout@v2
 
+      - uses: maxim-lobanov/setup-xcode@v1
+        with:
+          xcode-version: '13.4.1'
+
       - name: Set up ruby env
         uses: ruby/setup-ruby@v1
         with:
@@ -29,7 +33,17 @@ jobs:
         with:
           version: latest
 
+      - name: Cache Pods
+        id: cache-pods
+        uses: actions/cache@v3
+        with: 
+          path: Pods 
+          key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
+          restore-keys: | 
+            ${{ runner.os }}-pods-
+
       - name: Install Dependencies
+        if: steps.cache-pods.outputs.cache-hit != 'true'
         run: pod install --repo-update
 
       - name: Restore Secrets

CoreDataStack/Entity/UploadFile+CoreDataProperties.swift

@@ -17,18 +17,18 @@ extension UploadFile {
         return NSFetchRequest<UploadFile>(entityName: "UploadFile")
     }
 
+    @NSManaged public var content: Data?
     @NSManaged public var createdAt: Date?
     @NSManaged public var fileSize: Double
     @NSManaged public var fileType: Int64
     @NSManaged public var id: String?
     @NSManaged public var key: String?
     @NSManaged public var landingTxID: String?
-    @NSManaged public var mime: String?
     @NSManaged public var name: String?
     @NSManaged public var payloadTxID: String?
     @NSManaged public var provider: String?
-    @NSManaged public var uploadOption: String?
-    @NSManaged public var content: Data?
+    @NSManaged public var encrypted: String?
+    @NSManaged public var meson: String?
 
 }
 

CoreDataStack/Extension/Predicate.swift

@@ -1,6 +1,7 @@
 import Foundation
 
-public final class Predicate<S> : NSCompoundPredicate {
+
+public final class Predicate<S>: NSCompoundPredicate {
     fileprivate init(from predicate: NSPredicate) {
         super.init(type: .and, subpredicates: [predicate])
     }
@@ -9,18 +10,82 @@ public final class Predicate<S> : NSCompoundPredicate {
         super.init(type: type, subpredicates: subpredicates)
     }
 
-    required public init?(coder: NSCoder) {
+    @available(*, unavailable)
+    public required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
 }
 
-public func == <S, E: Equatable>(lhs: KeyPath<S,E>, rhs: E) -> Predicate<S> {
+/// Only use for NSManagedObject as we use NSExpression to make it work
+/// stable Types: Date, String, Int
+/// optional work types: Date, String
+
+public func == <S, E: Equatable>(lhs: KeyPath<S, E>, rhs: E) -> Predicate<S> {
+    let predicate = NSComparisonPredicate(
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .equalTo,
+        options: []
+    )
+
+    return Predicate<S>(from: predicate)
+}
+
+public func == <S, E: Equatable>(lhs: KeyPath<S, E?>, rhs: E?) -> Predicate<S> {
+    let predicate = NSComparisonPredicate(
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .equalTo,
+        options: [])
+
+    return Predicate<S>(from: predicate)
+}
+
+public func != <S, E: Equatable>(lhs: KeyPath<S, E>, rhs: E) -> Predicate<S> {
+    let predicate = NSComparisonPredicate(
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .notEqualTo,
+        options: []
+    )
+
+    return Predicate<S>(from: predicate)
+}
+
+public func != <S, E: Equatable>(lhs: KeyPath<S, E?>, rhs: E?) -> Predicate<S> {
+    let predicate = NSComparisonPredicate(
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .notEqualTo,
+        options: []
+    )
+
+    return Predicate<S>(from: predicate)
+}
+
+public func > <S, C: Comparable>(lhs: KeyPath<S, C>, rhs: C) -> Predicate<S> {
+    let predicate = NSComparisonPredicate(
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .greaterThan,
+        options: []
+    )
+
+    return Predicate<S>(from: predicate)
+}
+
+public func > <S, C: Comparable>(lhs: KeyPath<S, C?>, rhs: C?) -> Predicate<S> {
     let predicate = NSComparisonPredicate(
-            leftExpression: NSExpression(forKeyPath: lhs),
-            rightExpression: NSExpression(forConstantValue: rhs),
-            modifier: .direct,
-            type: .equalTo,
-            options: []
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .greaterThan,
+        options: []
     )
 
     return Predicate<S>(from: predicate)
@@ -29,11 +94,11 @@ public func == <S, E: Equatable>(lhs: KeyPath<S,E>, rhs: E) -> Predicate<S> {
 infix operator -->: AdditionPrecedence
 public func --> <S, E: Hashable>(lhs: KeyPath<S, E>, rhs: Set<E>) -> Predicate<S> {
     let predicate = NSComparisonPredicate(
-            leftExpression: NSExpression(forKeyPath: lhs),
-            rightExpression: NSExpression(forConstantValue: rhs),
-            modifier: .direct,
-            type: .in,
-            options: []
+        leftExpression: NSExpression(forKeyPath: lhs),
+        rightExpression: NSExpression(forConstantValue: rhs),
+        modifier: .direct,
+        type: .in,
+        options: []
     )
 
     return Predicate<S>(from: predicate)

CoreDataStack/Mask.xcdatamodeld/Mask.xcdatamodel/contents

@@ -237,19 +237,23 @@
     <entity name="UploadFile" representedClassName=".UploadFile" syncable="YES">
         <attribute name="content" optional="YES" attributeType="Binary"/>
         <attribute name="createdAt" optional="YES" attributeType="Date" usesScalarValueType="NO"/>
+        <attribute name="encrypted" optional="YES" attributeType="String"/>
         <attribute name="fileSize" optional="YES" attributeType="Double" defaultValueString="0.0" usesScalarValueType="YES"/>
         <attribute name="fileType" optional="YES" attributeType="Integer 64" defaultValueString="0" usesScalarValueType="YES"/>
         <attribute name="id" optional="YES" attributeType="String"/>
         <attribute name="key" optional="YES" attributeType="String"/>
         <attribute name="landingTxID" optional="YES" attributeType="String"/>
-        <attribute name="mime" optional="YES" attributeType="String"/>
+        <attribute name="meson" optional="YES" attributeType="String"/>
         <attribute name="name" optional="YES" attributeType="String"/>
         <attribute name="payloadTxID" optional="YES" attributeType="String"/>
         <attribute name="provider" optional="YES" attributeType="String"/>
-        <attribute name="uploadOption" optional="YES" attributeType="String"/>
         <uniquenessConstraints>
             <uniquenessConstraint>
                 <constraint value="id"/>
+                <constraint value="landingTxID"/>
+                <constraint value="payloadTxID"/>
+                <constraint value="encrypted"/>
+                <constraint value="meson"/>
             </uniquenessConstraint>
         </uniquenessConstraints>
     </entity>

CoreDataStackTests/CoreDataStackTests.swift

@@ -9,6 +9,31 @@
 @testable import CoreDataStack
 import XCTest
 
+@objcMembers
+final class Person: NSObject {
+    let name: String?
+    let date: Date
+    let id: String
+
+    let pet: Pet
+
+    init(name: String?, date: Date, id: String) {
+        self.name = name
+        self.date = date
+        self.id = id
+        self.pet = .init(name: name)
+    }
+
+    @objcMembers
+    final class Pet: NSObject {
+        let name: String?
+
+        init(name: String?) {
+            self.name = name
+        }
+    }
+}
+
 class CoreDataStackTests: XCTestCase {
     override func setUpWithError() throws {
         try super.setUpWithError()
@@ -31,4 +56,18 @@ class CoreDataStackTests: XCTestCase {
             // Put the code you want to measure the time of here.
         }
     }
+
+    func testPredicates() {
+        let persons = [
+            Person(name: "mike", date: Date(timeIntervalSince1970: 8), id: "113"),
+            .init(name: "tale", date: Date(), id: "daa"),
+            .init(name: nil, date: Date(), id: "131")
+        ]
+
+        // note Int? is not supported by predicate
+        let agePredicate = \Person.date > Date()
+
+        let result = persons.filter { agePredicate.evaluate(with: $0) }
+        XCTAssert(result.first?.name != "mike")
+    }
 }