Add ReversibleTransformer and tests. remove unneeded check in Entity.check().

Author: mattpolzin

Sources/JSONAPI/Resource/Attribute.swift

@@ -19,6 +19,13 @@ public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Trans
 	}
 }
 
+extension TransformedAttribute where Transformer: ReversibleTransformer {
+	public init(transformedValue: Transformer.To) throws {
+		self.value = transformedValue
+		rawValue = try Transformer.reverse(value)
+	}
+}
+
 extension TransformedAttribute: CustomStringConvertible {
 	public var description: String {
 		return "Attribute<\(String(describing: Transformer.From.self)) -> \(String(describing: Transformer.To.self))>(\(String(describing: value)))"

Sources/JSONAPI/Resource/Transformer.swift

@@ -9,11 +9,16 @@ public protocol Transformer {
 	associatedtype From
 	associatedtype To
 
-	static func transform(_ from: From) throws -> To
+	static func transform(_ value: From) throws -> To
 }
 
-public enum IdentityTransformer<T>: Transformer {
-	public static func transform(_ from: T) throws -> T { return from }
+public protocol ReversibleTransformer: Transformer {
+	static func reverse(_ value: To) throws -> From
+}
+
+public enum IdentityTransformer<T>: ReversibleTransformer {
+	public static func transform(_ value: T) throws -> T { return value }
+	public static func reverse(_ value: T) throws -> T { return value }
 }
 
 // MARK: - Validator
@@ -22,10 +27,19 @@ public enum IdentityTransformer<T>: Transformer {
 /// is passed to it but it does not change the type of the value. Any
 /// Transformer will perform validation in one sense so a Validator is
 /// really just semantic sugar (it can provide clarity in its use).
-public protocol Validator: Transformer where From == To {}
+/// To enforce the semantics, any change of the value in your implementation
+/// of `Validator.transform()` will be ignored.
+public protocol Validator: ReversibleTransformer where From == To {
+}
 
 extension Validator {
+	public static func reverse(_ value: To) throws -> To {
+		let _ = try transform(value)
+		return value
+	}
+
 	public static func validate(_ value: To) throws -> To {
-		return try transform(value)
+		let _ = try transform(value)
+		return value
 	}
 }

Sources/JSONAPITestLib/EntityCheck.swift

@@ -8,12 +8,25 @@
 import JSONAPI
 
 public enum EntityCheckError: Swift.Error {
+	/// The attributes should live in a struct, not
+	/// another type class.
 	case attributesNotStruct
+
+	/// The relationships should live in a struct, not
+	/// another type class.
 	case relationshipsNotStruct
+
+	/// All stored properties on an Attributes struct should
+	/// be one of the supplied Attribute types.
 	case nonAttribute(named: String)
+
+	/// All stored properties on a Relationships struct should
+	/// be one of the supplied Relationship types.
 	case nonRelationship(named: String)
+
+	/// It is explicitly stated by the JSON spec
+	/// a "none" value for arrays is an empty array, not `nil`.
 	case nullArray(named: String)
-	case badId
 }
 
 public struct EntityCheckErrors: Swift.Error {
@@ -36,10 +49,6 @@ public extension Entity {
 	public static func check(_ entity: Entity) throws {
 		var problems = [EntityCheckError]()
 
-		if Swift.type(of: entity.id).EntityType.Description.self != Description.self {
-			problems.append(.badId)
-		}
-
 		let attributesMirror = Mirror(reflecting: entity.attributes)
 
 		if attributesMirror.displayStyle != .`struct` {

Tests/JSONAPITests/Attribute/AttributeTests.swift

@@ -18,4 +18,31 @@ class AttributeTests: XCTestCase {
 		XCTAssertEqual(try Attribute<String>(rawValue: "hello"), Attribute<String>(value: "hello"))
 	}
 
+	func test_TransformedAttributeNoThrow() {
+		XCTAssertNoThrow(try TransformedAttribute<String, TestTransformer>(rawValue: "10"))
+	}
+
+	func test_TransformedAttributeThrows() {
+		XCTAssertThrowsError(try TransformedAttribute<String, TestTransformer>(rawValue: "10.3"))
+	}
+
+	func test_TransformedAttributeReversNoThrow() {
+		XCTAssertNoThrow(try TransformedAttribute<String, TestTransformer>(transformedValue: 10))
+	}
+}
+
+// MARK: Test types
+extension AttributeTests {
+	enum TestTransformer: ReversibleTransformer {
+		public static func transform(_ value: String) throws -> Int {
+			guard let ret = Int(value) else {
+				throw DecodingError.typeMismatch(Int.self, .init(codingPath: [], debugDescription: "Expected Int from String."))
+			}
+			return ret
+		}
+
+		public static func reverse(_ value: Int) throws -> String {
+			return String(value)
+		}
+	}
 }