Merge branch '7.x-branch'

# Conflicts:
#	Sources/Nimble/Matchers/BeginWith.swift
#	Sources/Nimble/Matchers/Contain.swift
#	Sources/Nimble/Matchers/EndWith.swift

Author: ikesyo

Nimble.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "Nimble"
-  s.version      = "7.1.2"
+  s.version      = "7.1.3"
   s.summary      = "A Matcher Framework for Swift and Objective-C"
   s.description  = <<-DESC
                    Use Nimble to express the expected outcomes of Swift or Objective-C expressions. Inspired by Cedar.

Sources/Nimble/Adapters/NMBExpectation.swift

@@ -4,7 +4,7 @@ import Foundation
 
 private func from(objcPredicate: NMBPredicate) -> Predicate<NSObject> {
     return Predicate { actualExpression in
-        let result = objcPredicate.satisfies(({ try! actualExpression.evaluate() }),
+        let result = objcPredicate.satisfies(({ try actualExpression.evaluate() }),
                                              location: actualExpression.location)
         return result.toSwift()
     }

Sources/Nimble/Adapters/NMBObjCMatcher.swift

@@ -3,8 +3,8 @@ import Foundation
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 
 // swiftlint:disable line_length
-public typealias MatcherBlock = (_ actualExpression: Expression<NSObject>, _ failureMessage: FailureMessage) -> Bool
-public typealias FullMatcherBlock = (_ actualExpression: Expression<NSObject>, _ failureMessage: FailureMessage, _ shouldNotMatch: Bool) -> Bool
+public typealias MatcherBlock = (_ actualExpression: Expression<NSObject>, _ failureMessage: FailureMessage) throws -> Bool
+public typealias FullMatcherBlock = (_ actualExpression: Expression<NSObject>, _ failureMessage: FailureMessage, _ shouldNotMatch: Bool) throws -> Bool
 // swiftlint:enable line_length
 
 public class NMBObjCMatcher: NSObject, NMBMatcher {
@@ -26,7 +26,7 @@ public class NMBObjCMatcher: NSObject, NMBMatcher {
 
     public convenience init(canMatchNil: Bool, matcher: @escaping MatcherBlock) {
         self.init(canMatchNil: canMatchNil, matcher: matcher, notMatcher: ({ actualExpression, failureMessage in
-            return !matcher(actualExpression, failureMessage)
+            return try !matcher(actualExpression, failureMessage)
         }))
     }
 
@@ -36,9 +36,9 @@ public class NMBObjCMatcher: NSObject, NMBMatcher {
 
     public convenience init(canMatchNil: Bool, matcher: @escaping FullMatcherBlock) {
         self.init(canMatchNil: canMatchNil, matcher: ({ actualExpression, failureMessage in
-            return matcher(actualExpression, failureMessage, false)
+            return try matcher(actualExpression, failureMessage, false)
         }), notMatcher: ({ actualExpression, failureMessage in
-            return matcher(actualExpression, failureMessage, true)
+            return try matcher(actualExpression, failureMessage, true)
         }))
     }
 
@@ -59,9 +59,14 @@ public class NMBObjCMatcher: NSObject, NMBMatcher {
 
     public func matches(_ actualBlock: @escaping () -> NSObject?, failureMessage: FailureMessage, location: SourceLocation) -> Bool {
         let expr = Expression(expression: actualBlock, location: location)
-        let result = _match(
-            expr,
-            failureMessage)
+        let result: Bool
+        do {
+            result = try _match(expr, failureMessage)
+        } catch let error {
+            failureMessage.stringValue = "unexpected error thrown: <\(error)>"
+            return false
+        }
+
         if self.canMatch(Expression(expression: actualBlock, location: location), failureMessage: failureMessage) {
             return result
         } else {
@@ -71,9 +76,14 @@ public class NMBObjCMatcher: NSObject, NMBMatcher {
 
     public func doesNotMatch(_ actualBlock: @escaping () -> NSObject?, failureMessage: FailureMessage, location: SourceLocation) -> Bool {
         let expr = Expression(expression: actualBlock, location: location)
-        let result = _doesNotMatch(
-            expr,
-            failureMessage)
+        let result: Bool
+        do {
+            result = try _doesNotMatch(expr, failureMessage)
+        } catch let error {
+            failureMessage.stringValue = "unexpected error thrown: <\(error)>"
+            return false
+        }
+
         if self.canMatch(Expression(expression: actualBlock, location: location), failureMessage: failureMessage) {
             return result
         } else {

Sources/Nimble/Matchers/AllPass.swift

@@ -68,7 +68,7 @@ extension NMBObjCMatcher {
     @objc public class func allPassMatcher(_ matcher: NMBMatcher) -> NMBPredicate {
         return NMBPredicate { actualExpression in
             let location = actualExpression.location
-            let actualValue = try! actualExpression.evaluate()
+            let actualValue = try actualExpression.evaluate()
             var nsObjects = [NSObject]()
 
             var collectionIsUsable = true
@@ -99,7 +99,7 @@ extension NMBObjCMatcher {
             let expr = Expression(expression: ({ nsObjects }), location: location)
             let pred: Predicate<[NSObject]> = createPredicate(Predicate { expr in
                 if let predicate = matcher as? NMBPredicate {
-                    return predicate.satisfies(({ try! expr.evaluate() }), location: expr.location).toSwift()
+                    return predicate.satisfies(({ try expr.evaluate() }), location: expr.location).toSwift()
                 } else {
                     let failureMessage = FailureMessage()
                     let result = matcher.matches(
@@ -114,7 +114,7 @@ extension NMBObjCMatcher {
                     )
                 }
             })
-            return try! pred.satisfies(expr).toObjectiveC()
+            return try pred.satisfies(expr).toObjectiveC()
         }
     }
 }

Sources/Nimble/Matchers/BeAKindOf.swift

@@ -59,8 +59,8 @@ public func beAKindOf(_ expectedClass: AnyClass) -> Predicate<NSObject> {
 
 extension NMBObjCMatcher {
     @objc public class func beAKindOfMatcher(_ expected: AnyClass) -> NMBMatcher {
-        return NMBObjCMatcher(canMatchNil: false) { actualExpression, failureMessage in
-            return try! beAKindOf(expected).matches(actualExpression, failureMessage: failureMessage)
+        return NMBPredicate { actualExpression in
+            return try beAKindOf(expected).satisfies(actualExpression).toObjectiveC()
         }
     }
 }

Sources/Nimble/Matchers/BeAnInstanceOf.swift

@@ -48,8 +48,8 @@ public func beAnInstanceOf(_ expectedClass: AnyClass) -> Predicate<NSObject> {
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 extension NMBObjCMatcher {
     @objc public class func beAnInstanceOfMatcher(_ expected: AnyClass) -> NMBMatcher {
-        return NMBObjCMatcher(canMatchNil: false) { actualExpression, failureMessage in
-            return try! beAnInstanceOf(expected).matches(actualExpression, failureMessage: failureMessage)
+        return NMBPredicate { actualExpression in
+            return try beAnInstanceOf(expected).satisfies(actualExpression).toObjectiveC()
         }
     }
 }

Sources/Nimble/Matchers/BeCloseTo.swift

@@ -52,7 +52,13 @@ public class NMBObjCBeCloseToMatcher: NSObject, NMBMatcher {
         })
         let expr = Expression(expression: actualBlock, location: location)
         let matcher = beCloseTo(self._expected, within: self._delta)
-        return try! matcher.matches(expr, failureMessage: failureMessage)
+
+        do {
+            return try matcher.matches(expr, failureMessage: failureMessage)
+        } catch let error {
+            failureMessage.stringValue = "unexpected error thrown: <\(error)>"
+            return false
+        }
     }
 
     @objc public func doesNotMatch(_ actualExpression: @escaping () -> NSObject?, failureMessage: FailureMessage, location: SourceLocation) -> Bool {
@@ -61,7 +67,13 @@ public class NMBObjCBeCloseToMatcher: NSObject, NMBMatcher {
         })
         let expr = Expression(expression: actualBlock, location: location)
         let matcher = beCloseTo(self._expected, within: self._delta)
-        return try! matcher.doesNotMatch(expr, failureMessage: failureMessage)
+
+        do {
+            return try matcher.doesNotMatch(expr, failureMessage: failureMessage)
+        } catch let error {
+            failureMessage.stringValue = "unexpected error thrown: <\(error)>"
+            return false
+        }
     }
 
     @objc public var within: (CDouble) -> NMBObjCBeCloseToMatcher {

Sources/Nimble/Matchers/BeEmpty.swift

@@ -66,14 +66,14 @@ extension NMBObjCMatcher {
     @objc public class func beEmptyMatcher() -> NMBPredicate {
         return NMBPredicate { actualExpression in
             let location = actualExpression.location
-            let actualValue = try! actualExpression.evaluate()
+            let actualValue = try actualExpression.evaluate()
 
             if let value = actualValue as? NMBCollection {
                 let expr = Expression(expression: ({ value as NMBCollection }), location: location)
-                return try! beEmpty().satisfies(expr).toObjectiveC()
+                return try beEmpty().satisfies(expr).toObjectiveC()
             } else if let value = actualValue as? NSString {
                 let expr = Expression(expression: ({ value as String }), location: location)
-                return try! beEmpty().satisfies(expr).toObjectiveC()
+                return try beEmpty().satisfies(expr).toObjectiveC()
             } else if let actualValue = actualValue {
                 // swiftlint:disable:next line_length
                 let badTypeErrorMsg = "be empty (only works for NSArrays, NSSets, NSIndexSets, NSDictionaries, NSHashTables, and NSStrings)"

Sources/Nimble/Matchers/BeGreaterThan.swift

@@ -13,13 +13,13 @@ public func beGreaterThan<T: Comparable>(_ expectedValue: T?) -> Predicate<T> {
 
 /// A Nimble matcher that succeeds when the actual value is greater than the expected value.
 public func beGreaterThan(_ expectedValue: NMBComparable?) -> Predicate<NMBComparable> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-        failureMessage.postfixMessage = "be greater than <\(stringify(expectedValue))>"
+    let errorMessage = "be greater than <\(stringify(expectedValue))>"
+    return Predicate.simple(errorMessage) { actualExpression in
         let actualValue = try actualExpression.evaluate()
         let matches = actualValue != nil
             && actualValue!.NMB_compare(expectedValue) == ComparisonResult.orderedDescending
-        return matches
-    }.requireNonNil
+        return PredicateStatus(bool: matches)
+    }
 }
 
 public func ><T: Comparable>(lhs: Expectation<T>, rhs: T) {
@@ -35,7 +35,7 @@ extension NMBObjCMatcher {
     @objc public class func beGreaterThanMatcher(_ expected: NMBComparable?) -> NMBObjCMatcher {
         return NMBObjCMatcher(canMatchNil: false) { actualExpression, failureMessage in
             let expr = actualExpression.cast { $0 as? NMBComparable }
-            return try! beGreaterThan(expected).matches(expr, failureMessage: failureMessage)
+            return try beGreaterThan(expected).matches(expr, failureMessage: failureMessage)
         }
     }
 }

Sources/Nimble/Matchers/BeGreaterThanOrEqualTo.swift

@@ -3,25 +3,25 @@ import Foundation
 /// A Nimble matcher that succeeds when the actual value is greater than
 /// or equal to the expected value.
 public func beGreaterThanOrEqualTo<T: Comparable>(_ expectedValue: T?) -> Predicate<T> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-        failureMessage.postfixMessage = "be greater than or equal to <\(stringify(expectedValue))>"
+    let message = "be greater than or equal to <\(stringify(expectedValue))>"
+    return Predicate.simple(message) { actualExpression in
         let actualValue = try actualExpression.evaluate()
         if let actual = actualValue, let expected = expectedValue {
-            return actual >= expected
+            return PredicateStatus(bool: actual >= expected)
         }
-        return false
-    }.requireNonNil
+        return .fail
+    }
 }
 
 /// A Nimble matcher that succeeds when the actual value is greater than
 /// or equal to the expected value.
 public func beGreaterThanOrEqualTo<T: NMBComparable>(_ expectedValue: T?) -> Predicate<T> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-        failureMessage.postfixMessage = "be greater than or equal to <\(stringify(expectedValue))>"
+    let message = "be greater than or equal to <\(stringify(expectedValue))>"
+    return Predicate.simple(message) { actualExpression in
         let actualValue = try actualExpression.evaluate()
         let matches = actualValue != nil && actualValue!.NMB_compare(expectedValue) != ComparisonResult.orderedAscending
-        return matches
-    }.requireNonNil
+        return PredicateStatus(bool: matches)
+    }
 }
 
 public func >=<T: Comparable>(lhs: Expectation<T>, rhs: T) {
@@ -37,7 +37,7 @@ extension NMBObjCMatcher {
     @objc public class func beGreaterThanOrEqualToMatcher(_ expected: NMBComparable?) -> NMBObjCMatcher {
         return NMBObjCMatcher(canMatchNil: false) { actualExpression, failureMessage in
             let expr = actualExpression.cast { $0 as? NMBComparable }
-            return try! beGreaterThanOrEqualTo(expected).matches(expr, failureMessage: failureMessage)
+            return try beGreaterThanOrEqualTo(expected).matches(expr, failureMessage: failureMessage)
         }
     }
 }