feat: Build order

Author: oschrenk

Sources/Cli/SharedOptions.swift

@@ -69,9 +69,9 @@ struct SharedOptions: ParsableArguments {
 
   @Option(help: ArgumentHelp(
     "Sort parameter(s) <s>." +
-      "Available: [start]",
+      "Available: []",
     valueName: "s"
-  )) var sortParameters: [Field] = [.start]
+  )) var sortParameters: [Order] = []
 
   @Flag(help: ArgumentHelp(
     "Print debug statements"

Sources/Model/Object.swift

@@ -5,6 +5,7 @@ enum Object {
     case notFound
   }
 
+  @discardableResult
   static func valueForKeyPath(_ object: Any, _ keyPath: String) throws -> Any? {
     let keys = keyPath.split(separator: ".").map { String($0) }
 

Sources/Model/Sorting.swift

@@ -1,34 +1,36 @@
 import ArgumentParser
 import Foundation
 
-class Order {
-  let field: Field
+final class Order: ArgumentParser.ExpressibleByArgument {
+  let field: String
   let direction: Direction
 
-  init(field: Field, direction: Direction) {
-    self.field = field
-    self.direction = direction
+  public init?(argument: String) {
+    let o = Order.parse(s: argument.lowercased())
+    if o != nil {
+      field = o!.field
+      direction = o!.direction
+    } else {
+      return nil
+    }
   }
 
-  func sort(events: [Event]) -> [Event] {
-    if field == .start {
-      if direction == .asc {
-      } else {}
-    }
-    return events
+  init(field: String, direction: Direction) {
+    self.field = field
+    self.direction = direction
   }
 
   static func parse(s: String) -> Order? {
     let ss: [String] = s.split(separator: ":").map { String($0) }
     switch ss.count {
     // found a string candidate for field only
     case 1:
-      return parseField(ss[0]).map {
+      return parseField(s: ss[0]).map {
         Order(field: $0, direction: Direction.asc)
       }
     // found a string candidates for field and direction
     case 2:
-      switch (parseField(ss[0]), Direction(rawValue: ss[1])) {
+      switch (parseField(s: ss[0]), Direction(rawValue: ss[1])) {
       case let (.some(f), .some(d)):
         return Order(field: f, direction: d)
       default:
@@ -39,13 +41,31 @@ class Order {
     }
   }
 
-  private static func parseField(_: String) -> Field? {
-    nil
-  }
-}
+  private static let event =
+    Event(
+      id: UUID().uuidString,
+      calendar: PlanCalendar.Unknown,
+      title: Title(text: "empty"),
+      schedule: Schedule(
+        now: Date(),
+        startDate: Date(),
+        endDate: Date(),
+        allDay: false
+      ),
+      location: "",
+      meeting: Meeting(organizer: "", attendees: []),
+      services: [:],
+      tags: []
+    )
 
-enum Field: String, ExpressibleByArgument {
-  case start
+  private static func parseField(s: String) -> String? {
+    do {
+      try Object.valueForKeyPath(event, s)
+      return s
+    } catch {
+      return nil
+    }
+  }
 }
 
 enum Direction: String, ExpressibleByArgument {