Restructure files a bit. Make Date handling relatively robust compared to my first pass at it. Make the failure to construct a generic open API node type throw an error rather than silently omit the node.

Sources/JSONAPIOpenAPI/Sampleable/Sampleable+OpenAPI.swift

@@ -0,0 +1,161 @@
+//
+//  Sampleable+OpenAPI.swift
+//  JSONAPIOpenAPI
+//
+//  Created by Mathew Polzin on 1/24/19.
+//
+
+import Foundation
+import AnyCodable
+
+public typealias SampleableOpenAPIType = Sampleable & GenericOpenAPINodeType
+
+extension Sampleable where Self: Encodable {
+	public static func genericOpenAPINode(using encoder: JSONEncoder) throws -> JSONNode {
+
+		// short circuit for dates
+		if let dateType = self as? Date.Type,
+			let node = try dateType.dateOpenAPINodeGuess(using: encoder) ?? primitiveGuess(using: encoder) {
+			return node
+		}
+
+		let mirror = Mirror(reflecting: Self.sample)
+		let properties: [(String, JSONNode)] = try mirror.children.compactMap { child in
+
+			// see if we can enumerate the possible values
+			let maybeAllCases: [AnyCodable]? = {
+				switch type(of: child.value) {
+				case let valType as AnyJSONCaseIterable.Type:
+					return valType.allCases(using: encoder)
+				case let valType as AnyWrappedJSONCaseIterable.Type:
+					return valType.allCases(using: encoder)
+				default:
+					return nil
+				}
+			}()
+
+			// try to snag an OpenAPI Node
+			let maybeOpenAPINode: JSONNode? = try {
+				switch type(of: child.value) {
+				case let valType as OpenAPINodeType.Type:
+					return try valType.openAPINode()
+
+				case let valType as RawOpenAPINodeType.Type:
+					return try valType.rawOpenAPINode()
+
+				case let valType as WrappedRawOpenAPIType.Type:
+					return try valType.wrappedOpenAPINode()
+
+				case let valType as DoubleWrappedRawOpenAPIType.Type:
+					return try valType.wrappedOpenAPINode()
+
+				case let valType as GenericOpenAPINodeType.Type:
+					return try valType.genericOpenAPINode(using: encoder)
+
+				case let valType as DateOpenAPINodeType.Type:
+					return valType.dateOpenAPINodeGuess(using: encoder)
+
+				default:
+					throw OpenAPITypeError.unknownNodeType(self)
+//					return nil
+				}
+				}()
+
+			// put it all together
+			let newNode: JSONNode?
+			if let allCases = maybeAllCases,
+				let openAPINode = maybeOpenAPINode {
+				newNode = try openAPINode.with(allowedValues: allCases)
+			} else {
+				newNode = maybeOpenAPINode
+			}
+
+			return zip(child.label, newNode) { ($0, $1) }
+		}
+
+		// if there are no properties, let's see if we are dealing
+		// with a primitive.
+		if properties.count == 0,
+			let primitive = try primitiveGuess(using: encoder) {
+			return primitive
+		}
+
+		// There should not be any duplication of keys since these are
+		// property names, but rather than risk runtime exception, we just
+		// fail to the newer value arbitrarily
+		let propertiesDict = Dictionary(properties) { _, value2 in value2 }
+
+		return .object(.init(format: .generic,
+							 required: true),
+					   .init(properties: propertiesDict))
+	}
+
+	private static func primitiveGuess(using encoder: JSONEncoder) throws -> JSONNode? {
+
+		let data = try encoder.encode(PrimitiveWrapper(primitive: Self.sample))
+		let wrappedValue = try JSONSerialization.jsonObject(with: data, options: [.allowFragments])
+
+		guard let wrapperDict = wrappedValue as? [String: Any],
+			wrapperDict.contains(where: { $0.key == "primitive" }) else {
+				throw OpenAPICodableError.primitiveGuessFailed
+		}
+
+		let value = (wrappedValue as! [String: Any])["primitive"]!
+
+		return try {
+			switch type(of: value) {
+			case let valType as OpenAPINodeType.Type:
+				return try valType.openAPINode()
+
+			case let valType as RawOpenAPINodeType.Type:
+				return try valType.rawOpenAPINode()
+
+			case let valType as WrappedRawOpenAPIType.Type:
+				return try valType.wrappedOpenAPINode()
+
+			case let valType as DoubleWrappedRawOpenAPIType.Type:
+				return try valType.wrappedOpenAPINode()
+
+			case let valType as GenericOpenAPINodeType.Type:
+				return try valType.genericOpenAPINode(using: encoder)
+
+			case let valType as DateOpenAPINodeType.Type:
+				return valType.dateOpenAPINodeGuess(using: encoder)
+
+			default:
+				return nil
+			}
+			}() ?? {
+				switch value {
+				case is String:
+					return .string(.init(format: .generic,
+										 required: true),
+								   .init())
+
+				case is Int:
+					return .integer(.init(format: .generic,
+										  required: true),
+									.init())
+
+				case is Double:
+					return .number(.init(format: .double,
+										 required: true),
+								   .init())
+
+				case is Bool:
+					return .boolean(.init(format: .generic,
+										  required: true))
+
+				default:
+					return nil
+				}
+			}()
+	}
+}
+
+// The following wrapper is only needed because JSONEncoder cannot yet encode
+// JSON fragments. It is a very unfortunate limitation that requires silly
+// workarounds in edge cases like this.
+private struct PrimitiveWrapper<Wrapped: Encodable>: Encodable {
+	let primitive: Wrapped
+}