crossmate

main.swift (9388B)

---

 import Foundation
 
 /// Bumped whenever the manifest schema changes so the app can refuse or
 /// migrate manifests it does not understand.
 let manifestVersion = 1
 
 struct BundlemakeError: Error, CustomStringConvertible {
     let description: String
 }
 
 struct Options {
     var directory: String?
     var outputPath: String?
     var name: String?
     var bundleID: String?
 }
 
 /// The on-disk manifest: a lightweight index of a bundle's puzzles so the app
 /// can draw grid thumbnails without parsing every `.xd` file.
 struct Manifest: Encodable {
     let version: Int
     let bundleID: String
     let name: String
     let puzzles: [PuzzleEntry]
 }
 
 struct PuzzleEntry: Encodable {
     let id: String
     let title: String
     let publisher: String?
     let gridWidth: Int
     let gridHeight: Int
     /// Row-major block mask: `#` is a block, `.` is an open cell.
     let blockMask: String
 }
 
 func parseOptions(_ arguments: [String]) throws -> Options {
     var options = Options()
     var index = 1
 
     func requireValue(_ name: String) throws -> String {
         guard index + 1 < arguments.count else {
             throw BundlemakeError(description: "Missing value for \(name)")
         }
         index += 1
         return arguments[index]
     }
 
     while index < arguments.count {
         let arg = arguments[index]
         switch arg {
         case "-o", "--output":
             options.outputPath = try requireValue(arg)
         case "--name":
             options.name = try requireValue(arg)
         case "--bundle-id":
             options.bundleID = try requireValue(arg)
         case "-h", "--help":
             printUsage()
             exit(0)
         default:
             guard options.directory == nil else {
                 throw BundlemakeError(description: "Unexpected extra argument: \(arg)")
             }
             options.directory = arg
         }
         index += 1
     }
 
     guard options.directory != nil else {
         throw BundlemakeError(description: "Missing <bundle-directory>. See --help.")
     }
     return options
 }
 
 func printUsage() {
     print("""
     Usage: Bundlemake [options] <bundle-directory>
 
     Writes manifest.json for a puzzle bundle: a lightweight index of every
     .xd file's title, publisher, and grid block mask, so the app can render
     puzzle thumbnails without parsing each puzzle.
 
     Options:
       -o, --output PATH    Manifest output path. Default: <directory>/manifest.json
       --name NAME          Bundle display name. Default: the directory's name.
       --bundle-id ID       Bundle id. Required when the puzzles carry no
                            Bundle: field (e.g. dev fixtures).
       -h, --help           Show this help.
     """)
 }
 
 /// Splits an `.xd` source into its sections. Mirrors the app's XD parser
 /// (`XD.splitIntoSections`): a run of two or more blank lines, or a `## `
 /// header line, ends a section. Sections are metadata, grid, then clues.
 func splitIntoSections(_ source: String) -> [[String]] {
     let lines = source
         .split(separator: "\n", omittingEmptySubsequences: false)
         .map(String.init)
 
     var sections: [[String]] = []
     var current: [String] = []
     var blankRun = 0
 
     func flush() {
         while current.last?.trimmingCharacters(in: .whitespaces).isEmpty == true {
             current.removeLast()
         }
         while current.first?.trimmingCharacters(in: .whitespaces).isEmpty == true {
             current.removeFirst()
         }
         if !current.isEmpty {
             sections.append(current)
         }
         current = []
     }
 
     for rawLine in lines {
         let line = rawLine.trimmingCharacters(in: CharacterSet(charactersIn: "\r"))
         let trimmed = line.trimmingCharacters(in: .whitespaces)
 
         if trimmed.hasPrefix("## ") || trimmed == "##" {
             flush()
             blankRun = 0
             continue
         }
         if trimmed.isEmpty {
             blankRun += 1
             if blankRun >= 2 {
                 flush()
             }
             continue
         }
         blankRun = 0
         current.append(line)
     }
     flush()
     return sections
 }
 
 /// Reads `Key: Value` metadata lines, keeping the first value seen per key.
 func parseMetadata(_ lines: [String]) -> [String: String] {
     var entries: [String: String] = [:]
     for line in lines {
         guard let colon = line.firstIndex(of: ":") else { continue }
         let key = line[..<colon].trimmingCharacters(in: .whitespaces)
         let value = line[line.index(after: colon)...].trimmingCharacters(in: .whitespaces)
         if !key.isEmpty, entries[key] == nil {
             entries[key] = value
         }
     }
     return entries
 }
 
 struct Grid {
     let width: Int
     let height: Int
     let blockMask: String
 }
 
 /// Builds the block mask from a grid section. `#` and `_` are blocks (matching
 /// the app's `XD.gridCell`); every other character is an open cell.
 func parseGrid(_ lines: [String]) throws -> Grid {
     var rows: [String] = []
     var width: Int?
     for line in lines {
         let trimmed = line.trimmingCharacters(in: .whitespaces)
         if trimmed.isEmpty { continue }
         if let width, trimmed.count != width {
             throw BundlemakeError(description: "grid rows have inconsistent widths")
         }
         width = trimmed.count
         rows.append(trimmed)
     }
     guard let width, !rows.isEmpty else {
         throw BundlemakeError(description: "grid section is empty")
     }
 
     var mask = ""
     mask.reserveCapacity(width * rows.count)
     for row in rows {
         for character in row {
             mask.append(character == "#" || character == "_" ? "#" : ".")
         }
     }
     return Grid(width: width, height: rows.count, blockMask: mask)
 }
 
 struct ParsedPuzzle {
     let entry: PuzzleEntry
     let bundleID: String?
 }
 
 func parsePuzzle(at path: String) throws -> ParsedPuzzle {
     let id = URL(fileURLWithPath: path).deletingPathExtension().lastPathComponent
     let source = try String(contentsOfFile: path, encoding: .utf8)
     let sections = splitIntoSections(source)
     guard sections.count >= 2 else {
         throw BundlemakeError(description: "\(id): .xd source has no grid section")
     }
 
     let metadata = parseMetadata(sections[0])
     let grid: Grid
     do {
         grid = try parseGrid(sections[1])
     } catch let error as BundlemakeError {
         throw BundlemakeError(description: "\(id): \(error.description)")
     }
 
     func nonEmpty(_ key: String) -> String? {
         metadata[key].flatMap { $0.isEmpty ? nil : $0 }
     }
 
     let entry = PuzzleEntry(
         id: id,
         title: nonEmpty("Title") ?? id,
         publisher: nonEmpty("Publisher"),
         gridWidth: grid.width,
         gridHeight: grid.height,
         blockMask: grid.blockMask
     )
     return ParsedPuzzle(entry: entry, bundleID: nonEmpty("Bundle"))
 }
 
 func run() throws {
     let options = try parseOptions(CommandLine.arguments)
     let directory = options.directory!
     let fileManager = FileManager.default
 
     var isDirectory: ObjCBool = false
     guard fileManager.fileExists(atPath: directory, isDirectory: &isDirectory),
           isDirectory.boolValue else {
         throw BundlemakeError(description: "Not a directory: \(directory)")
     }
 
     let directoryURL = URL(fileURLWithPath: directory)
     let xdPaths = try fileManager
         .contentsOfDirectory(at: directoryURL, includingPropertiesForKeys: nil)
         .filter { $0.pathExtension.lowercased() == "xd" }
         .map(\.path)
         .sorted()
     guard !xdPaths.isEmpty else {
         throw BundlemakeError(description: "No .xd puzzles found in \(directory)")
     }
 
     let parsed = try xdPaths.map { try parsePuzzle(at: $0) }
 
     // Resolve the bundle id. Puzzles normally declare a `Bundle:` field, and
     // every puzzle in a bundle must agree on it. Dirs whose puzzles carry no
     // such field (dev fixtures) need an explicit --bundle-id instead.
     let declaredIDs = Set(parsed.compactMap(\.bundleID))
     guard declaredIDs.count <= 1 else {
         let listed = declaredIDs.sorted().joined(separator: ", ")
         throw BundlemakeError(description: "Puzzles disagree on their Bundle: id (\(listed))")
     }
     if let declared = declaredIDs.first,
        let override = options.bundleID,
        declared != override {
         throw BundlemakeError(
             description: "--bundle-id \(override) contradicts the Bundle: \(declared) in the puzzles")
     }
     guard let bundleID = options.bundleID ?? declaredIDs.first else {
         throw BundlemakeError(
             description: "No Bundle: id in \(directory); pass --bundle-id to name the bundle")
     }
 
     let manifest = Manifest(
         version: manifestVersion,
         bundleID: bundleID,
         name: options.name ?? directoryURL.lastPathComponent,
         puzzles: parsed.map(\.entry)
     )
 
     let encoder = JSONEncoder()
     encoder.outputFormatting = [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes]
     var data = try encoder.encode(manifest)
     data.append(0x0A)
 
     let outputURL = options.outputPath.map { URL(fileURLWithPath: $0) }
         ?? directoryURL.appendingPathComponent("manifest.json")
     try data.write(to: outputURL)
 
     fputs("Wrote \(outputURL.path): \(manifest.puzzles.count) puzzle(s) in bundle \"\(bundleID)\".\n", stderr)
 }
 
 do {
     try run()
 } catch {
     fputs("Bundlemake: \(error)\n", stderr)
     exit(1)
 }