Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373import CryptoKitimport Foundation
enum CIAuditTools { // Shipped languages are a contract, not inferred from whatever translations remain. static let shippedLanguages = ["en", "de", "es", "fr", "ja", "ko", "pt-BR", "zh-Hans"] static let permittedLicenses: Set<String> = ["MIT", "BSD-2-Clause", "BSD-3-Clause", "Apache-2.0", "Zlib"]
struct LanguageStatus { let language: String var required = 0 var missing = 0 var invalid = 0 var stale = 0 var failures: [String] = []
var json: DevJSON { .object([ "language": .string(language), "required": .number(Double(required)), "missing": .number(Double(missing)), "invalid": .number(Double(invalid)), "stale": .number(Double(stale)), "valid": .number(Double(required - missing - invalid)), "failures": .array(failures.sorted().map(DevJSON.string)), ]) } }
struct Report { let json: DevJSON let markdown: String let failures: [String] }
static func run(_ args: [String]) throws -> Int32 { guard args.count == 2 else { throw DevError("Usage: check-ci-audits REPOSITORY OUTPUT_DIRECTORY") } let root = URL(fileURLWithPath: args[0]) let output = URL(fileURLWithPath: args[1]) try FileManager.default.createDirectory(at: output, withIntermediateDirectories: true) let localization = localizationReport(root) try write(localization, name: "localization", output: output) let licenses = licenseReport(root) try write(licenses, name: "swiftpm-licenses", output: output) let failures = localization.failures + licenses.failures if !failures.isEmpty { FileHandle.standardError.write(Data((failures.joined(separator: "\n") + "\n").utf8)) return 1 } print("CI catalog and SwiftPM license audits passed") return 0 }
private static func write(_ report: Report, name: String, output: URL) throws { try report.json.encoded().write(to: output.appendingPathComponent(name + ".json"), options: .atomic) try report.markdown.write( to: output.appendingPathComponent(name + ".md"), atomically: true, encoding: .utf8) }
static func localizationReport(_ root: URL) -> Report { var failures: [String] = [] var catalogs: [(String, [String: DevJSON])] = [] do { let sources = root.appendingPathComponent("Sources") let urls = try catalogURLs(sources) if urls.isEmpty { failures.append("No String Catalogs found under Sources") } for url in urls { do { let catalog = try DevJSON.read(url.path) if catalog["sourceLanguage"] != .string("en") { failures.append("\(url.path): sourceLanguage must be en") } let entries = try (catalog["strings"] ?? .null).requireObject() if entries.isEmpty { failures.append("\(url.path): catalog contains zero keys") } for (key, entry) in entries where entry["localizations"]?[LocalizationTools.pseudoLanguage] != nil { failures.append("\(url.path): pseudo resources must be generated, not committed (\(key))") } catalogs.append((url.path, entries)) } catch { failures.append("\(url.path): \(error)") } } } catch { failures.append("Catalog discovery: \(error)") } do { failures += try LocalizationTools.audit(root) } catch { failures.append("Localization/source audit: \(error)") } var languages = Set(shippedLanguages) for (_, entries) in catalogs { for entry in entries.values { languages.formUnion( entry["localizations"]?.object?.keys.filter { $0 != LocalizationTools.pseudoLanguage } ?? []) } } var statuses: [LanguageStatus] = [] for language in languages.sorted() { var status = LanguageStatus(language: language) for (path, entries) in catalogs { for (key, entry) in entries.sorted(by: { $0.key < $1.key }) { let context = "\(path): \(key) [\(language)]" if entry["extractionState"] == .string("stale") { status.stale += 1 status.failures.append("\(context): stale extraction state") } guard entry["shouldTranslate"] != .bool(false) else { continue } status.required += 1 let english = entry["localizations"]?["en"] ?? .object([ "stringUnit": .object(["state": .string("translated"), "value": .string(key)]) ]) guard containsStringUnit(english) else { status.invalid += 1 status.failures.append("\(context): source localization contains no string units") continue } guard let localized = language == "en" ? english : entry["localizations"]?[language] else { status.missing += 1 status.failures.append("\(context): missing localization") continue } do { let issues = try LocalizationTools.localizationFailures( english, localized, context: context, language: language) if !issues.isEmpty { status.invalid += 1 } status.failures += issues } catch { status.invalid += 1 status.failures.append("\(context): \(error)") } } } failures += status.failures statuses.append(status) } failures = Array(Set(failures)).sorted() let json = DevJSON.object([ "schemaVersion": .number(1), "passed": .bool(failures.isEmpty), "expectedLanguages": .array(shippedLanguages.map(DevJSON.string)), "catalogCount": .number(Double(catalogs.count)), "languages": .array(statuses.map(\.json)), "failures": .array(failures.map(DevJSON.string)), ]) var markdown = "# Localization catalog status\n\n" markdown += "Result: \(failures.isEmpty ? "passed" : "failed"). Catalogs read: \(catalogs.count).\n\n" markdown += "| Language | Required | Valid | Missing | Invalid | Stale |\n| --- | ---: | ---: | ---: | ---: | ---: |\n" for row in statuses { markdown += "| \(cell(row.language)) | \(row.required) | \(row.required - row.missing - row.invalid) | \(row.missing) | \(row.invalid) | \(row.stale) |\n" } markdown += "\nNon-translatable entries are excluded from coverage; stale extraction entries still fail. English key-only source text is valid. Invalid counts include placeholder, plural, substitution, and translation-state errors.\n" markdown += failureMarkdown(failures) return Report(json: json, markdown: markdown, failures: failures) }
private static func containsStringUnit(_ node: DevJSON) -> Bool { if node["stringUnit"]?["value"]?.string != nil { return true } switch node { case .object(let values): return values.values.contains(where: containsStringUnit) case .array(let values): return values.contains(where: containsStringUnit) default: return false } }
private static func catalogURLs(_ sources: URL) throws -> [URL] { var result: [URL] = [] for url in try FileManager.default.contentsOfDirectory( at: sources, includingPropertiesForKeys: [.isDirectoryKey, .isSymbolicLinkKey]) { let values = try url.resourceValues(forKeys: [.isDirectoryKey, .isSymbolicLinkKey]) guard values.isSymbolicLink != true else { throw DevError("Catalog discovery does not follow symbolic links: \(url.path)") } if values.isDirectory == true { result += try catalogURLs(url) } else if url.pathExtension == "xcstrings" { result.append(url) } } return result.sorted { $0.path < $1.path } }
struct Pin: Equatable { let identity: String let repository: String let revision: String let version: String
init(_ json: DevJSON, manifest: Bool) throws { identity = try (json["identity"] ?? .null).requireString() repository = try (json[manifest ? "repository" : "location"] ?? .null).requireString() let state = manifest ? json : json["state"] ?? .null revision = try (state["revision"] ?? .null).requireString() version = try (state["version"] ?? .null).requireString() guard try NameRegex.matches("[a-z0-9][a-z0-9._-]*", identity), repository.hasPrefix("https://"), try NameRegex.matches("[a-f0-9]{40}", revision), !version.isEmpty else { throw DevError("Invalid dependency pin: \(identity)") } if !manifest && json["kind"] != .string("remoteSourceControl") { throw DevError("Unsupported dependency kind: \(identity)") } } }
struct DependencyStatus { let pin: Pin let expressions: [String] let inspectedCheckoutCount: Int
var json: DevJSON { .object([ "identity": .string(pin.identity), "repository": .string(pin.repository), "revision": .string(pin.revision), "version": .string(pin.version), "licenses": .array(expressions.map(DevJSON.string)), "inspectedCheckoutCount": .number(Double(inspectedCheckoutCount)), ]) } }
static func licenseReport(_ root: URL) -> Report { do { return try dependencyReport( resolved: DevJSON.read(root.appendingPathComponent("Package.resolved").path), manifest: DevJSON.read(root.appendingPathComponent(".github/swiftpm-licenses.json").path), checkoutDirectories: [ root.appendingPathComponent(".build/checkouts"), root.appendingPathComponent(".build/parcel-dev/checkouts"), ]) } catch { let failures = ["SwiftPM license audit: \(error)"] return Report( json: .object([ "schemaVersion": .number(1), "passed": .bool(false), "failures": .array(failures.map(DevJSON.string)), ]), markdown: "# SwiftPM dependency/license status\n\nResult: failed.\n" + failureMarkdown(failures), failures: failures) } }
static func dependencyReport(resolved: DevJSON, manifest: DevJSON, checkoutDirectories: [URL]) throws -> Report { guard resolved["version"] == .number(3), manifest["schemaVersion"] == .number(1) else { throw DevError("Unsupported Package.resolved or license manifest schema") } let pins = try (resolved["pins"] ?? .null).requireArray().map { try Pin($0, manifest: false) } let reviewed = try (manifest["dependencies"] ?? .null).requireArray() let reviewedPins = try reviewed.map { try Pin($0, manifest: true) } guard Set(pins.map(\.identity)).count == pins.count, Set(reviewedPins.map(\.identity)).count == reviewedPins.count else { throw DevError("Duplicate dependency identities") } var failures: [String] = [] var rows: [DependencyStatus] = [] for pin in pins.sorted(by: { $0.identity < $1.identity }) { guard let index = reviewedPins.firstIndex(where: { $0.identity == pin.identity }) else { failures.append("\(pin.identity): missing reviewed license manifest entry") continue } if reviewedPins[index] != pin { failures.append("\(pin.identity): reviewed pin does not exactly match Package.resolved") } let files = try (reviewed[index]["licenseFiles"] ?? .null).requireArray() if files.isEmpty { failures.append("\(pin.identity): no reviewed license files") } let checkouts = try matchingCheckouts(pin.identity, directories: checkoutDirectories) if checkouts.isEmpty { failures.append( "\(pin.identity): checkouts absent; license hashes and checkout revisions NOT verified; build first" ) } var expressions: [String] = [] var paths = Set<String>() for file in files { let path = try (file["path"] ?? .null).requireString() let hash = try (file["sha256"] ?? .null).requireString() let expression = try (file["spdx"] ?? .null).requireString() expressions.append(expression) guard safeRelativePath(path), try NameRegex.matches("[a-f0-9]{64}", hash), paths.insert(path).inserted else { throw DevError("\(pin.identity): invalid or duplicate reviewed license path/hash") } if try !permittedExpression(expression) { failures.append("\(pin.identity): license is not permitted: \(expression)") } for checkout in checkouts { do { let url = checkout.appendingPathComponent(path).resolvingSymlinksInPath() guard url.path.hasPrefix(checkout.resolvingSymlinksInPath().path + "/") else { throw DevError("License path escapes checkout") } let actual = DevHex.string(SHA256.hash(data: try Data(contentsOf: url))) if actual != hash { failures.append("\(pin.identity): license hash mismatch: \(url.path)") } } catch { failures.append("\(pin.identity): license readback: \(error)") } } } for checkout in checkouts { do { let actual = String( decoding: try DevProcess.checked("/usr/bin/git", ["-C", checkout.path, "rev-parse", "HEAD"]), as: UTF8.self ) .trimmingCharacters(in: .whitespacesAndNewlines) if actual != pin.revision { failures.append("\(pin.identity): checkout revision mismatch: \(checkout.path)") } } catch { failures.append("\(pin.identity): checkout revision readback: \(error)") } } rows.append(DependencyStatus(pin: pin, expressions: expressions, inspectedCheckoutCount: checkouts.count)) } for pin in reviewedPins where !pins.contains(where: { $0.identity == pin.identity }) { failures.append("\(pin.identity): reviewed dependency is not in Package.resolved") } failures.sort() let limitations = "This verifies reviewed pins and license-file SHA256, not legal interpretation, all source headers, transitive code embedded in binary artifacts, or packaged notice compliance. Missing checkouts fail the audit because content verification is incomplete; run SwiftPM setup/build first. SPDX OR alternatives need one permitted branch; every AND component must be permitted." let json = DevJSON.object([ "schemaVersion": .number(1), "passed": .bool(failures.isEmpty), "dependencies": .array(rows.map(\.json)), "permittedLicenses": .array(permittedLicenses.sorted().map(DevJSON.string)), "failures": .array(failures.map(DevJSON.string)), "limitations": .string(limitations), ]) var markdown = "# SwiftPM dependency/license status\n\nResult: \(failures.isEmpty ? "passed" : "failed").\n\n" markdown += "| Dependency | Version | Revision | Reviewed SPDX | Checkouts inspected |\n| --- | --- | --- | --- | ---: |\n" for row in rows { markdown += "| \(cell(row.pin.identity)) | \(cell(row.pin.version)) | \(cell(row.pin.revision)) | \(cell(row.expressions.joined(separator: "; "))) | \(row.inspectedCheckoutCount) |\n" } markdown += "\n\(limitations)\n" markdown += failureMarkdown(failures) return Report(json: json, markdown: markdown, failures: failures) }
// A deliberately small SPDX grammar; unsupported syntax must be reviewed, never coerced. static func permittedExpression(_ expression: String) throws -> Bool { var permitted = false for alternative in expression.components(separatedBy: " OR ") { var branch = true for identifier in alternative.components(separatedBy: " AND ") { guard try NameRegex.matches("[A-Za-z0-9][A-Za-z0-9.-]*", identifier) else { throw DevError("Unsupported SPDX expression: \(expression)") } branch = branch && permittedLicenses.contains(identifier) } permitted = permitted || branch } return permitted }
private static func matchingCheckouts(_ identity: String, directories: [URL]) throws -> [URL] { var results: [URL] = [] for directory in directories where FileManager.default.fileExists(atPath: directory.path) { for url in try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil) where url.lastPathComponent.lowercased() == identity { results.append(url) } } return results }
private static func safeRelativePath(_ path: String) -> Bool { !path.isEmpty && !path.hasPrefix("/") && !path.contains("\\") && path.components(separatedBy: "/").allSatisfy { !$0.isEmpty && $0 != "." && $0 != ".." } }
private static func cell(_ value: String) -> String { value.replacingOccurrences(of: "|", with: "\\|").replacingOccurrences(of: "\r", with: " ") .replacingOccurrences(of: "\n", with: " ").replacingOccurrences(of: "<", with: "<") .replacingOccurrences(of: ">", with: ">") }
static func failureMarkdown(_ failures: [String]) -> String { guard !failures.isEmpty else { return "" } let preview = failures.prefix(40).map { failure in let text = String(failure.prefix(300)) + (failure.count > 300 ? "…" : "") return "- " + cell(text) }.joined(separator: "\n") return "\n## Failures\n\n" + preview + "\n\nShowing up to 40 failures; full details are in the JSON artifact.\n" }}