2.17.0

Package.swift

@@ -15,15 +15,15 @@ let package = Package(
 		.library(name: "SwiftOpenAPI", targets: ["SwiftOpenAPI"]),
 	],
 	dependencies: [
-		.package(url: "https://github.com/pointfreeco/swift-custom-dump.git", from: "0.10.3")
+		.package(url: "https://github.com/pointfreeco/swift-custom-dump.git", from: "0.10.3"),
 	],
 	targets: [
 		.target(name: "SwiftOpenAPI", dependencies: []),
 		.testTarget(
 			name: "SwiftOpenAPITests",
 			dependencies: [
 				"SwiftOpenAPI",
-				.product(name: "CustomDump", package: "swift-custom-dump")
+				.product(name: "CustomDump", package: "swift-custom-dump"),
 			],
 			exclude: ["Mocks/"]
 		),

README.md

@@ -146,7 +146,7 @@ import PackageDescription
 let package = Package(
   name: "SomeProject",
   dependencies: [
-    .package(url: "https://github.com/dankinsoid/SwiftOpenAPI.git", from: "2.16.7")
+    .package(url: "https://github.com/dankinsoid/SwiftOpenAPI.git", from: "2.17.0")
   ],
   targets: [
     .target(name: "SomeProject", dependencies: ["SwiftOpenAPI"])

Sources/SwiftOpenAPI/Common/AnyRange.swift

@@ -0,0 +1,106 @@
+import Foundation
+
+/// Range expression that supports all range operators
+public struct AnyRange<Bound: Comparable>: RangeExpression {
+
+	public let lowerBound: Bound?
+	public let upperBound: Bound?
+	public let include: Set<RangeEdge>
+
+	public init(lowerBound: Bound?, upperBound: Bound?, include: Set<RangeEdge>) {
+		self.lowerBound = lowerBound.map { lowerBound in
+			upperBound.map { min(lowerBound, $0) } ?? lowerBound
+		}
+		self.upperBound = upperBound.map { upperBound in
+			lowerBound.map { min(upperBound, $0) } ?? upperBound
+		}
+		self.include = include
+	}
+
+	public subscript(_ edge: RangeEdge) -> Bound? {
+		switch edge {
+		case .lower: return lowerBound
+		case .upper: return upperBound
+		}
+	}
+
+	public func relative<C: Collection>(to collection: C) -> Range<Bound> where Bound == C.Index {
+		switch (lowerBound, upperBound, include.contains(.lower), include.contains(.upper)) {
+		case (.some(let lower), let .some(upper), true, true):
+			return (lower ... upper).relative(to: collection)
+		case (.some(let lower), let .some(upper), false, true):
+			return upLowerBound((lower ... upper).relative(to: collection), in: collection)
+		case (.some(let lower), let .some(upper), true, false):
+			return (lower ..< upper).relative(to: collection)
+		case (.some(let lower), let .some(upper), false, false):
+			return upLowerBound((lower ..< upper).relative(to: collection), in: collection)
+		case (.some(let lower), .none, true, _):
+			return (lower...).relative(to: collection)
+		case (.some(let lower), .none, false, _):
+			return upLowerBound((lower...).relative(to: collection), in: collection)
+		case (.none, let .some(upper), _, true):
+			return (...upper).relative(to: collection)
+		case (.none, let .some(upper), _, false):
+			return (..<upper).relative(to: collection)
+		case (.none, .none, _, _):
+			return collection.startIndex ..< collection.endIndex
+		}
+	}
+
+	public func contains(_ element: Bound) -> Bool {
+		let isUpper: Bool
+		if let lowerBound {
+			isUpper = include.contains(.lower) ? element >= lowerBound : element > lowerBound
+		} else {
+			isUpper = true
+		}
+		let isLower: Bool
+		if let upperBound {
+			isLower = include.contains(.upper) ? element <= upperBound : element < upperBound
+		} else {
+			isLower = true
+		}
+		return isLower && isUpper
+	}
+
+	public static var any: AnyRange {
+		AnyRange(lowerBound: nil, upperBound: nil, include: [])
+	}
+
+	private func upLowerBound<C: Collection>(_ range: Range<Bound>, in collection: C) -> Range<Bound> where Bound == C.Index {
+		guard range.upperBound > range.lowerBound else {
+			return range
+		}
+		return collection.index(after: range.lowerBound) ..< range.upperBound
+	}
+}
+
+@_disfavoredOverload
+public func ... <Bound: Comparable>(_ lhs: Bound, _ rhs: Bound) -> AnyRange<Bound> {
+	AnyRange(lowerBound: lhs, upperBound: rhs, include: [.lower, .upper])
+}
+
+@_disfavoredOverload
+public func ..< <Bound: Comparable>(_ lhs: Bound, _ rhs: Bound) -> AnyRange<Bound> {
+	AnyRange(lowerBound: lhs, upperBound: rhs, include: [.lower])
+}
+
+@_disfavoredOverload
+public postfix func ... <Bound: Comparable>(_ lhs: Bound) -> AnyRange<Bound> {
+	AnyRange(lowerBound: lhs, upperBound: nil, include: [.lower])
+}
+
+@_disfavoredOverload
+public prefix func ..< <Bound: Comparable>(_ rhs: Bound) -> AnyRange<Bound> {
+	AnyRange(lowerBound: nil, upperBound: rhs, include: [])
+}
+
+@_disfavoredOverload
+public prefix func ... <Bound: Comparable>(_ rhs: Bound) -> AnyRange<Bound> {
+	AnyRange(lowerBound: nil, upperBound: rhs, include: [.upper])
+}
+
+public enum RangeEdge: Hashable {
+
+	case lower, upper
+}

Sources/SwiftOpenAPI/Common/Bool++.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+extension Bool {
+
+	var nilIfFalse: Bool? {
+		self ? self : nil
+	}
+}

Sources/SwiftOpenAPI/Common/Collection++.swift

@@ -7,16 +7,16 @@ extension Collection {
 	}
 }
 
-extension Dictionary {
+extension OrderedDictionary {
 
-	func mapKeys<T>(_ map: (Key) -> T) -> [T: Value] {
-		[T: Value](self.map { (map($0.key), $0.value) }) { _, new in
+	func mapKeys<T>(_ map: (Key) -> T) -> OrderedDictionary<T, Value> {
+		OrderedDictionary<T, Value>(self.map { (map($0.key), $0.value) }) { _, new in
 			new
 		}
 	}
 
-	func mapKeys<T, V>(_ map: (Key) -> T, values: (Value) -> V) -> [T: V] {
-		[T: V](self.map { (map($0.key), values($0.value)) }) { _, new in
+	func mapKeys<T, V>(_ map: (Key) -> T, values: (Value) -> V) -> OrderedDictionary<T, V> {
+		OrderedDictionary<T, V>(self.map { (map($0.key), values($0.value)) }) { _, new in
 			new
 		}
 	}

Sources/SwiftOpenAPI/Common/File.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+extension Decimal {
+
+	var double: Double {
+		(self as NSDecimalNumber).doubleValue
+	}
+}