Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 kua-agent
|
3dfb703834 |
@@ -1,209 +0,0 @@
|
||||
import AppKit
|
||||
import CoreGraphics
|
||||
import CoreText
|
||||
import Foundation
|
||||
import ImageIO
|
||||
import os
|
||||
|
||||
private let pdfLog = Logger(subsystem: "ai.flowmaster.shotdeck", category: "PDF")
|
||||
|
||||
public struct PDFComposer: Sendable {
|
||||
public init() {}
|
||||
|
||||
@discardableResult
|
||||
public func compose(
|
||||
session: CaptureSession,
|
||||
imageURL: (Capture) -> URL,
|
||||
title: String,
|
||||
to outputURL: URL
|
||||
) throws -> Int {
|
||||
if session.isEmpty {
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: "session has no captures")
|
||||
}
|
||||
|
||||
var loaded: [(Capture, CGImage)] = []
|
||||
loaded.reserveCapacity(session.captures.count)
|
||||
for capture in session.captures {
|
||||
let url = imageURL(capture)
|
||||
if let image = Self.loadCGImage(from: url) {
|
||||
loaded.append((capture, image))
|
||||
} else {
|
||||
pdfLog.error(
|
||||
"skipping capture \(capture.id.uuidString, privacy: .public) seq \(capture.sequence, privacy: .public): image unreadable at \(url.path, privacy: .public)"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
guard !loaded.isEmpty else {
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: "no readable images in session")
|
||||
}
|
||||
|
||||
let pageCount = loaded.count
|
||||
let tmpURL = outputURL
|
||||
.deletingLastPathComponent()
|
||||
.appendingPathComponent(".tmp-\(UUID().uuidString)-\(outputURL.lastPathComponent)")
|
||||
|
||||
do {
|
||||
try Self.writePDF(
|
||||
loaded: loaded,
|
||||
pageCount: pageCount,
|
||||
title: title,
|
||||
sessionID: session.id,
|
||||
to: tmpURL
|
||||
)
|
||||
|
||||
let handle = try FileHandle(forWritingTo: tmpURL)
|
||||
try handle.synchronize()
|
||||
try handle.close()
|
||||
|
||||
if FileManager.default.fileExists(atPath: outputURL.path) {
|
||||
try FileManager.default.removeItem(at: outputURL)
|
||||
}
|
||||
try FileManager.default.moveItem(at: tmpURL, to: outputURL)
|
||||
return pageCount
|
||||
} catch {
|
||||
try? FileManager.default.removeItem(at: tmpURL)
|
||||
if let shotdeck = error as? ShotdeckError {
|
||||
throw shotdeck
|
||||
}
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: error.localizedDescription)
|
||||
}
|
||||
}
|
||||
|
||||
public static func fileName(for session: CaptureSession) -> String {
|
||||
"Shotdeck-\(DubaiTime.fileStamp(session.createdAt)).pdf"
|
||||
}
|
||||
|
||||
private static func writePDF(
|
||||
loaded: [(Capture, CGImage)],
|
||||
pageCount: Int,
|
||||
title: String,
|
||||
sessionID: UUID,
|
||||
to tmpURL: URL
|
||||
) throws {
|
||||
guard let consumer = CGDataConsumer(url: tmpURL as CFURL) else {
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: "cannot open output location")
|
||||
}
|
||||
|
||||
let auxiliaryInfo: [String: Any] = [
|
||||
kCGPDFContextCreator as String: "Shotdeck",
|
||||
kCGPDFContextTitle as String: title,
|
||||
kCGPDFContextSubject as String: sessionID.uuidString.lowercased(),
|
||||
]
|
||||
|
||||
guard let context = CGContext(
|
||||
consumer: consumer,
|
||||
mediaBox: nil,
|
||||
auxiliaryInfo as CFDictionary
|
||||
) else {
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: "cannot open output location")
|
||||
}
|
||||
|
||||
let lightGrey = CGColor(gray: 0.75, alpha: 1)
|
||||
let black = CGColor(gray: 0, alpha: 1)
|
||||
let timestampColor = CGColor(gray: 0.45, alpha: 1)
|
||||
|
||||
for pageIndex in 1...pageCount {
|
||||
let (capture, cgImage) = loaded[pageIndex - 1]
|
||||
let layout = PageLayout(capture: capture, pageIndex: pageIndex, pageCount: pageCount)
|
||||
|
||||
context.beginPDFPage(Self.pageInfo(mediaBox: layout.pageRect))
|
||||
|
||||
context.draw(cgImage, in: layout.imageRect)
|
||||
|
||||
context.setStrokeColor(lightGrey)
|
||||
context.setLineWidth(0.5)
|
||||
context.move(to: CGPoint(x: layout.headerRect.minX, y: layout.headerRect.minY))
|
||||
context.addLine(to: CGPoint(x: layout.headerRect.maxX, y: layout.headerRect.minY))
|
||||
context.strokePath()
|
||||
|
||||
drawText(
|
||||
layout.pageNumberText,
|
||||
font: layout.pageNumberFont,
|
||||
color: black,
|
||||
at: layout.pageNumberOrigin,
|
||||
in: context
|
||||
)
|
||||
drawText(
|
||||
layout.timestampText,
|
||||
font: layout.timestampFont,
|
||||
color: timestampColor,
|
||||
at: layout.timestampOrigin,
|
||||
in: context
|
||||
)
|
||||
drawText(
|
||||
"PASS",
|
||||
font: layout.tickLabelFont,
|
||||
color: black,
|
||||
at: layout.passLabelOrigin,
|
||||
in: context
|
||||
)
|
||||
drawText(
|
||||
"FAIL",
|
||||
font: layout.tickLabelFont,
|
||||
color: black,
|
||||
at: layout.failLabelOrigin,
|
||||
in: context
|
||||
)
|
||||
|
||||
strokeTickBox(layout.passTickBox, in: context, color: black)
|
||||
strokeTickBox(layout.failTickBox, in: context, color: black)
|
||||
|
||||
context.endPDFPage()
|
||||
}
|
||||
|
||||
context.closePDF()
|
||||
}
|
||||
|
||||
private static func pageInfo(mediaBox: CGRect) -> CFDictionary {
|
||||
var box = mediaBox
|
||||
let data = Data(bytes: &box, count: MemoryLayout<CGRect>.size)
|
||||
return [kCGPDFContextMediaBox as String: data] as CFDictionary
|
||||
}
|
||||
|
||||
private static func drawText(
|
||||
_ string: String,
|
||||
font: NSFont,
|
||||
color: CGColor,
|
||||
at origin: CGPoint,
|
||||
in context: CGContext
|
||||
) {
|
||||
let attributes: [CFString: Any] = [
|
||||
kCTFontAttributeName: font,
|
||||
kCTForegroundColorAttributeName: color,
|
||||
]
|
||||
guard let attributed = CFAttributedStringCreate(
|
||||
nil,
|
||||
string as CFString,
|
||||
attributes as CFDictionary
|
||||
) else {
|
||||
return
|
||||
}
|
||||
let line = CTLineCreateWithAttributedString(attributed)
|
||||
context.textMatrix = .identity
|
||||
context.textPosition = origin
|
||||
CTLineDraw(line, context)
|
||||
}
|
||||
|
||||
private static func strokeTickBox(_ box: CGRect, in context: CGContext, color: CGColor) {
|
||||
let path = CGPath(
|
||||
roundedRect: box,
|
||||
cornerWidth: 2,
|
||||
cornerHeight: 2,
|
||||
transform: nil
|
||||
)
|
||||
context.addPath(path)
|
||||
context.setStrokeColor(color)
|
||||
context.setLineWidth(1.0)
|
||||
context.strokePath()
|
||||
}
|
||||
|
||||
private static func loadCGImage(from url: URL) -> CGImage? {
|
||||
guard let source = CGImageSourceCreateWithURL(url as CFURL, nil),
|
||||
CGImageSourceGetCount(source) > 0
|
||||
else {
|
||||
return nil
|
||||
}
|
||||
return CGImageSourceCreateImageAtIndex(source, 0, nil)
|
||||
}
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
import AppKit
|
||||
import CoreGraphics
|
||||
import CoreText
|
||||
import Foundation
|
||||
|
||||
public struct PageLayout: Sendable, Equatable {
|
||||
public let isLandscape: Bool
|
||||
public let pageRect: CGRect
|
||||
public let headerRect: CGRect
|
||||
public let imageBoxRect: CGRect
|
||||
public let imageRect: CGRect
|
||||
|
||||
public let pageNumberText: String
|
||||
public let pageNumberOrigin: CGPoint
|
||||
public let timestampText: String
|
||||
public let timestampOrigin: CGPoint
|
||||
|
||||
public let passLabelOrigin: CGPoint
|
||||
public let failLabelOrigin: CGPoint
|
||||
public let passTickBox: CGRect
|
||||
public let failTickBox: CGRect
|
||||
|
||||
/// Constructed at access time so `PageLayout` stays Sendable under Swift 6
|
||||
/// (`NSFont` is not Sendable). Same `NSFont.systemFont` values used for measurement.
|
||||
public var pageNumberFont: NSFont { NSFont.systemFont(ofSize: 9, weight: .semibold) }
|
||||
public var timestampFont: NSFont { NSFont.systemFont(ofSize: 9, weight: .regular) }
|
||||
public var tickLabelFont: NSFont { NSFont.systemFont(ofSize: 8, weight: .semibold) }
|
||||
|
||||
private static let marginAll: CGFloat = 18
|
||||
private static let headerHeight: CGFloat = 26
|
||||
private static let headerImageGap: CGFloat = 10
|
||||
private static let tickBoxSize: CGFloat = 13
|
||||
private static let tickGroupGap: CGFloat = 8
|
||||
private static let portraitPage = CGSize(width: 595, height: 842)
|
||||
private static let landscapePage = CGSize(width: 842, height: 595)
|
||||
|
||||
/// `pageIndex` and `pageCount` are 1-based / total, over ACTUALLY-WRITTEN pages
|
||||
/// (see SPEC decision D-D), not `capture.sequence` / `session.captures.count`.
|
||||
public init(capture: Capture, pageIndex: Int, pageCount: Int) {
|
||||
let pageNumberFont = NSFont.systemFont(ofSize: 9, weight: .semibold)
|
||||
let timestampFont = NSFont.systemFont(ofSize: 9, weight: .regular)
|
||||
let tickLabelFont = NSFont.systemFont(ofSize: 8, weight: .semibold)
|
||||
|
||||
isLandscape = capture.isLandscape
|
||||
pageRect = CGRect(origin: .zero, size: isLandscape ? Self.landscapePage : Self.portraitPage)
|
||||
let W = pageRect.width
|
||||
let H = pageRect.height
|
||||
|
||||
let contentMinX = Self.marginAll
|
||||
let contentMaxX = W - Self.marginAll
|
||||
let contentMinY = Self.marginAll
|
||||
let contentMaxY = H - Self.marginAll
|
||||
let contentWidth = contentMaxX - contentMinX
|
||||
|
||||
headerRect = CGRect(
|
||||
x: contentMinX,
|
||||
y: contentMaxY - Self.headerHeight,
|
||||
width: contentWidth,
|
||||
height: Self.headerHeight
|
||||
)
|
||||
|
||||
imageBoxRect = CGRect(
|
||||
x: contentMinX,
|
||||
y: contentMinY,
|
||||
width: contentWidth,
|
||||
height: headerRect.minY - Self.headerImageGap - contentMinY
|
||||
)
|
||||
|
||||
let pointSize = CGSize(
|
||||
width: CGFloat(capture.pixelWidth) / capture.scale,
|
||||
height: CGFloat(capture.pixelHeight) / capture.scale
|
||||
)
|
||||
let fitScale = min(
|
||||
imageBoxRect.width / pointSize.width,
|
||||
imageBoxRect.height / pointSize.height,
|
||||
1.0
|
||||
)
|
||||
let drawnSize = CGSize(
|
||||
width: pointSize.width * fitScale,
|
||||
height: pointSize.height * fitScale
|
||||
)
|
||||
imageRect = CGRect(
|
||||
x: imageBoxRect.midX - drawnSize.width / 2,
|
||||
y: imageBoxRect.midY - drawnSize.height / 2,
|
||||
width: drawnSize.width,
|
||||
height: drawnSize.height
|
||||
)
|
||||
|
||||
let metricsFont = timestampFont as CTFont
|
||||
let ascent = CTFontGetAscent(metricsFont)
|
||||
let descent = CTFontGetDescent(metricsFont)
|
||||
let baselineY = headerRect.minY + (headerRect.height - (ascent + descent)) / 2 + descent
|
||||
|
||||
pageNumberText = "\(pageIndex) / \(pageCount)"
|
||||
pageNumberOrigin = CGPoint(x: headerRect.minX, y: baselineY)
|
||||
|
||||
timestampText = DubaiTime.stamp(capture.capturedAt)
|
||||
let pageNumberWidth = Self.measuredWidth(pageNumberText, font: pageNumberFont)
|
||||
timestampOrigin = CGPoint(x: headerRect.minX + pageNumberWidth + 10, y: baselineY)
|
||||
|
||||
let groupRightX = headerRect.maxX
|
||||
let failBoxMinX = groupRightX - Self.tickBoxSize
|
||||
let tickBoxY = headerRect.midY - Self.tickBoxSize / 2
|
||||
failTickBox = CGRect(
|
||||
x: failBoxMinX,
|
||||
y: tickBoxY,
|
||||
width: Self.tickBoxSize,
|
||||
height: Self.tickBoxSize
|
||||
)
|
||||
|
||||
let failLabelWidth = Self.measuredWidth("FAIL", font: tickLabelFont)
|
||||
let failLabelMaxX = failTickBox.minX - Self.tickGroupGap
|
||||
failLabelOrigin = CGPoint(x: failLabelMaxX - failLabelWidth, y: baselineY)
|
||||
|
||||
let passBoxMaxX = failLabelOrigin.x - Self.tickGroupGap
|
||||
passTickBox = CGRect(
|
||||
x: passBoxMaxX - Self.tickBoxSize,
|
||||
y: tickBoxY,
|
||||
width: Self.tickBoxSize,
|
||||
height: Self.tickBoxSize
|
||||
)
|
||||
|
||||
let passLabelWidth = Self.measuredWidth("PASS", font: tickLabelFont)
|
||||
let passLabelMaxX = passTickBox.minX - Self.tickGroupGap
|
||||
passLabelOrigin = CGPoint(x: passLabelMaxX - passLabelWidth, y: baselineY)
|
||||
}
|
||||
|
||||
public static func == (lhs: PageLayout, rhs: PageLayout) -> Bool {
|
||||
lhs.isLandscape == rhs.isLandscape
|
||||
&& lhs.pageRect == rhs.pageRect
|
||||
&& lhs.headerRect == rhs.headerRect
|
||||
&& lhs.imageBoxRect == rhs.imageBoxRect
|
||||
&& lhs.imageRect == rhs.imageRect
|
||||
&& lhs.pageNumberText == rhs.pageNumberText
|
||||
&& lhs.pageNumberOrigin == rhs.pageNumberOrigin
|
||||
&& lhs.timestampText == rhs.timestampText
|
||||
&& lhs.timestampOrigin == rhs.timestampOrigin
|
||||
&& lhs.passLabelOrigin == rhs.passLabelOrigin
|
||||
&& lhs.failLabelOrigin == rhs.failLabelOrigin
|
||||
&& lhs.passTickBox == rhs.passTickBox
|
||||
&& lhs.failTickBox == rhs.failTickBox
|
||||
}
|
||||
|
||||
private static func measuredWidth(_ text: String, font: NSFont) -> CGFloat {
|
||||
let attributed = NSAttributedString(string: text, attributes: [.font: font])
|
||||
let line = CTLineCreateWithAttributedString(attributed)
|
||||
return CGFloat(CTLineGetTypographicBounds(line, nil, nil, nil))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
import Foundation
|
||||
import PDFKit
|
||||
|
||||
public struct ReturnedDocument: Codable, Sendable, Identifiable, Equatable {
|
||||
public var id: URL { fileURL }
|
||||
public let fileURL: URL
|
||||
/// Session UUID recovered from the PDF's subject attribute, when present and valid.
|
||||
public let sessionID: UUID?
|
||||
public let pageCount: Int
|
||||
/// 1-based page numbers that carry at least one human mark, ascending, no duplicates.
|
||||
public let annotatedPages: [Int]
|
||||
public let detectedAt: Date
|
||||
public var isCommented: Bool { !annotatedPages.isEmpty }
|
||||
|
||||
public init(
|
||||
fileURL: URL,
|
||||
sessionID: UUID?,
|
||||
pageCount: Int,
|
||||
annotatedPages: [Int],
|
||||
detectedAt: Date
|
||||
) {
|
||||
self.fileURL = fileURL
|
||||
self.sessionID = sessionID
|
||||
self.pageCount = pageCount
|
||||
self.annotatedPages = annotatedPages
|
||||
self.detectedAt = detectedAt
|
||||
}
|
||||
}
|
||||
|
||||
public enum AnnotationInspector {
|
||||
private static let humanMarkTypes: Set<String> = [
|
||||
PDFAnnotationSubtype.ink.rawValue,
|
||||
PDFAnnotationSubtype.highlight.rawValue,
|
||||
PDFAnnotationSubtype.underline.rawValue,
|
||||
PDFAnnotationSubtype.strikeOut.rawValue,
|
||||
// PDFKit has no PDFAnnotationSubtype.squiggly member (unsupported renderer),
|
||||
// but Apple Markup still writes Adobe /Squiggly objects that we must count.
|
||||
PDFAnnotationSubtype(rawValue: "/Squiggly").rawValue,
|
||||
PDFAnnotationSubtype.freeText.rawValue,
|
||||
PDFAnnotationSubtype.square.rawValue,
|
||||
PDFAnnotationSubtype.circle.rawValue,
|
||||
PDFAnnotationSubtype.line.rawValue,
|
||||
PDFAnnotationSubtype.stamp.rawValue,
|
||||
PDFAnnotationSubtype.text.rawValue,
|
||||
]
|
||||
|
||||
// .link ignored: a PDF hyperlink is structural, not a human mark.
|
||||
// .popup ignored: it is always the companion of another annotation; counting it
|
||||
// would double-count a single human mark as two.
|
||||
// .widget ignored: a form field. Shotdeck's own PASS/FAIL boxes are page content
|
||||
// (drawn by WP-2), never PDFAnnotation objects — a widget seen here can only be
|
||||
// introduced by a third-party tool flattening/reopening the file, and is not a
|
||||
// human mark either way.
|
||||
|
||||
/// PDFKit's `PDFAnnotation.type` may omit the leading slash that
|
||||
/// `PDFAnnotationSubtype.rawValue` includes; compare against the slash form.
|
||||
private static func pdfTypeName(_ type: String) -> String {
|
||||
type.hasPrefix("/") ? type : "/" + type
|
||||
}
|
||||
|
||||
private static func isHumanMark(_ annotation: PDFAnnotation) -> Bool {
|
||||
guard let raw = annotation.type else { return false }
|
||||
let type = pdfTypeName(raw)
|
||||
guard humanMarkTypes.contains(type) else { return false }
|
||||
if type == PDFAnnotationSubtype.ink.rawValue {
|
||||
let b = annotation.bounds
|
||||
return b.width > 0 && b.height > 0 // zero-area ink = an undone stroke, not a mark
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
/// Opens the PDF at fileURL and reports which pages carry a genuine human mark.
|
||||
/// Throws ShotdeckError.manifestCorrupt(path: fileURL.path) if PDFDocument cannot open it.
|
||||
/// File modification date is never consulted; only persisted PDFAnnotation objects count.
|
||||
public static func inspect(fileURL: URL) throws -> ReturnedDocument {
|
||||
guard let document = PDFDocument(url: fileURL) else {
|
||||
throw ShotdeckError.manifestCorrupt(path: fileURL.path)
|
||||
}
|
||||
var annotatedPages: [Int] = []
|
||||
for index in 0..<document.pageCount {
|
||||
guard let page = document.page(at: index) else { continue }
|
||||
if page.annotations.contains(where: isHumanMark) {
|
||||
annotatedPages.append(index + 1) // 1-based
|
||||
}
|
||||
}
|
||||
var sessionID: UUID?
|
||||
if let subject = document.documentAttributes?[PDFDocumentAttribute.subjectAttribute] as? String {
|
||||
sessionID = UUID(uuidString: subject) // nil (not thrown) if it doesn't parse
|
||||
}
|
||||
return ReturnedDocument(
|
||||
fileURL: fileURL, sessionID: sessionID, pageCount: document.pageCount,
|
||||
annotatedPages: annotatedPages, detectedAt: Date()
|
||||
)
|
||||
}
|
||||
|
||||
/// True when this PDF was produced by Shotdeck. Creator attribute is authoritative;
|
||||
/// the filename fallback applies ONLY when the creator attribute is absent.
|
||||
public static func isShotdeckDocument(_ document: PDFDocument) -> Bool {
|
||||
if let creator = document.documentAttributes?[PDFDocumentAttribute.creatorAttribute] as? String {
|
||||
return creator == "Shotdeck" // present creator is authoritative, full stop
|
||||
}
|
||||
// Creator ABSENT (some apps rewrite metadata on save) -> filename fallback only here.
|
||||
guard let name = document.documentURL?.lastPathComponent else { return false }
|
||||
// .lastPathComponent on a file URL is already percent-decoded; do not use .absoluteString.
|
||||
return name.wholeMatch(of: /^Shotdeck-\d{8}-\d{6}( \d+)?\.pdf$/) != nil
|
||||
// Case-sensitive by construction (Swift Regex literals are case-sensitive by default).
|
||||
// The optional "( \d+)?" is macOS's duplicate-name suffix AirDrop adds when a file of
|
||||
// the same name already exists in the watch folder — the normal case for a return.
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
import Foundation
|
||||
|
||||
public actor ReturnLedger {
|
||||
private let fileURL: URL
|
||||
private var entries: [URL: ReturnedDocument]
|
||||
|
||||
/// Loads `returns.json` under paths.root if it exists; starts empty otherwise.
|
||||
/// A file that cannot be decoded is renamed (never deleted) and the ledger starts empty.
|
||||
public init(paths: AppSupportPaths) throws {
|
||||
self.fileURL = paths.root.appendingPathComponent("returns.json")
|
||||
if FileManager.default.fileExists(atPath: fileURL.path) {
|
||||
let data = try Data(contentsOf: fileURL)
|
||||
do {
|
||||
let decoded = try JSONDecoder().decode([ReturnedDocument].self, from: data)
|
||||
entries = Dictionary(decoded.map { ($0.fileURL, $0) }, uniquingKeysWith: { _, new in new })
|
||||
} catch {
|
||||
let stamp = DubaiTime.fileStamp(Date())
|
||||
let corruptURL = fileURL.deletingLastPathComponent()
|
||||
.appendingPathComponent("returns.json.corrupt-\(stamp)")
|
||||
try FileManager.default.moveItem(at: fileURL, to: corruptURL)
|
||||
Log.returns.error(
|
||||
"returns.json could not be decoded; moved to \(corruptURL.path, privacy: .public): \(error.localizedDescription, privacy: .public)"
|
||||
)
|
||||
entries = [:]
|
||||
}
|
||||
} else {
|
||||
entries = [:]
|
||||
}
|
||||
}
|
||||
|
||||
/// Upserts by fileURL — recording the same URL again replaces the prior entry
|
||||
/// (the most recently recorded call wins, regardless of its detectedAt value).
|
||||
public func record(_ document: ReturnedDocument) throws {
|
||||
entries[document.fileURL] = document
|
||||
try persist()
|
||||
}
|
||||
|
||||
/// Every recorded return, newest detectedAt first.
|
||||
public func all() throws -> [ReturnedDocument] {
|
||||
entries.values.sorted { $0.detectedAt > $1.detectedAt }
|
||||
}
|
||||
|
||||
/// Commented returns (isCommented == true), newest detectedAt first.
|
||||
public func commented() throws -> [ReturnedDocument] {
|
||||
try all().filter(\.isCommented)
|
||||
}
|
||||
|
||||
/// Absolute POSIX paths of commented returns, newest first, one per line, no
|
||||
/// trailing newline. Throws ShotdeckError.noCommentedReturns when commented() is empty.
|
||||
public func clipboardText() throws -> String {
|
||||
let paths = try commented().map { $0.fileURL.path }
|
||||
guard !paths.isEmpty else { throw ShotdeckError.noCommentedReturns }
|
||||
return paths.joined(separator: "\n")
|
||||
}
|
||||
|
||||
private func persist() throws {
|
||||
let data = try JSONEncoder().encode(Array(entries.values))
|
||||
try AtomicFile.write(data, to: fileURL)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,412 @@
|
||||
import AppKit
|
||||
import Foundation
|
||||
import PDFKit
|
||||
import Testing
|
||||
import ShotdeckCore
|
||||
|
||||
private let pageBounds = CGRect(x: 0, y: 0, width: 600, height: 800)
|
||||
|
||||
private func makeAnnotation(
|
||||
_ subtype: PDFAnnotationSubtype,
|
||||
bounds: CGRect = CGRect(x: 100, y: 100, width: 80, height: 40),
|
||||
contents: String? = nil
|
||||
) -> PDFAnnotation {
|
||||
let annotation = PDFAnnotation(
|
||||
bounds: bounds,
|
||||
forType: subtype,
|
||||
withProperties: nil
|
||||
)
|
||||
annotation.contents = contents
|
||||
return annotation
|
||||
}
|
||||
|
||||
private func makePDF(
|
||||
at url: URL,
|
||||
pageCount: Int,
|
||||
creator: String? = "Shotdeck",
|
||||
subject: String? = nil,
|
||||
annotations: [(page: Int, annotation: PDFAnnotation)] = []
|
||||
) throws {
|
||||
let document = PDFDocument()
|
||||
for index in 0..<pageCount {
|
||||
let page = PDFPage()
|
||||
page.setBounds(pageBounds, for: .mediaBox)
|
||||
document.insert(page, at: index)
|
||||
}
|
||||
|
||||
var attributes = [PDFDocumentAttribute: Any]()
|
||||
if let creator { attributes[.creatorAttribute] = creator }
|
||||
if let subject { attributes[.subjectAttribute] = subject }
|
||||
document.documentAttributes = attributes
|
||||
|
||||
for item in annotations {
|
||||
guard let page = document.page(at: item.page) else {
|
||||
throw NSError(domain: "WP5Test", code: 1)
|
||||
}
|
||||
page.addAnnotation(item.annotation)
|
||||
}
|
||||
|
||||
guard document.write(to: url) else {
|
||||
throw NSError(domain: "WP5Test", code: 2)
|
||||
}
|
||||
}
|
||||
|
||||
private func makeCasePaths() throws -> (paths: AppSupportPaths, cleanup: URL) {
|
||||
let cleanup = FileManager.default.temporaryDirectory
|
||||
.appendingPathComponent("shotdeck-wp5a-\(UUID().uuidString)", isDirectory: true)
|
||||
let paths = try AppSupportPaths(
|
||||
root: cleanup.appendingPathComponent("root", isDirectory: true),
|
||||
outbox: cleanup.appendingPathComponent("outbox", isDirectory: true),
|
||||
watchFolder: cleanup.appendingPathComponent("watch", isDirectory: true)
|
||||
)
|
||||
return (paths, cleanup)
|
||||
}
|
||||
|
||||
@Test("I-1 Untouched PDF is clean")
|
||||
func i1_untouchedPDFIsClean() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134200.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 3,
|
||||
creator: "Shotdeck",
|
||||
subject: "11111111-1111-1111-1111-111111111111"
|
||||
)
|
||||
|
||||
var calendar = Calendar(identifier: .gregorian)
|
||||
calendar.timeZone = try #require(TimeZone(identifier: "Asia/Dubai"))
|
||||
let firstMTime = try #require(calendar.date(from: DateComponents(
|
||||
year: 2026, month: 8, day: 30, hour: 13, minute: 42, second: 0
|
||||
)))
|
||||
let secondMTime = try #require(calendar.date(from: DateComponents(
|
||||
year: 2026, month: 8, day: 30, hour: 13, minute: 43, second: 0
|
||||
)))
|
||||
try FileManager.default.setAttributes([.modificationDate: firstMTime], ofItemAtPath: pdfURL.path)
|
||||
try FileManager.default.setAttributes([.modificationDate: secondMTime], ofItemAtPath: pdfURL.path)
|
||||
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.fileURL == pdfURL)
|
||||
#expect(inspected.sessionID == UUID(uuidString: "11111111-1111-1111-1111-111111111111"))
|
||||
#expect(inspected.pageCount == 3)
|
||||
#expect(inspected.annotatedPages == [])
|
||||
#expect(inspected.isCommented == false)
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
try await ledger.record(inspected)
|
||||
let all = try await ledger.all()
|
||||
#expect(all.count == 1)
|
||||
#expect(all[0].fileURL == pdfURL)
|
||||
#expect(try await ledger.commented() == [])
|
||||
let clipboardError = try await #require(throws: ShotdeckError.self) {
|
||||
try await ledger.clipboardText()
|
||||
}
|
||||
guard case .noCommentedReturns = clipboardError else {
|
||||
Issue.record("expected noCommentedReturns, got \(clipboardError)")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
@Test("I-2 Ink is a mark")
|
||||
func i2_inkIsAMark() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134201.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 3,
|
||||
annotations: [(page: 1, annotation: makeAnnotation(
|
||||
.ink, bounds: CGRect(x: 120, y: 240, width: 140, height: 60)
|
||||
))]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.pageCount == 3)
|
||||
#expect(inspected.annotatedPages == [2])
|
||||
#expect(inspected.isCommented == true)
|
||||
}
|
||||
|
||||
@Test("I-3 Highlight is a mark")
|
||||
func i3_highlightIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.highlight,
|
||||
bounds: CGRect(x: 80, y: 500, width: 300, height: 24),
|
||||
fileName: "Shotdeck-20260830-134202.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-4 Underline is a mark")
|
||||
func i4_underlineIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.underline,
|
||||
bounds: CGRect(x: 90, y: 460, width: 280, height: 18),
|
||||
fileName: "Shotdeck-20260830-134203.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-5 Strike-out is a mark")
|
||||
func i5_strikeOutIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.strikeOut,
|
||||
bounds: CGRect(x: 90, y: 430, width: 280, height: 18),
|
||||
fileName: "Shotdeck-20260830-134204.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-6 Squiggly is a mark")
|
||||
func i6_squigglyIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
PDFAnnotationSubtype(rawValue: "/Squiggly"),
|
||||
bounds: CGRect(x: 90, y: 400, width: 280, height: 18),
|
||||
fileName: "Shotdeck-20260830-134205.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-7 Free-text is a mark")
|
||||
func i7_freeTextIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.freeText,
|
||||
bounds: CGRect(x: 140, y: 300, width: 220, height: 80),
|
||||
contents: "Typed review note",
|
||||
fileName: "Shotdeck-20260830-134206.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-8 Square is a mark")
|
||||
func i8_squareIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.square,
|
||||
bounds: CGRect(x: 160, y: 250, width: 100, height: 100),
|
||||
fileName: "Shotdeck-20260830-134207.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-9 Circle is a mark")
|
||||
func i9_circleIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.circle,
|
||||
bounds: CGRect(x: 280, y: 250, width: 100, height: 100),
|
||||
fileName: "Shotdeck-20260830-134208.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-10 Line is a mark")
|
||||
func i10_lineIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.line,
|
||||
bounds: CGRect(x: 100, y: 180, width: 320, height: 8),
|
||||
fileName: "Shotdeck-20260830-134209.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-11 Stamp is a mark")
|
||||
func i11_stampIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.stamp,
|
||||
bounds: CGRect(x: 180, y: 500, width: 120, height: 60),
|
||||
contents: "Approved",
|
||||
fileName: "Shotdeck-20260830-134210.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-12 Sticky text is a mark")
|
||||
func i12_stickyTextIsAMark() throws {
|
||||
try expectSinglePageMark(
|
||||
.text,
|
||||
bounds: CGRect(x: 420, y: 620, width: 28, height: 28),
|
||||
contents: "Look here",
|
||||
fileName: "Shotdeck-20260830-134211.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-13 Link alone is not a mark")
|
||||
func i13_linkAloneIsNotAMark() throws {
|
||||
try expectSinglePageIgnored(
|
||||
.link,
|
||||
bounds: CGRect(x: 80, y: 700, width: 160, height: 20),
|
||||
fileName: "Shotdeck-20260830-134212.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-14 Popup alone is not a mark")
|
||||
func i14_popupAloneIsNotAMark() throws {
|
||||
try expectSinglePageIgnored(
|
||||
.popup,
|
||||
bounds: CGRect(x: 450, y: 600, width: 100, height: 60),
|
||||
fileName: "Shotdeck-20260830-134213.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-15 Widget alone is not a mark")
|
||||
func i15_widgetAloneIsNotAMark() throws {
|
||||
try expectSinglePageIgnored(
|
||||
.widget,
|
||||
bounds: CGRect(x: 100, y: 100, width: 140, height: 32),
|
||||
fileName: "Shotdeck-20260830-134214.pdf"
|
||||
)
|
||||
}
|
||||
|
||||
@Test("I-16 Zero-area ink is not a mark")
|
||||
func i16_zeroAreaInkIsNotAMark() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134215.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 1,
|
||||
annotations: [(page: 0, annotation: makeAnnotation(
|
||||
.ink, bounds: CGRect(x: 240, y: 240, width: 0, height: 0)
|
||||
))]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.annotatedPages == [])
|
||||
#expect(inspected.isCommented == false)
|
||||
}
|
||||
|
||||
@Test("I-17 Ignored objects plus one real mark count once")
|
||||
func i17_ignoredObjectsPlusOneRealMarkCountOnce() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134216.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 3,
|
||||
annotations: [
|
||||
(page: 1, annotation: makeAnnotation(.link, bounds: CGRect(x: 20, y: 20, width: 40, height: 20))),
|
||||
(page: 1, annotation: makeAnnotation(.popup, bounds: CGRect(x: 70, y: 20, width: 40, height: 20))),
|
||||
(page: 1, annotation: makeAnnotation(.widget, bounds: CGRect(x: 120, y: 20, width: 40, height: 20))),
|
||||
(page: 1, annotation: makeAnnotation(.ink, bounds: CGRect(x: 200, y: 200, width: 120, height: 50))),
|
||||
]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.pageCount == 3)
|
||||
#expect(inspected.annotatedPages == [2])
|
||||
#expect(inspected.isCommented == true)
|
||||
}
|
||||
|
||||
@Test("I-18 Page numbers are 1-based and ascending")
|
||||
func i18_pageNumbersAre1BasedAndAscending() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134217.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 3,
|
||||
annotations: [
|
||||
(page: 0, annotation: makeAnnotation(.circle, bounds: CGRect(x: 260, y: 200, width: 70, height: 70))),
|
||||
(page: 1, annotation: makeAnnotation(.link, bounds: CGRect(x: 80, y: 700, width: 160, height: 20))),
|
||||
(page: 2, annotation: makeAnnotation(.ink, bounds: CGRect(x: 100, y: 100, width: 90, height: 40))),
|
||||
]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.pageCount == 3)
|
||||
#expect(inspected.annotatedPages == [1, 3])
|
||||
#expect(inspected.isCommented == true)
|
||||
}
|
||||
|
||||
@Test("I-19 Session UUID recovery and invalid-subject tolerance")
|
||||
func i19_sessionUUIDRecoveryAndInvalidSubjectTolerance() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let validURL = paths.watchFolder.appendingPathComponent("valid-subject.pdf")
|
||||
let invalidURL = paths.watchFolder.appendingPathComponent("invalid-subject.pdf")
|
||||
let missingURL = paths.watchFolder.appendingPathComponent("missing-subject.pdf")
|
||||
|
||||
try makePDF(
|
||||
at: validURL,
|
||||
pageCount: 1,
|
||||
creator: "Shotdeck",
|
||||
subject: "22222222-2222-2222-2222-222222222222"
|
||||
)
|
||||
try makePDF(
|
||||
at: invalidURL,
|
||||
pageCount: 1,
|
||||
creator: "Shotdeck",
|
||||
subject: "not-a-uuid"
|
||||
)
|
||||
try makePDF(
|
||||
at: missingURL,
|
||||
pageCount: 1,
|
||||
creator: "Shotdeck",
|
||||
subject: nil
|
||||
)
|
||||
|
||||
let valid = try AnnotationInspector.inspect(fileURL: validURL)
|
||||
#expect(valid.sessionID == UUID(uuidString: "22222222-2222-2222-2222-222222222222"))
|
||||
#expect(valid.pageCount == 1)
|
||||
#expect(valid.annotatedPages == [])
|
||||
#expect(valid.isCommented == false)
|
||||
|
||||
let invalid = try AnnotationInspector.inspect(fileURL: invalidURL)
|
||||
#expect(invalid.sessionID == nil)
|
||||
#expect(invalid.annotatedPages == [])
|
||||
#expect(invalid.isCommented == false)
|
||||
|
||||
let missing = try AnnotationInspector.inspect(fileURL: missingURL)
|
||||
#expect(missing.sessionID == nil)
|
||||
#expect(missing.annotatedPages == [])
|
||||
#expect(missing.isCommented == false)
|
||||
}
|
||||
|
||||
@Test("I-19b Present non-Shotdeck creator beats a matching filename")
|
||||
func i19b_presentNonShotdeckCreatorBeatsMatchingFilename() throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent("Shotdeck-20260830-134218.pdf")
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 1,
|
||||
creator: "Preview",
|
||||
annotations: [(page: 0, annotation: makeAnnotation(
|
||||
.ink, bounds: CGRect(x: 100, y: 100, width: 120, height: 50)
|
||||
))]
|
||||
)
|
||||
let reopened = try #require(PDFDocument(url: pdfURL))
|
||||
#expect(AnnotationInspector.isShotdeckDocument(reopened) == false)
|
||||
}
|
||||
|
||||
private func expectSinglePageMark(
|
||||
_ subtype: PDFAnnotationSubtype,
|
||||
bounds: CGRect,
|
||||
contents: String? = nil,
|
||||
fileName: String
|
||||
) throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent(fileName)
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 1,
|
||||
annotations: [(page: 0, annotation: makeAnnotation(subtype, bounds: bounds, contents: contents))]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.pageCount == 1)
|
||||
#expect(inspected.annotatedPages == [1])
|
||||
#expect(inspected.isCommented == true)
|
||||
}
|
||||
|
||||
private func expectSinglePageIgnored(
|
||||
_ subtype: PDFAnnotationSubtype,
|
||||
bounds: CGRect,
|
||||
fileName: String
|
||||
) throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let pdfURL = paths.watchFolder.appendingPathComponent(fileName)
|
||||
try makePDF(
|
||||
at: pdfURL,
|
||||
pageCount: 1,
|
||||
annotations: [(page: 0, annotation: makeAnnotation(subtype, bounds: bounds))]
|
||||
)
|
||||
let inspected = try AnnotationInspector.inspect(fileURL: pdfURL)
|
||||
#expect(inspected.annotatedPages == [])
|
||||
#expect(inspected.isCommented == false)
|
||||
}
|
||||
@@ -1,579 +0,0 @@
|
||||
import CoreGraphics
|
||||
import Foundation
|
||||
import ImageIO
|
||||
import PDFKit
|
||||
import ShotdeckCore
|
||||
import Testing
|
||||
import UniformTypeIdentifiers
|
||||
|
||||
enum TestFixtureError: Error { case cannotCreateBitmap, cannotCreatePNG, cannotFinalizePNG }
|
||||
|
||||
func writeSolidPNG(
|
||||
pixelWidth: Int,
|
||||
pixelHeight: Int,
|
||||
red: UInt8,
|
||||
green: UInt8,
|
||||
blue: UInt8,
|
||||
to url: URL
|
||||
) throws {
|
||||
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
||||
guard let context = CGContext(
|
||||
data: nil,
|
||||
width: pixelWidth,
|
||||
height: pixelHeight,
|
||||
bitsPerComponent: 8,
|
||||
bytesPerRow: pixelWidth * 4,
|
||||
space: colorSpace,
|
||||
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
|
||||
) else { throw TestFixtureError.cannotCreateBitmap }
|
||||
context.setFillColor(CGColor(
|
||||
red: CGFloat(red) / 255,
|
||||
green: CGFloat(green) / 255,
|
||||
blue: CGFloat(blue) / 255,
|
||||
alpha: 1
|
||||
))
|
||||
context.fill(CGRect(x: 0, y: 0, width: pixelWidth, height: pixelHeight))
|
||||
guard let image = context.makeImage(),
|
||||
let destination = CGImageDestinationCreateWithURL(
|
||||
url as CFURL,
|
||||
UTType.png.identifier as CFString,
|
||||
1,
|
||||
nil
|
||||
)
|
||||
else { throw TestFixtureError.cannotCreatePNG }
|
||||
CGImageDestinationAddImage(destination, image, nil)
|
||||
guard CGImageDestinationFinalize(destination) else { throw TestFixtureError.cannotFinalizePNG }
|
||||
}
|
||||
|
||||
private let fixtureDate = Date(timeIntervalSince1970: 1_777_482_180)
|
||||
|
||||
private func makeCapture(
|
||||
sequence: Int,
|
||||
pixelWidth: Int,
|
||||
pixelHeight: Int,
|
||||
scale: CGFloat = 1,
|
||||
capturedAt: Date = fixtureDate,
|
||||
id: UUID = UUID(),
|
||||
fileName: String? = nil
|
||||
) -> Capture {
|
||||
Capture(
|
||||
id: id,
|
||||
sequence: sequence,
|
||||
fileName: fileName ?? String(format: "%03d.png", sequence),
|
||||
pixelWidth: pixelWidth,
|
||||
pixelHeight: pixelHeight,
|
||||
scale: scale,
|
||||
capturedAt: capturedAt
|
||||
)
|
||||
}
|
||||
|
||||
private func makeSession(
|
||||
captures: [Capture],
|
||||
id: UUID = UUID(),
|
||||
createdAt: Date = fixtureDate
|
||||
) -> CaptureSession {
|
||||
CaptureSession(
|
||||
id: id,
|
||||
createdAt: createdAt,
|
||||
state: .open,
|
||||
captures: captures,
|
||||
pdfFileName: nil
|
||||
)
|
||||
}
|
||||
|
||||
private func makeScratchDirectory() throws -> URL {
|
||||
let url = FileManager.default.temporaryDirectory
|
||||
.appendingPathComponent("shotdeck-pdf-\(UUID().uuidString)", isDirectory: true)
|
||||
try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
|
||||
return url
|
||||
}
|
||||
|
||||
private func writePNG(
|
||||
for capture: Capture,
|
||||
red: UInt8,
|
||||
green: UInt8,
|
||||
blue: UInt8,
|
||||
in directory: URL
|
||||
) throws -> URL {
|
||||
let url = directory.appendingPathComponent(capture.fileName)
|
||||
try writeSolidPNG(
|
||||
pixelWidth: capture.pixelWidth,
|
||||
pixelHeight: capture.pixelHeight,
|
||||
red: red,
|
||||
green: green,
|
||||
blue: blue,
|
||||
to: url
|
||||
)
|
||||
return url
|
||||
}
|
||||
|
||||
private func imageURLMap(_ urls: [UUID: URL]) -> (Capture) -> URL {
|
||||
{ capture in
|
||||
urls[capture.id] ?? URL(fileURLWithPath: "/nonexistent/\(capture.id.uuidString).png")
|
||||
}
|
||||
}
|
||||
|
||||
private func openDocument(_ url: URL) throws -> PDFDocument {
|
||||
let document = try #require(PDFDocument(url: url))
|
||||
return document
|
||||
}
|
||||
|
||||
private func pdftoppm(pdf: URL, prefix: URL) throws {
|
||||
let process = Process()
|
||||
process.executableURL = URL(fileURLWithPath: "/opt/homebrew/bin/pdftoppm")
|
||||
process.arguments = ["-png", "-r", "110", pdf.path, prefix.path]
|
||||
let err = Pipe()
|
||||
process.standardError = err
|
||||
try process.run()
|
||||
process.waitUntilExit()
|
||||
guard process.terminationStatus == 0 else {
|
||||
let message = String(data: err.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
|
||||
throw ShotdeckError.pdfCompositionFailed(reason: "pdftoppm failed: \(message)")
|
||||
}
|
||||
}
|
||||
|
||||
private struct RGBABitmap {
|
||||
let width: Int
|
||||
let height: Int
|
||||
let bytesPerRow: Int
|
||||
let data: Data
|
||||
|
||||
func pixel(x: Int, y: Int) -> (UInt8, UInt8, UInt8)? {
|
||||
guard x >= 0, y >= 0, x < width, y < height else { return nil }
|
||||
let offset = y * bytesPerRow + x * 4
|
||||
guard offset + 2 < data.count else { return nil }
|
||||
return (data[offset], data[offset + 1], data[offset + 2])
|
||||
}
|
||||
|
||||
func containsNonWhite(x0: Int, y0: Int, x1: Int, y1: Int) -> Bool {
|
||||
let xStart = max(0, x0)
|
||||
let yStart = max(0, y0)
|
||||
let xEnd = min(width, x1)
|
||||
let yEnd = min(height, y1)
|
||||
guard xStart < xEnd, yStart < yEnd else { return false }
|
||||
for y in yStart..<yEnd {
|
||||
for x in xStart..<xEnd {
|
||||
if let (r, g, b) = pixel(x: x, y: y), r != 255 || g != 255 || b != 255 {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
static func loadPNG(at url: URL) throws -> RGBABitmap {
|
||||
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
||||
let source = try #require(CGImageSourceCreateWithURL(url as CFURL, nil))
|
||||
let image = try #require(CGImageSourceCreateImageAtIndex(source, 0, nil))
|
||||
let width = image.width
|
||||
let height = image.height
|
||||
let bytesPerRow = width * 4
|
||||
var data = Data(count: bytesPerRow * height)
|
||||
try data.withUnsafeMutableBytes { raw in
|
||||
guard let base = raw.baseAddress else {
|
||||
throw TestFixtureError.cannotCreateBitmap
|
||||
}
|
||||
guard let context = CGContext(
|
||||
data: base,
|
||||
width: width,
|
||||
height: height,
|
||||
bitsPerComponent: 8,
|
||||
bytesPerRow: bytesPerRow,
|
||||
space: colorSpace,
|
||||
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
|
||||
) else {
|
||||
throw TestFixtureError.cannotCreateBitmap
|
||||
}
|
||||
context.interpolationQuality = .none
|
||||
context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
|
||||
}
|
||||
return RGBABitmap(width: width, height: height, bytesPerRow: bytesPerRow, data: data)
|
||||
}
|
||||
}
|
||||
|
||||
private func pixelWindow(
|
||||
for rect: CGRect,
|
||||
pageHeightPt: CGFloat,
|
||||
scale k: CGFloat
|
||||
) -> (x0: Int, y0: Int, x1: Int, y1: Int) {
|
||||
let pixelX0 = Int(floor(rect.minX * k))
|
||||
let pixelX1 = Int(ceil(rect.maxX * k))
|
||||
let pixelY0 = Int(floor((pageHeightPt - rect.maxY) * k))
|
||||
let pixelY1 = Int(ceil((pageHeightPt - rect.minY) * k))
|
||||
return (pixelX0, pixelY0, pixelX1, pixelY1)
|
||||
}
|
||||
|
||||
@Test("Three-page basic compose")
|
||||
func threePageBasicCompose() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let c1 = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let c2 = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
|
||||
let c3 = makeCapture(sequence: 3, pixelWidth: 1200, pixelHeight: 800)
|
||||
let urls: [UUID: URL] = [
|
||||
c1.id: try writePNG(for: c1, red: 200, green: 20, blue: 20, in: directory),
|
||||
c2.id: try writePNG(for: c2, red: 20, green: 200, blue: 20, in: directory),
|
||||
c3.id: try writePNG(for: c3, red: 20, green: 20, blue: 200, in: directory),
|
||||
]
|
||||
let session = makeSession(captures: [c1, c2, c3])
|
||||
let output = directory.appendingPathComponent("three.pdf")
|
||||
let pageCount = try PDFComposer().compose(
|
||||
session: session,
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "Three page",
|
||||
to: output
|
||||
)
|
||||
#expect(pageCount == 3)
|
||||
let document = try openDocument(output)
|
||||
#expect(document.pageCount == 3)
|
||||
let p0 = try #require(document.page(at: 0))
|
||||
let p1 = try #require(document.page(at: 1))
|
||||
let p2 = try #require(document.page(at: 2))
|
||||
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
|
||||
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
#expect(p2.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
|
||||
}
|
||||
|
||||
@Test("Wide/tall page geometry exact")
|
||||
func wideTallPageGeometryExact() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let tall = makeCapture(sequence: 1, pixelWidth: 900, pixelHeight: 1600)
|
||||
let wideURL = try writePNG(for: wide, red: 10, green: 10, blue: 10, in: directory)
|
||||
let tallURL = try writePNG(for: tall, red: 10, green: 10, blue: 10, in: directory)
|
||||
|
||||
let wideOut = directory.appendingPathComponent("wide.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [wide]),
|
||||
imageURL: { _ in wideURL },
|
||||
title: "Wide",
|
||||
to: wideOut
|
||||
)
|
||||
let tallOut = directory.appendingPathComponent("tall.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [tall]),
|
||||
imageURL: { _ in tallURL },
|
||||
title: "Tall",
|
||||
to: tallOut
|
||||
)
|
||||
|
||||
let widePage = try #require(openDocument(wideOut).page(at: 0))
|
||||
let tallPage = try #require(openDocument(tallOut).page(at: 0))
|
||||
#expect(widePage.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
|
||||
#expect(tallPage.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
}
|
||||
|
||||
@Test("Square resolves to portrait (Capture.swift:39-42 isLandscape strict >)")
|
||||
func squareResolvesToPortrait() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let square = makeCapture(sequence: 1, pixelWidth: 1000, pixelHeight: 1000)
|
||||
let png = try writePNG(for: square, red: 80, green: 80, blue: 80, in: directory)
|
||||
let output = directory.appendingPathComponent("square.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [square]),
|
||||
imageURL: { _ in png },
|
||||
title: "Square",
|
||||
to: output
|
||||
)
|
||||
let page = try #require(openDocument(output).page(at: 0))
|
||||
#expect(page.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
}
|
||||
|
||||
@Test("Retina capture uses point size, not pixel size")
|
||||
func retinaCaptureUsesPointSize() throws {
|
||||
let capture = makeCapture(sequence: 1, pixelWidth: 2880, pixelHeight: 1620, scale: 2.0)
|
||||
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
|
||||
let expectedScale = min(806.0 / 1440.0, 523.0 / 810.0, 1.0)
|
||||
let expected = CGSize(width: 1440.0 * expectedScale, height: 810.0 * expectedScale)
|
||||
#expect(abs(layout.imageRect.width - expected.width) < 0.01)
|
||||
#expect(abs(layout.imageRect.height - expected.height) < 0.01)
|
||||
#expect(layout.imageRect.width < 2000)
|
||||
#expect(layout.isLandscape)
|
||||
}
|
||||
|
||||
@Test("Zero PDFAnnotation objects on every page")
|
||||
func zeroPDFAnnotationObjects() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let c1 = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 600)
|
||||
let c2 = makeCapture(sequence: 2, pixelWidth: 600, pixelHeight: 800)
|
||||
let c3 = makeCapture(sequence: 3, pixelWidth: 1000, pixelHeight: 1000)
|
||||
let urls: [UUID: URL] = [
|
||||
c1.id: try writePNG(for: c1, red: 30, green: 30, blue: 30, in: directory),
|
||||
c2.id: try writePNG(for: c2, red: 40, green: 40, blue: 40, in: directory),
|
||||
c3.id: try writePNG(for: c3, red: 50, green: 50, blue: 50, in: directory),
|
||||
]
|
||||
let output = directory.appendingPathComponent("no-annots.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [c1, c2, c3]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "No annotations",
|
||||
to: output
|
||||
)
|
||||
let document = try openDocument(output)
|
||||
#expect(document.pageCount == 3)
|
||||
for index in 0..<document.pageCount {
|
||||
let page = try #require(document.page(at: index))
|
||||
#expect(page.annotations.isEmpty)
|
||||
}
|
||||
}
|
||||
|
||||
@Test("Mixed orientations coexist, unnormalised")
|
||||
func mixedOrientationsCoexist() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let tall = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
|
||||
let square = makeCapture(sequence: 3, pixelWidth: 1000, pixelHeight: 1000)
|
||||
let urls: [UUID: URL] = [
|
||||
wide.id: try writePNG(for: wide, red: 90, green: 10, blue: 10, in: directory),
|
||||
tall.id: try writePNG(for: tall, red: 10, green: 90, blue: 10, in: directory),
|
||||
square.id: try writePNG(for: square, red: 10, green: 10, blue: 90, in: directory),
|
||||
]
|
||||
let output = directory.appendingPathComponent("mixed.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [wide, tall, square]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "Mixed",
|
||||
to: output
|
||||
)
|
||||
let document = try openDocument(output)
|
||||
#expect(document.pageCount == 3)
|
||||
let p0 = try #require(document.page(at: 0))
|
||||
let p1 = try #require(document.page(at: 1))
|
||||
let p2 = try #require(document.page(at: 2))
|
||||
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
|
||||
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
#expect(p2.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
}
|
||||
|
||||
@Test("No cover page, no before/after, exactly one page per capture")
|
||||
func noCoverPageExactlyOnePagePerCapture() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let c1 = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 500)
|
||||
let c2 = makeCapture(sequence: 2, pixelWidth: 500, pixelHeight: 800)
|
||||
let urls: [UUID: URL] = [
|
||||
c1.id: try writePNG(for: c1, red: 12, green: 12, blue: 12, in: directory),
|
||||
c2.id: try writePNG(for: c2, red: 22, green: 22, blue: 22, in: directory),
|
||||
]
|
||||
let output = directory.appendingPathComponent("two.pdf")
|
||||
let pageCount = try PDFComposer().compose(
|
||||
session: makeSession(captures: [c1, c2]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "Two",
|
||||
to: output
|
||||
)
|
||||
#expect(pageCount == 2)
|
||||
#expect(try openDocument(output).pageCount == 2)
|
||||
}
|
||||
|
||||
@Test("Small image is never upscaled")
|
||||
func smallImageIsNeverUpscaled() throws {
|
||||
let capture = makeCapture(sequence: 1, pixelWidth: 200, pixelHeight: 150)
|
||||
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
|
||||
#expect(layout.imageRect.size == CGSize(width: 200, height: 150))
|
||||
}
|
||||
|
||||
@Test("Empty session throws, produces nothing on disk")
|
||||
func emptySessionThrowsProducesNothing() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let output = directory.appendingPathComponent("empty.pdf")
|
||||
var threwCompositionFailed = false
|
||||
do {
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: []),
|
||||
imageURL: { _ in directory.appendingPathComponent("missing.png") },
|
||||
title: "Empty",
|
||||
to: output
|
||||
)
|
||||
} catch ShotdeckError.pdfCompositionFailed {
|
||||
threwCompositionFailed = true
|
||||
}
|
||||
#expect(threwCompositionFailed)
|
||||
#expect(!FileManager.default.fileExists(atPath: output.path))
|
||||
let leftover = try FileManager.default.contentsOfDirectory(atPath: directory.path)
|
||||
#expect(leftover.isEmpty)
|
||||
}
|
||||
|
||||
@Test("A missing PNG is skipped, page count drops, document still opens")
|
||||
func missingPNGIsSkipped() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let first = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let missing = makeCapture(sequence: 2, pixelWidth: 800, pixelHeight: 600)
|
||||
let third = makeCapture(sequence: 3, pixelWidth: 900, pixelHeight: 1600)
|
||||
let firstURL = try writePNG(for: first, red: 220, green: 10, blue: 10, in: directory)
|
||||
let thirdURL = try writePNG(for: third, red: 10, green: 10, blue: 220, in: directory)
|
||||
let missingURL = directory.appendingPathComponent("does-not-exist.png")
|
||||
let urls: [UUID: URL] = [
|
||||
first.id: firstURL,
|
||||
missing.id: missingURL,
|
||||
third.id: thirdURL,
|
||||
]
|
||||
let output = directory.appendingPathComponent("skip-missing.pdf")
|
||||
let pageCount = try PDFComposer().compose(
|
||||
session: makeSession(captures: [first, missing, third]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "Skip missing",
|
||||
to: output
|
||||
)
|
||||
#expect(pageCount == 2)
|
||||
let document = try openDocument(output)
|
||||
#expect(document.pageCount == 2)
|
||||
let p0 = try #require(document.page(at: 0))
|
||||
let p1 = try #require(document.page(at: 1))
|
||||
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
|
||||
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
|
||||
|
||||
// Distinct fill colors sampled from pdftoppm at each imageRect center.
|
||||
let prefix = directory.appendingPathComponent("skip-missing")
|
||||
try pdftoppm(pdf: output, prefix: prefix)
|
||||
let page1PNG = directory.appendingPathComponent("skip-missing-1.png")
|
||||
let page2PNG = directory.appendingPathComponent("skip-missing-2.png")
|
||||
let bitmap1 = try RGBABitmap.loadPNG(at: page1PNG)
|
||||
let bitmap2 = try RGBABitmap.loadPNG(at: page2PNG)
|
||||
let k = 110.0 / 72.0
|
||||
let layout1 = PageLayout(capture: first, pageIndex: 1, pageCount: 2)
|
||||
let layout2 = PageLayout(capture: third, pageIndex: 2, pageCount: 2)
|
||||
let c1 = try #require(bitmap1.pixel(
|
||||
x: Int((layout1.imageRect.midX * k).rounded()),
|
||||
y: Int(((layout1.pageRect.height - layout1.imageRect.midY) * k).rounded())
|
||||
))
|
||||
let c2 = try #require(bitmap2.pixel(
|
||||
x: Int((layout2.imageRect.midX * k).rounded()),
|
||||
y: Int(((layout2.pageRect.height - layout2.imageRect.midY) * k).rounded())
|
||||
))
|
||||
#expect(c1.0 > 150 && c1.1 < 80 && c1.2 < 80)
|
||||
#expect(c2.2 > 150 && c2.0 < 80 && c2.1 < 80)
|
||||
}
|
||||
|
||||
@Test("An unreadable (corrupt) PNG is treated exactly like a missing one (D-A)")
|
||||
func unreadablePNGIsSkippedLikeMissing() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let good = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 500)
|
||||
let bad = makeCapture(sequence: 2, pixelWidth: 800, pixelHeight: 500)
|
||||
let goodURL = try writePNG(for: good, red: 30, green: 140, blue: 30, in: directory)
|
||||
let badURL = directory.appendingPathComponent("corrupt.png")
|
||||
try Data([0x00, 0x01, 0x02, 0xFF, 0xD8, 0x00]).write(to: badURL)
|
||||
let urls: [UUID: URL] = [good.id: goodURL, bad.id: badURL]
|
||||
let output = directory.appendingPathComponent("skip-corrupt.pdf")
|
||||
let pageCount = try PDFComposer().compose(
|
||||
session: makeSession(captures: [good, bad]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "Skip corrupt",
|
||||
to: output
|
||||
)
|
||||
#expect(pageCount == 1)
|
||||
let document = try openDocument(output)
|
||||
#expect(document.pageCount == 1)
|
||||
}
|
||||
|
||||
@Test("Document attributes round-trip exactly")
|
||||
func documentAttributesRoundTrip() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let sessionID = try #require(UUID(uuidString: "deadbeef-dead-4eef-8ead-deadbeef0001"))
|
||||
let capture = makeCapture(sequence: 1, pixelWidth: 640, pixelHeight: 480)
|
||||
let png = try writePNG(for: capture, red: 40, green: 40, blue: 40, in: directory)
|
||||
let output = directory.appendingPathComponent("attrs.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [capture], id: sessionID),
|
||||
imageURL: { _ in png },
|
||||
title: "Ben review — 2026-08-30",
|
||||
to: output
|
||||
)
|
||||
let document = try openDocument(output)
|
||||
let attributes = try #require(document.documentAttributes)
|
||||
#expect(attributes[PDFDocumentAttribute.creatorAttribute] as? String == "Shotdeck")
|
||||
#expect(attributes[PDFDocumentAttribute.titleAttribute] as? String == "Ben review — 2026-08-30")
|
||||
#expect(attributes[PDFDocumentAttribute.subjectAttribute] as? String == "deadbeef-dead-4eef-8ead-deadbeef0001")
|
||||
#expect(document.pageCount == 1)
|
||||
#expect(try #require(document.page(at: 0)).annotations.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Rendered page is not blank (pdftoppm, pinned renderer + rounding)")
|
||||
func renderedPageIsNotBlank() throws {
|
||||
let directory = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: directory) }
|
||||
|
||||
let capture = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let png = try writePNG(for: capture, red: 128, green: 128, blue: 128, in: directory)
|
||||
let output = directory.appendingPathComponent("not-blank.pdf")
|
||||
_ = try PDFComposer().compose(
|
||||
session: makeSession(captures: [capture]),
|
||||
imageURL: { _ in png },
|
||||
title: "Not blank",
|
||||
to: output
|
||||
)
|
||||
let prefix = directory.appendingPathComponent("not-blank")
|
||||
try pdftoppm(pdf: output, prefix: prefix)
|
||||
let rendered = directory.appendingPathComponent("not-blank-1.png")
|
||||
let bitmap = try RGBABitmap.loadPNG(at: rendered)
|
||||
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
|
||||
let k: CGFloat = 110.0 / 72.0
|
||||
let imageWin = pixelWindow(for: layout.imageRect, pageHeightPt: layout.pageRect.height, scale: k)
|
||||
let headerWin = pixelWindow(for: layout.headerRect, pageHeightPt: layout.pageRect.height, scale: k)
|
||||
#expect(bitmap.containsNonWhite(x0: imageWin.x0, y0: imageWin.y0, x1: imageWin.x1, y1: imageWin.y1))
|
||||
#expect(bitmap.containsNonWhite(x0: headerWin.x0, y0: headerWin.y0, x1: headerWin.x1, y1: headerWin.y1))
|
||||
}
|
||||
|
||||
@Test("Right-edge tick group geometry matches D-12 exactly, both orientations")
|
||||
func rightEdgeTickGroupGeometry() throws {
|
||||
let landscape = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let portrait = makeCapture(sequence: 1, pixelWidth: 900, pixelHeight: 1600)
|
||||
let landscapeLayout = PageLayout(capture: landscape, pageIndex: 1, pageCount: 1)
|
||||
let portraitLayout = PageLayout(capture: portrait, pageIndex: 1, pageCount: 1)
|
||||
|
||||
#expect(landscapeLayout.failTickBox.maxX == 824)
|
||||
#expect(landscapeLayout.headerRect.maxX == 824)
|
||||
#expect(portraitLayout.failTickBox.maxX == 577)
|
||||
#expect(portraitLayout.headerRect.maxX == 577)
|
||||
#expect(landscapeLayout.failTickBox.width == 13)
|
||||
#expect(landscapeLayout.failTickBox.height == 13)
|
||||
#expect(portraitLayout.failTickBox.width == 13)
|
||||
#expect(portraitLayout.failTickBox.height == 13)
|
||||
#expect(landscapeLayout.passTickBox.maxX == landscapeLayout.failLabelOrigin.x - 8)
|
||||
#expect(portraitLayout.passTickBox.maxX == portraitLayout.failLabelOrigin.x - 8)
|
||||
}
|
||||
|
||||
@Test("Writes visual sample for review")
|
||||
func writesVisualSampleForReview() throws {
|
||||
let verifyDir = URL(fileURLWithPath: "/Users/benjaminhippler/mmd-projects/multi-agent-runs/shotdeck-20260830/verify")
|
||||
try FileManager.default.createDirectory(at: verifyDir, withIntermediateDirectories: true)
|
||||
let scratch = try makeScratchDirectory()
|
||||
defer { try? FileManager.default.removeItem(at: scratch) }
|
||||
|
||||
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
|
||||
let tall = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
|
||||
let retina = makeCapture(sequence: 3, pixelWidth: 2880, pixelHeight: 1620, scale: 2.0)
|
||||
let urls: [UUID: URL] = [
|
||||
wide.id: try writePNG(for: wide, red: 196, green: 42, blue: 42, in: scratch),
|
||||
tall.id: try writePNG(for: tall, red: 32, green: 96, blue: 176, in: scratch),
|
||||
retina.id: try writePNG(for: retina, red: 36, green: 148, blue: 84, in: scratch),
|
||||
]
|
||||
let output = verifyDir.appendingPathComponent("wp2-sample.pdf")
|
||||
let pageCount = try PDFComposer().compose(
|
||||
session: makeSession(captures: [wide, tall, retina]),
|
||||
imageURL: imageURLMap(urls),
|
||||
title: "WP-2 visual sample",
|
||||
to: output
|
||||
)
|
||||
#expect(pageCount == 3)
|
||||
let prefix = verifyDir.appendingPathComponent("wp2-sample")
|
||||
try pdftoppm(pdf: output, prefix: prefix)
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
import Foundation
|
||||
import Testing
|
||||
import ShotdeckCore
|
||||
|
||||
private func makeCasePaths() throws -> (paths: AppSupportPaths, cleanup: URL) {
|
||||
let cleanup = FileManager.default.temporaryDirectory
|
||||
.appendingPathComponent("shotdeck-wp5a-ledger-\(UUID().uuidString)", isDirectory: true)
|
||||
let paths = try AppSupportPaths(
|
||||
root: cleanup.appendingPathComponent("root", isDirectory: true),
|
||||
outbox: cleanup.appendingPathComponent("outbox", isDirectory: true),
|
||||
watchFolder: cleanup.appendingPathComponent("watch", isDirectory: true)
|
||||
)
|
||||
return (paths, cleanup)
|
||||
}
|
||||
|
||||
private func document(
|
||||
path: String,
|
||||
annotatedPages: [Int],
|
||||
detectedAt: Date,
|
||||
sessionID: UUID? = nil,
|
||||
pageCount: Int = 1
|
||||
) -> ReturnedDocument {
|
||||
ReturnedDocument(
|
||||
fileURL: URL(fileURLWithPath: path),
|
||||
sessionID: sessionID,
|
||||
pageCount: pageCount,
|
||||
annotatedPages: annotatedPages,
|
||||
detectedAt: detectedAt
|
||||
)
|
||||
}
|
||||
|
||||
@Test("L-1 commented() returns only commented entries, newest first")
|
||||
func l1_commentedReturnsOnlyCommentedNewestFirst() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let newer = document(
|
||||
path: "/tmp/shotdeck-returns/newer.pdf",
|
||||
annotatedPages: [1, 2],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_200)
|
||||
)
|
||||
let older = document(
|
||||
path: "/tmp/shotdeck-returns/older.pdf",
|
||||
annotatedPages: [3],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_100)
|
||||
)
|
||||
let clean = document(
|
||||
path: "/tmp/shotdeck-returns/clean.pdf",
|
||||
annotatedPages: [],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_300)
|
||||
)
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
try await ledger.record(older)
|
||||
try await ledger.record(newer)
|
||||
try await ledger.record(clean)
|
||||
|
||||
let commented = try await ledger.commented()
|
||||
#expect(commented.map(\.fileURL) == [newer.fileURL, older.fileURL])
|
||||
#expect(commented.map(\.annotatedPages) == [[1, 2], [3]])
|
||||
}
|
||||
|
||||
@Test("L-2 clipboardText() exact format")
|
||||
func l2_clipboardTextExactFormat() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let newer = document(
|
||||
path: "/tmp/shotdeck-returns/newer.pdf",
|
||||
annotatedPages: [1, 2],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_200)
|
||||
)
|
||||
let older = document(
|
||||
path: "/tmp/shotdeck-returns/older.pdf",
|
||||
annotatedPages: [3],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_100)
|
||||
)
|
||||
let clean = document(
|
||||
path: "/tmp/shotdeck-returns/clean.pdf",
|
||||
annotatedPages: [],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_300)
|
||||
)
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
try await ledger.record(older)
|
||||
try await ledger.record(newer)
|
||||
try await ledger.record(clean)
|
||||
|
||||
let text = try await ledger.clipboardText()
|
||||
#expect(text == newer.fileURL.path + "\n" + older.fileURL.path)
|
||||
#expect(text.hasSuffix("\n") == false)
|
||||
}
|
||||
|
||||
@Test("L-3 Re-recording the same URL upserts")
|
||||
func l3_rerecordingTheSameURLUpserts() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let url = URL(fileURLWithPath: "/tmp/shotdeck-returns/same.pdf")
|
||||
let first = ReturnedDocument(
|
||||
fileURL: url,
|
||||
sessionID: nil,
|
||||
pageCount: 1,
|
||||
annotatedPages: [],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_400)
|
||||
)
|
||||
let second = ReturnedDocument(
|
||||
fileURL: url,
|
||||
sessionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111"),
|
||||
pageCount: 1,
|
||||
annotatedPages: [1],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_100)
|
||||
)
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
try await ledger.record(first)
|
||||
try await ledger.record(second)
|
||||
|
||||
let all = try await ledger.all()
|
||||
#expect(all.count == 1)
|
||||
#expect(all[0].fileURL == url)
|
||||
#expect(all[0].annotatedPages == [1])
|
||||
#expect(all[0].isCommented == true)
|
||||
#expect(all[0].sessionID == UUID(uuidString: "11111111-1111-1111-1111-111111111111"))
|
||||
}
|
||||
|
||||
@Test("L-4 clipboardText() throws when nothing is commented")
|
||||
func l4_clipboardTextThrowsWhenNothingIsCommented() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
let emptyError = try await #require(throws: ShotdeckError.self) {
|
||||
try await ledger.clipboardText()
|
||||
}
|
||||
guard case .noCommentedReturns = emptyError else {
|
||||
Issue.record("expected noCommentedReturns on an empty ledger, got \(emptyError)")
|
||||
return
|
||||
}
|
||||
|
||||
try await ledger.record(document(
|
||||
path: "/tmp/shotdeck-returns/clean-only.pdf",
|
||||
annotatedPages: [],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_500)
|
||||
))
|
||||
let cleanError = try await #require(throws: ShotdeckError.self) {
|
||||
try await ledger.clipboardText()
|
||||
}
|
||||
guard case .noCommentedReturns = cleanError else {
|
||||
Issue.record("expected noCommentedReturns with only clean returns, got \(cleanError)")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
@Test("L-5 Ledger survives reopening from disk")
|
||||
func l5_ledgerSurvivesReopeningFromDisk() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let first = document(
|
||||
path: "/tmp/shotdeck-returns/a.pdf",
|
||||
annotatedPages: [1],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_700),
|
||||
sessionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")
|
||||
)
|
||||
let second = document(
|
||||
path: "/tmp/shotdeck-returns/b.pdf",
|
||||
annotatedPages: [],
|
||||
detectedAt: Date(timeIntervalSince1970: 1_777_000_600)
|
||||
)
|
||||
|
||||
do {
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
try await ledger.record(first)
|
||||
try await ledger.record(second)
|
||||
}
|
||||
|
||||
let reopened = try ReturnLedger(paths: paths)
|
||||
let all = try await reopened.all()
|
||||
#expect(all == [first, second])
|
||||
}
|
||||
|
||||
@Test("L-6 Corrupt returns.json is renamed and the ledger starts empty")
|
||||
func l6_corruptReturnsJSONIsRenamedAndStartsEmpty() async throws {
|
||||
let (paths, cleanup) = try makeCasePaths()
|
||||
defer { try? FileManager.default.removeItem(at: cleanup) }
|
||||
|
||||
let returnsURL = paths.root.appendingPathComponent("returns.json")
|
||||
try Data("{not-json".utf8).write(to: returnsURL)
|
||||
#expect(FileManager.default.fileExists(atPath: returnsURL.path))
|
||||
|
||||
let ledger = try ReturnLedger(paths: paths)
|
||||
#expect(try await ledger.all() == [])
|
||||
#expect(FileManager.default.fileExists(atPath: returnsURL.path) == false)
|
||||
|
||||
let names = try FileManager.default.contentsOfDirectory(atPath: paths.root.path)
|
||||
let corrupt = names.filter { $0.hasPrefix("returns.json.corrupt-") }
|
||||
#expect(corrupt.count == 1)
|
||||
#expect(corrupt[0].contains(DubaiTime.fileStamp(Date()).prefix(8)))
|
||||
}
|
||||
Reference in New Issue
Block a user