263 lines
8.2 KiB
Swift
263 lines
8.2 KiB
Swift
import Foundation
|
|
import AppKit
|
|
import CryptoKit
|
|
|
|
private struct ImageJob {
|
|
|
|
let destination: String
|
|
|
|
let width: Int
|
|
|
|
let path: String
|
|
}
|
|
|
|
final class ImageGenerator {
|
|
|
|
/**
|
|
The path to the input folder.
|
|
*/
|
|
private let input: URL
|
|
|
|
/**
|
|
The path to the output folder
|
|
*/
|
|
private let output: URL
|
|
|
|
/**
|
|
The images to generate.
|
|
|
|
The key is the image source path relative to the input folder, and the values are the destination path (relative to the output folder) and the required image width.
|
|
*/
|
|
private var imageJobs: [String : [ImageJob]] = [:]
|
|
|
|
/**
|
|
The images which could not be found, but are required for the site.
|
|
|
|
The key is the image path, and the value is the page that requires it.
|
|
*/
|
|
private var missingImages: [String : String] = [:]
|
|
|
|
/**
|
|
All warnings produced for images during generation
|
|
*/
|
|
private var imageWarnings: Set<String> = []
|
|
|
|
/**
|
|
All images required by the site.
|
|
|
|
The values are the destination paths of the images, relative to the output folder
|
|
*/
|
|
private var requiredImages: Set<String> = []
|
|
|
|
/**
|
|
All images modified or created during this generator run.
|
|
*/
|
|
private var generatedImages: Set<String> = []
|
|
|
|
/**
|
|
A cache to get the size of source images, so that files don't have to be loaded multiple times.
|
|
|
|
The key is the absolute source path, and the value is the image size
|
|
*/
|
|
private var imageSizeCache: [String : NSSize] = [:]
|
|
|
|
private var fileUpdates: FileUpdateChecker
|
|
|
|
init(input: URL, output: URL) {
|
|
self.fileUpdates = FileUpdateChecker(input: input)
|
|
self.input = input
|
|
self.output = output
|
|
}
|
|
|
|
func writeDetectedFileChangesToDisk() {
|
|
fileUpdates.writeDetectedFileChangesToDisk()
|
|
}
|
|
|
|
private func getImageSize(atPath path: String) -> NSSize? {
|
|
if let size = imageSizeCache[path] {
|
|
return size
|
|
}
|
|
guard let image = getImage(atPath: path) else {
|
|
return nil
|
|
}
|
|
let size = image.size
|
|
imageSizeCache[path] = size
|
|
return size
|
|
}
|
|
|
|
private func getImage(atPath path: String) -> NSImage? {
|
|
guard let data = getData(atPath: path) else {
|
|
log.add(error: "Failed to load file", source: path)
|
|
return nil
|
|
}
|
|
guard let image = NSImage(data: data) else {
|
|
log.add(error: "Failed to read image", source: path)
|
|
return nil
|
|
}
|
|
return image
|
|
}
|
|
|
|
private func getData(atPath path: String) -> Data? {
|
|
let url = input.appendingPathComponent(path)
|
|
guard url.exists else {
|
|
return nil
|
|
}
|
|
do {
|
|
let data = try Data(contentsOf: url)
|
|
fileUpdates.didLoad(data, at: path)
|
|
return data
|
|
} catch {
|
|
log.add(error: "Failed to read data", source: path, error: error)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func requireImage(at destination: String, generatedFrom source: String, requiredBy path: String, width: Int, height: Int?) -> NSSize {
|
|
let height = height.unwrapped(CGFloat.init)
|
|
let sourceUrl = input.appendingPathComponent(source)
|
|
guard sourceUrl.exists else {
|
|
missingImages[source] = path
|
|
return .zero
|
|
}
|
|
|
|
guard let imageSize = getImageSize(atPath: source) else {
|
|
missingImages[source] = path
|
|
return .zero
|
|
}
|
|
let scaledSize = imageSize.scaledDown(to: CGFloat(width))
|
|
|
|
// Check desired height, then we can forget about it
|
|
if let height = height {
|
|
let expectedHeight = scaledSize.width / CGFloat(width) * height
|
|
if abs(expectedHeight - scaledSize.height) > 2 {
|
|
addWarning("Invalid height (\(scaledSize.height) instead of \(expectedHeight))", destination: destination, path: path)
|
|
}
|
|
}
|
|
|
|
let job = ImageJob(destination: destination, width: width, path: path)
|
|
|
|
guard let existingSource = imageJobs[source] else {
|
|
imageJobs[source] = [job]
|
|
return scaledSize
|
|
}
|
|
|
|
guard let existingJob = existingSource.first(where: { $0.destination == destination}) else {
|
|
imageJobs[source] = existingSource + [job]
|
|
return scaledSize
|
|
}
|
|
|
|
if existingJob.width != width {
|
|
addWarning("Multiple image widths (\(existingJob.width) and \(width))", destination: destination, path: "\(existingJob.path) and \(path)")
|
|
}
|
|
return scaledSize
|
|
}
|
|
|
|
func createImages() {
|
|
for (source, jobs) in imageJobs.sorted(by: { $0.key < $1.key }) {
|
|
create(images: jobs, from: source)
|
|
}
|
|
printMissingImages()
|
|
printImageWarnings()
|
|
}
|
|
|
|
private func printMissingImages() {
|
|
guard !missingImages.isEmpty else {
|
|
return
|
|
}
|
|
print("\(missingImages.count) missing images:")
|
|
for (source, path) in missingImages {
|
|
print(" \(source) (required by \(path))")
|
|
}
|
|
}
|
|
|
|
private func printImageWarnings() {
|
|
guard !imageWarnings.isEmpty else {
|
|
return
|
|
}
|
|
print("\(imageWarnings.count) image warnings:")
|
|
for imageWarning in imageWarnings {
|
|
print(imageWarning)
|
|
}
|
|
}
|
|
|
|
private func addWarning(_ message: String, destination: String, path: String) {
|
|
let warning = " \(destination): \(message) required by \(path)"
|
|
imageWarnings.insert(warning)
|
|
}
|
|
|
|
private func addWarning(_ message: String, job: ImageJob) {
|
|
addWarning(message, destination: job.destination, path: job.path)
|
|
}
|
|
|
|
private func isMissing(_ job: ImageJob) -> Bool {
|
|
!output.appendingPathComponent(job.destination).exists
|
|
}
|
|
|
|
private func create(images: [ImageJob], from source: String) {
|
|
// Only load image if required
|
|
let imageHasChanged = fileUpdates.fileHasChanged(at: source)
|
|
guard imageHasChanged || images.contains(where: isMissing) else {
|
|
return
|
|
}
|
|
|
|
guard let image = getImage(atPath: source) else {
|
|
missingImages[source] = images.first?.path
|
|
return
|
|
}
|
|
if imageHasChanged {
|
|
// Update all images
|
|
images.forEach { create(job: $0, from: image, source: source) }
|
|
} else {
|
|
// Update only missing images
|
|
images
|
|
.filter(isMissing)
|
|
.forEach { create(job: $0, from: image, source: source) }
|
|
}
|
|
}
|
|
|
|
private func create(job: ImageJob, from image: NSImage, source: String) {
|
|
let destinationUrl = output.appendingPathComponent(job.destination)
|
|
|
|
// Ensure that image file is supported
|
|
let ext = destinationUrl.pathExtension.lowercased()
|
|
guard ImageType(fileExtension: ext) != nil else {
|
|
fatalError()
|
|
}
|
|
|
|
let desiredWidth = CGFloat(image.size.width)
|
|
|
|
let destinationSize = image.size.scaledDown(to: desiredWidth)
|
|
let scaledImage = image.scaledDown(to: destinationSize)
|
|
let scaledSize = scaledImage.size
|
|
|
|
if abs(scaledSize.width - desiredWidth) > 2 {
|
|
addWarning("Invalid width (\(scaledSize.width) instead of \(desiredWidth))", job: job)
|
|
}
|
|
|
|
if scaledSize.width > desiredWidth {
|
|
addWarning("Invalid width (\(scaledSize.width) instead of \(desiredWidth))", job: job)
|
|
}
|
|
|
|
let destinationExtension = destinationUrl.pathExtension.lowercased()
|
|
guard let type = ImageType(fileExtension: destinationExtension)?.fileType else {
|
|
addWarning("Invalid image extension \(destinationExtension)", job: job)
|
|
return
|
|
}
|
|
guard let tiff = scaledImage.tiffRepresentation, let tiffData = NSBitmapImageRep(data: tiff) else {
|
|
addWarning("Failed to get data", job: job)
|
|
return
|
|
}
|
|
|
|
guard let data = tiffData.representation(using: type, properties: [.compressionFactor: NSNumber(0.7)]) else {
|
|
addWarning("Failed to get data", job: job)
|
|
return
|
|
}
|
|
do {
|
|
try data.createFolderAndWrite(to: destinationUrl)
|
|
} catch {
|
|
addWarning("Failed to write image (\(error))", job: job)
|
|
return
|
|
}
|
|
}
|
|
}
|