Implement dependency wrapping & version spec

Sources/apk/Common/ApkRequirement.swift

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+internal struct ApkRequirement {
+  static func extract(blob extract: String) throws(ParseError) -> (String, ApkVersionSpecification) {
+    var comparer: ComparatorBits = []
+    var dependStr = extract[...]
+    let nameEnd: String.Index, versionStart: String.Index
+
+    // Check for bang prefix to indicate a conflict
+    if dependStr.first == "!" {
+      comparer.insert(.conflict)
+      dependStr = dependStr[dependStr.index(after: dependStr.startIndex)...]
+    }
+
+    // Match comparator
+    if let range = dependStr.firstRange(where: { [ "<", "=", ">", "~" ].contains($0) }) {
+      for c in dependStr[range] {
+        switch c {
+        case "<": comparer.insert(.less)
+        case "=": comparer.insert(.equals)
+        case ">": comparer.insert(.greater)
+        case "~": comparer.formUnion([ .fuzzy, .equals ])
+        default: break
+        }
+      }
+      (nameEnd, versionStart) = (range.lowerBound, range.upperBound)
+    } else {
+      // 
+      if !comparer.contains(.conflict) {
+        comparer.formUnion(.any)
+      }
+      (nameEnd, versionStart) = (dependStr.endIndex, dependStr.endIndex)
+    }
+
+    // Parse version specification
+    let spec = try ApkVersionSpecification(comparer, version: dependStr[versionStart...])
+    let name = String(dependStr[..<nameEnd])
+    return (name, spec)
+  }
+}
+
+extension ApkRequirement {
+  enum ParseError: Error, LocalizedError {
+    case brokenSpec
+
+    var errorDescription: String? {
+      switch self {
+      case .brokenSpec: "Invalid version specification"
+      }
+    }
+  }
+}
+
+//MARK: - Private Implementation
+
+fileprivate extension ApkRequirement {
+  struct ComparatorBits: OptionSet {
+    let rawValue: UInt8
+
+    static let equals: Self   = Self(rawValue: 1 << 0)
+    static let less: Self     = Self(rawValue: 1 << 1)
+    static let greater: Self  = Self(rawValue: 1 << 2)
+    static let fuzzy: Self    = Self(rawValue: 1 << 3)
+    static let conflict: Self = Self(rawValue: 1 << 4)
+
+    static let any: Self = [ .equals, .less, .greater ]
+    static let checksum: Self = [ .less, .greater ]
+  }
+}
+
+fileprivate extension ApkVersionSpecification {
+  init(_ bits: ApkRequirement.ComparatorBits, version: Substring) throws(ApkRequirement.ParseError) {
+    if bits == [ .conflict ] {
+      self = .conflict
+    } else {
+      if bits.contains(.conflict) {
+        throw .brokenSpec
+      } else if bits == [ .any ] {
+        self = .any
+      } else {
+        self = .constraint(op: try .init(bits), version: String(version))
+      }
+    }
+  }
+}
+
+fileprivate extension ApkVersionSpecification.Operator {
+  init(_ bits: ApkRequirement.ComparatorBits) throws(ApkRequirement.ParseError) {
+    self = switch bits.subtracting(.conflict) {
+    case .equals:   .equals
+    case .less:     .less
+    case .greater:  .greater
+    //case .checksum: .checksum
+    case [ .equals, .less ]:    .lessEqual
+    case [ .equals, .greater ]: .greaterEqual
+    case [ .fuzzy, .equals ], .fuzzy:  .fuzzyEquals
+    case [ .fuzzy, .equals, .less]:    .lessFuzzy
+    case [ .fuzzy, .equals, .greater]: .greaterFuzzy
+    default: throw .brokenSpec
+    }
+  }
+}
+
+fileprivate extension Substring {
+  func firstRange(where predicate: (Character) throws -> Bool) rethrows -> Range<Self.Index>? {
+    guard let start = try self.firstIndex(where: predicate) else {
+      return nil
+    }
+    var idx = start
+    repeat {
+      idx = self.index(after: idx)
+    } while try idx != self.endIndex && predicate(self[idx])
+    return start..<idx
+  }
+}

Sources/apk/Common/ApkVersionSpecification.swift

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+
+enum ApkVersionSpecification: Equatable {
+  case any
+  case constraint(op: Operator, version: String)
+  case conflict
+}
+
+extension ApkVersionSpecification: CustomStringConvertible {
+  var description: String {
+    switch self {
+    case .any: ""
+    case .conflict: "!"
+    case .constraint(let op, let version): "\(op)\(version)"
+    }
+  }
+}
+
+extension ApkVersionSpecification {
+  enum Operator: Equatable {
+    case equals
+    case fuzzyEquals
+    case greater
+    case less
+    case greaterEqual
+    case lessEqual
+    case greaterFuzzy
+    case lessFuzzy
+  }
+}
+
+extension ApkVersionSpecification.Operator: CustomStringConvertible {
+  var description: String {
+    switch self {
+    //case .checksum:     "><"
+    case .lessEqual:    "<="
+    case .greaterEqual: ">="
+    case .lessFuzzy:    "<~"
+    case .greaterFuzzy: ">~"
+    case .equals:       "="
+    case .less:         "<"
+    case .greater:      ">"
+    case .fuzzyEquals:  "~"
+    }
+  }
+}