✅ Add real-world use cases

Author: RemiBardon

Sources/GeoJSON/GeoJSON+Codable.swift

@@ -409,3 +409,38 @@ extension Feature {
 	}
 
 }
+
+fileprivate enum FeatureCollectionCodingKeys: String, CodingKey {
+	case geoJSONType = "type"
+	case features, bbox
+}
+
+extension FeatureCollection {
+	
+	public init(from decoder: Decoder) throws {
+		let container = try decoder.container(keyedBy: FeatureCollectionCodingKeys.self)
+		
+		let type = try container.decode(GeoJSON.`Type`.self, forKey: .geoJSONType)
+		guard type == Self.geoJSONType else {
+			throw DecodingError.typeMismatch(Self.self, DecodingError.Context(
+				codingPath: container.codingPath,
+				debugDescription: "Found GeoJSON type '\(type.rawValue)'"
+			))
+		}
+		
+		let features = try container.decodeIfPresent([Feature<Properties>].self, forKey: .features) ?? []
+		
+		self.init(features: features)
+	}
+	
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: FeatureCollectionCodingKeys.self)
+		
+		try container.encode(Self.geoJSONType, forKey: .geoJSONType)
+		try container.encodeIfPresent(self.features, forKey: .features)
+		// TODO: Create GeoJSONEncoder that allows setting "export bboxes" to a boolean value
+		// TODO: Memoize bboxes not to recompute them all the time (bboxes tree)
+		try container.encodeIfPresent(self.bbox, forKey: .bbox)
+	}
+	
+}

Sources/GeoJSON/Objects/Feature.swift

@@ -10,7 +10,7 @@ public struct Feature<
 //	Geometry: GeoJSON.Geometry,
 //	BoundingBox: GeoJSON.BoundingBox,
 	Properties: GeoJSON.Properties
->: GeoJSON.Object, Hashable, Codable {
+>: GeoJSON.Object {
 
 	public static var geoJSONType: GeoJSON.`Type` { .feature }
 

Sources/GeoJSON/Objects/Geometry.swift

@@ -8,7 +8,7 @@
 
 import Turf
 
-public protocol Geometry: GeoJSON.Object, Hashable, Codable {
+public protocol Geometry: GeoJSON.Object {
 
 	static var geometryType: GeoJSON.`Type`.Geometry { get }
 

Sources/GeoJSON/Objects/Object.swift

@@ -6,7 +6,7 @@
 //  Copyright © 2022 Rémi Bardon. All rights reserved.
 //
 
-public protocol Object {
+public protocol Object: Hashable, Codable {
 
 	associatedtype BoundingBox: GeoJSON.BoundingBox
 

Tests/GeoJSONTests/GeoJSON+DecodableTests.swift

@@ -11,6 +11,8 @@ import XCTest
 
 final class GeoJSONDecodableTests: XCTestCase {
 
+	// MARK: Specification tests
+	
 	func testPosition2DDecode() throws {
 		let string: String = "[-1.55366,47.21881]"
 		let data: Data = try XCTUnwrap(string.data(using: .utf8))
@@ -177,4 +179,192 @@ final class GeoJSONDecodableTests: XCTestCase {
 		XCTAssertEqual(feature, expected)
 	}
 
+	// MARK: Real-world use cases
+	
+	func testDecodeFeatureProperties() throws {
+		struct RealWorldProperties: Hashable, Codable {
+			let prop0: String
+		}
+		
+		let string = """
+		{
+			"type": "Feature",
+			"geometry": {
+				"type": "Point",
+				"coordinates": [102.0, 0.5]
+			},
+			"properties": {
+				"prop0": "value0"
+			}
+		}
+		"""
+		
+		let data: Data = try XCTUnwrap(string.data(using: .utf8))
+		let feature = try JSONDecoder().decode(Feature<RealWorldProperties>.self, from: data)
+		
+		let expected: Feature = Feature(
+			geometry: .point2D(Point2D(coordinates: .init(latitude: 0.5, longitude: 102))),
+			properties: RealWorldProperties(prop0: "value0")
+		)
+		XCTAssertEqual(feature, expected)
+	}
+	
+	/// Example from [RFC 7946, section 1.5](https://datatracker.ietf.org/doc/html/rfc7946#section-1.5).
+	func testDecodeHeterogeneousFeatureCollection() throws {
+		enum HeterogeneousProperties: Hashable, Codable, CustomStringConvertible {
+			struct Properties1: Hashable, Codable, CustomStringConvertible {
+				let prop0: String
+				
+				var description: String {
+					"{prop0:\"\(prop0)\"}"
+				}
+			}
+			struct Properties2: Hashable, Codable, CustomStringConvertible {
+				let prop0: String
+				let prop1: Double
+				
+				var description: String {
+					"{prop0:\"\(prop0)\",prop1:\(prop1)}"
+				}
+			}
+			struct Properties3: Hashable, Codable, CustomStringConvertible {
+				struct Prop1: Hashable, Codable, CustomStringConvertible {
+					let this: String
+					
+					var description: String {
+						"{this:\"\(this)\"}"
+					}
+				}
+				
+				let prop0: String
+				let prop1: Prop1
+				
+				var description: String {
+					"{prop0:\"\(prop0)\",prop1:\(prop1)}"
+				}
+			}
+			
+			enum CodingKeys: String, CodingKey {
+				case prop0, prop1
+			}
+			
+			case type1(Properties1)
+			case type2(Properties2)
+			case type3(Properties3)
+			
+			var description: String {
+				switch self {
+				case .type1(let type1):
+					return type1.description
+				case .type2(let type2):
+					return type2.description
+				case .type3(let type3):
+					return type3.description
+				}
+			}
+			
+			init(from decoder: Decoder) throws {
+				let container = try decoder.container(keyedBy: CodingKeys.self)
+				
+				let prop0 = try container.decode(String.self, forKey: .prop0)
+				do {
+					do {
+						let prop1 = try container.decode(Double.self, forKey: .prop1)
+						self = .type2(.init(prop0: prop0, prop1: prop1))
+					} catch {
+						let prop1 = try container.decode(Properties3.Prop1.self, forKey: .prop1)
+						self = .type3(.init(prop0: prop0, prop1: prop1))
+					}
+				} catch {
+					self = .type1(.init(prop0: prop0))
+				}
+			}
+			
+			func encode(to encoder: Encoder) throws {
+				fatalError("Useless")
+			}
+		}
+		
+		let string = """
+		{
+			"type": "FeatureCollection",
+			"features": [{
+				"type": "Feature",
+				"geometry": {
+					"type": "Point",
+					"coordinates": [102.0, 0.5]
+				},
+				"properties": {
+					"prop0": "value0"
+				}
+			}, {
+				"type": "Feature",
+				"geometry": {
+					"type": "LineString",
+					"coordinates": [
+						[102.0, 0.0],
+						[103.0, 1.0],
+						[104.0, 0.0],
+						[105.0, 1.0]
+					]
+				},
+				"properties": {
+					"prop0": "value0",
+					"prop1": 0.0
+				}
+			}, {
+				"type": "Feature",
+				"geometry": {
+					"type": "Polygon",
+					"coordinates": [
+						[
+							[100.0, 0.0],
+							[101.0, 0.0],
+							[101.0, 1.0],
+							[100.0, 1.0],
+							[100.0, 0.0]
+						]
+					]
+				},
+				"properties": {
+					"prop0": "value0",
+					"prop1": {
+						"this": "that"
+					}
+				}
+			}]
+		}
+		"""
+		
+		let data: Data = try XCTUnwrap(string.data(using: .utf8))
+		let feature = try JSONDecoder().decode(FeatureCollection<HeterogeneousProperties>.self, from: data)
+		
+		let expected: FeatureCollection<HeterogeneousProperties> = FeatureCollection(features: [
+			Feature(
+				geometry: .point2D(Point2D(coordinates: .init(latitude: 0.5, longitude: 102))),
+				properties: .type1(.init(prop0: "value0"))
+			),
+			Feature(
+				geometry: .lineString2D(.init(coordinates: [
+					.init(latitude: 0.0, longitude: 102.0),
+					.init(latitude: 1.0, longitude: 103.0),
+					.init(latitude: 0.0, longitude: 104.0),
+					.init(latitude: 1.0, longitude: 105.0)
+				])!),
+				properties: .type2(.init(prop0: "value0", prop1: 0))
+			),
+			Feature(
+				geometry: .polygon2D(.init(coordinates: .init(arrayLiteral: [
+					.init(latitude: 0.0, longitude: 100.0),
+					.init(latitude: 0.0, longitude: 101.0),
+					.init(latitude: 1.0, longitude: 101.0),
+					.init(latitude: 1.0, longitude: 100.0),
+					.init(latitude: 0.0, longitude: 100.0)
+				]))),
+				properties: .type3(.init(prop0: "value0", prop1: .init(this: "that")))
+			),
+		])
+		XCTAssertEqual(feature, expected)
+	}
+	
 }