Support plist & pbxproj in json format

phimage · e-marchand · commit b4b54e222346 · 2022-10-21T10:58:11.000+02:00
diff --git a/Sources/XcodeProj+FilePath.swift b/Sources/XcodeProj+FilePath.swift
@@ -10,7 +10,7 @@ import Foundation
 
 extension XcodeProj {
 
-    func paths(_ current: PBXGroup, prefix: String) -> [String: PathType] {
+    static func paths(_ current: PBXGroup, prefix: String) -> [String: PathType] {
         var paths: [String: PathType] = [:]
 
         for file in current.fileRefs {
diff --git a/Sources/XcodeProj+Serialization.swift b/Sources/XcodeProj+Serialization.swift
@@ -10,7 +10,7 @@ import Foundation
 
 extension XcodeProj {
 
-    public func write(to url: URL, format: PropertyListSerialization.PropertyListFormat? = nil,
+    public func write(to url: URL, format: Format? = nil,
                       projectName: String? = nil, lineEnding: String? = nil, atomic: Bool = true) throws {
         let pbxprojURL: URL
         let name: String
@@ -36,13 +36,22 @@ extension XcodeProj {
         if format == .openStep {
             let serializer = OpenStepSerializer(projectName: name, lineEnding: lineEnding, projectFile: self)
             try serializer.serialize().write(to: pbxprojURL, atomically: atomic, encoding: .utf8)
-        } else {
-            let data = try PropertyListSerialization.data(fromPropertyList: dict, format: format, options: 0)
-            #if os(Linux)
+        }
+        else if let propertyListformat = format.toPropertyListformat() {
+            let data = try PropertyListSerialization.data(fromPropertyList: dict, format: propertyListformat, options: 0)
+#if os(Linux)
             try data.write(to: pbxprojURL, options: []) // error no attomic on linux
-            #else
+#else
             try data.write(to: pbxprojURL, options: atomic ? [.atomicWrite] : [])
-            #endif
+#endif
+        }
+        else if format == .json {
+            let data = try JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
+#if os(Linux)
+            try data.write(to: pbxprojURL, options: []) // error no attomic on linux
+#else
+            try data.write(to: pbxprojURL, options: atomic ? [.atomicWrite] : [])
+#endif
         }
     }
 
@@ -51,9 +60,13 @@ extension XcodeProj {
             let projectName = projectName ?? self.projectName
             let serializer = OpenStepSerializer(projectName: projectName, projectFile: self)
             return try serializer.serialize().data(using: .utf8) ?? Data()
-        } else {
-            return try PropertyListSerialization.data(fromPropertyList: dict, format: format, options: 0)
+        } else if let propertyListformat = format.toPropertyListformat() {
+            return try PropertyListSerialization.data(fromPropertyList: dict, format: propertyListformat, options: 0)
+        }
+        else if format == .json {
+            return try JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
         }
+        return Data() // must not occurs
     }
 
 }
diff --git a/Sources/XcodeProj.swift b/Sources/XcodeProj.swift
@@ -8,16 +8,97 @@
 
 import Foundation
 
-public class XcodeProj {
+open class PropertyList {
+
+    public enum Format {
+        case binary
+        case xml
+        case json
+        case openStep
+
+        public func toPropertyListformat() -> PropertyListSerialization.PropertyListFormat? {
+            switch self {
+            case .binary:
+                return .binary
+            case .xml:
+                return .xml
+            case .openStep:
+                return .openStep
+            case .json:
+                return nil
+            }
+        }
+
+        public init(_ format: PropertyListSerialization.PropertyListFormat) {
+            switch format {
+            case .binary:
+                self = .binary
+            case .xml:
+                self = .xml
+            case .openStep:
+                self = .openStep
+            }
+        }
+
+        public init?(_ format: PropertyListSerialization.PropertyListFormat?) {
+            if let format = format {
+                self.init(format)
+            } else {
+                return nil
+            }
+        }
+    }
+
+    public let dict: PBXObject.Fields
+    public let format: Format
+
+    public init(dict: PBXObject.Fields, format: Format) throws {
+        self.dict = dict
+        self.format = format
+    }
+
+    public convenience init(propertyListData data: Data) throws {
+        let format: Format
+        let obj: Any
+        if data.first == 123 { // start with {
+            obj = try JSONSerialization.jsonObject(with: data)
+            format = .json
+        } else {
+            var propertyListFormat: PropertyListSerialization.PropertyListFormat = .binary
+            obj = try PropertyListSerialization.propertyList(from: data, options: [], format: &propertyListFormat)
+            format = .init(propertyListFormat)
+        }
+
+        guard let dict = obj as? PBXObject.Fields else {
+            throw XcodeProjError.invalidData(object: obj)
+        }
+
+        try self.init(dict: dict, format: format)
+    }
+
+    public convenience init(url: URL) throws {
+        assert(url.isFileURL)
+        do {
+            let data = try Data(contentsOf: url)
+            try self.init(propertyListData: data)
+        } catch let error as XcodeProjError {
+            throw error
+        } catch {
+            throw XcodeProjError.failedToReadFile(error: error)
+        }
+    }
+
+}
+
+public class XcodeProj: PropertyList {
 
     public static let pbxprojFileExtension = "pbxproj"
     public static let pbxprojFileName = "project.pbxproj"
 
-    public let dict: PBXObject.Fields
-    public let format: PropertyListSerialization.PropertyListFormat
     public var projectName: String = "PRODUCT_NAME"
     public var lineEnding: String = "\r\n"
 
+    public let objects: Objects
     public let project: PBXProject
 
     public class Objects: PBXObjectFactory {
@@ -69,7 +150,6 @@ public class XcodeProj {
 
     }
 
-    public let objects: Objects
 
     // MARK: init
     public convenience init(url: URL) throws {
@@ -112,35 +192,25 @@ public class XcodeProj {
         }
     }
 
-    public convenience init(propertyListData data: Data) throws {
-        var format: PropertyListSerialization.PropertyListFormat = .binary
-        let obj = try PropertyListSerialization.propertyList(from: data, options: [], format: &format)
-
-        guard let dict = obj as? PBXObject.Fields else {
-            throw XcodeProjError.invalidData(object: obj)
-        }
-
-        try self.init(dict: dict, format: format)
+    public convenience init(dict: PBXObject.Fields, format: PropertyListSerialization.PropertyListFormat) throws {
+        try self.init(dict: dict, format: .init(format))
     }
 
-    init(dict: PBXObject.Fields, format: PropertyListSerialization.PropertyListFormat) throws {
-        self.dict = dict
-        self.format = format
-
+    public override init(dict: PBXObject.Fields, format: Format) throws {
         self.objects = Objects()
 
-        if let objs = self.dict[FieldKey.objects.rawValue] as? [String: PBXObject.Fields] {
+        if let objs = dict[FieldKey.objects.rawValue] as? [String: PBXObject.Fields] {
             // Create all objects
             for (ref, obj) in objs {
                 self.objects.dict[ref] = try XcodeProj.createObject(ref: ref, fields: obj, objects: self.objects)
             }
 
             // parsing project
-            if let rootObjectRef = self.dict[FieldKey.rootObject.rawValue] as? String {
+            if let rootObjectRef = dict[FieldKey.rootObject.rawValue] as? String {
                 if let projDict = objs[rootObjectRef] {
                     self.project = PBXProject(ref: rootObjectRef, fields: projDict, objects: self.objects)
                     if let mainGroup = self.project.mainGroup {
-                        objects.fullFilePaths = paths(mainGroup, prefix: "")
+                        objects.fullFilePaths = XcodeProj.paths(mainGroup, prefix: "")
                     } else {
                         if let mainGroupref = self.project.string(PBXProject.PBXKeys.mainGroup) {
                             throw XcodeProjError.objectMissing(key: mainGroupref, expectedType: .group)
@@ -157,6 +227,7 @@ public class XcodeProj {
         } else {
             throw XcodeProjError.fieldKeyMissing(.objects)
         }
+        try super.init(dict: dict, format: format)
     }
 
     static func createObject(ref: String, fields: PBXObject.Fields, objects: XcodeProj.Objects) throws -> PBXObject {
diff --git a/Tests/Utils.swift b/Tests/Utils.swift
@@ -47,4 +47,50 @@ extension XCTestCase {
     func url(forResource resource: String, withExtension ext: String) -> URL? {
         return Utils.url(forResource: resource, withExtension: ext)
     }
+
+    func assertContentsEqual(_ url: URL, _ testURL: URL ) {
+        do {
+            let contents = try String(contentsOf: url)
+            let testContents = try String(contentsOf: testURL)
+#if os(Linux)
+            XCTAssertEqual(contents.replacingOccurrences(matchingPattern: "classes = \\{\\s*\\};", by: "classes = [:];"), testContents, "diff \(url.path) \(testURL.path)")
+#else
+            XCTAssertEqual(contents, testContents)
+#endif
+
+        } catch {
+            XCTFail("\(error)")
+        }
+    }
+
+    func assertContentsNotEqual(_ url: URL, _ testURL: URL ) {
+        do {
+            let contents = try String(contentsOf: url)
+            let testContents = try String(contentsOf: testURL)
+#if os(Linux)
+            XCTAssertNotEqual(contents.replacingOccurrences(matchingPattern: "classes = \\{\\s*\\};", by: "classes = [:];"), testContents, "diff \(url.path) \(testURL.path)")
+#else
+            XCTAssertNotEqual(contents, testContents)
+#endif
+
+        } catch {
+            XCTFail("\(error)")
+        }
+    }
+
+}
+
+extension String {
+    func replacingOccurrences(matchingPattern pattern: String, by replacement: String) -> String {
+        do {
+            let expression = try NSRegularExpression(pattern: pattern, options: [])
+            let matches = expression.matches(in: self, options: [], range: NSRange(startIndex..<endIndex, in: self))
+            return matches.reversed().reduce(into: self) { (current, result) in
+                let range = Range(result.range, in: current)!
+                current.replaceSubrange(range, with: replacement)
+            }
+        } catch {
+            return self
+        }
+    }
 }
diff --git a/Tests/XcodeProjKitEditionTests.swift b/Tests/XcodeProjKitEditionTests.swift
@@ -53,7 +53,7 @@ class XcodeProjKitEditionTests: XCTestCase {
                 XCTAssertEqual(PBXProject.Version(major: 12, minor: 0), testproj.project.lastUpgradeCheck)
 
 
-                compare(url, testURL)
+                assertContentsNotEqual(url, testURL)
 
             } catch {
                 XCTFail("\(error)")
@@ -63,19 +63,4 @@ class XcodeProjKitEditionTests: XCTestCase {
         }
     }
 
-    func compare(_ url: URL, _ testURL: URL ) {
-        do {
-            let contents = try String(contentsOf: url)
-            let testContents = try String(contentsOf: testURL)
-            #if os(Linux)
-            XCTAssertNotEqual(contents.replacingOccurrences(matchingPattern: "classes = \\{\\s*\\};", by: "classes = [:];"), testContents, "diff \(url.path) \(testURL.path)")
-            #else
-            XCTAssertNotEqual(contents, testContents)
-            #endif
-
-        } catch {
-            XCTFail("\(error)")
-        }
-
-    }
 }
diff --git a/Tests/XcodeProjKitParseTests.swift b/Tests/XcodeProjKitParseTests.swift
@@ -88,6 +88,10 @@ class XcodeProjKitParseTests: XCTestCase {
         testParse("ok/plist")
     }
 
+    func testjson() {
+        testParse("ok/json")
+    }
+
     func testswiftpm() {
         let proj = testParse("ok/swiftpm.project")
         XCTAssertNotNil(proj?.objects.object("48A408192662576D0068A35B"))
diff --git a/Tests/XcodeProjKitWriteTests.swift b/Tests/XcodeProjKitWriteTests.swift
@@ -102,12 +102,22 @@ class XcodeProjKitWriteTests: XCTestCase {
                 XCTAssertNotNil(proj.project.buildConfigurationList)
                 let testURL = URL(fileURLWithPath: XcodeProjKitWriteTests.directory + resource.replacingOccurrences(of: "ok/", with: "") + "." + XcodeProj.pbxprojFileExtension)
                 try proj.write(to: testURL)
-                
+
+                assertContentsEqual(url, testURL)
+
+                // test passing by xml before recoding to openstep
                 let testURLPlist = URL(fileURLWithPath: XcodeProjKitWriteTests.directory + resource.replacingOccurrences(of: "ok/", with: "") + ".plist")
                 try proj.write(to: testURLPlist, format: .xml)
-                
-                compare(url, testURL)
-                
+                try XcodeProj(url: testURLPlist).write(to: testURLPlist.appendingPathExtension("pbxproj"), format: .openStep, projectName: proj.projectName, lineEnding: proj.lineEnding)
+                print("\(url.path)")
+                print("\(testURLPlist.appendingPathExtension("pbxproj").path)")
+                assertContentsEqual(url, testURLPlist.appendingPathExtension("pbxproj"))
+
+                // test passing by json before recoding to openstep
+                let testURLJSON = URL(fileURLWithPath: XcodeProjKitWriteTests.directory + resource.replacingOccurrences(of: "ok/", with: "") + ".json")
+                try proj.write(to: testURLJSON, format: .json)
+                try XcodeProj(url: testURLJSON).write(to: testURLJSON.appendingPathExtension(".pbxproj"), format: .openStep, projectName: proj.projectName, lineEnding: proj.lineEnding)
+                assertContentsEqual(url, testURLJSON.appendingPathExtension(".pbxproj"))
             } catch {
                 XCTFail("\(error)")
             }
@@ -116,35 +126,8 @@ class XcodeProjKitWriteTests: XCTestCase {
         }
     }
 
-    func compare(_ url: URL, _ testURL: URL ) {
-        do {
-            let contents = try String(contentsOf: url)
-            let testContents = try String(contentsOf: testURL)
-            #if os(Linux)
-            XCTAssertEqual(contents.replacingOccurrences(matchingPattern: "classes = \\{\\s*\\};", by: "classes = [:];"), testContents, "diff \(url.path) \(testURL.path)")
-            #else
-            XCTAssertEqual(contents, testContents)
-            #endif
-            
-        } catch {
-            XCTFail("\(error)")
-        }
-        
-    }
-    
 }
 
-fileprivate extension String {
-    func replacingOccurrences(matchingPattern pattern: String, by replacement: String) -> String {
-        do {
-            let expression = try NSRegularExpression(pattern: pattern, options: [])
-            let matches = expression.matches(in: self, options: [], range: NSRange(startIndex..<endIndex, in: self))
-            return matches.reversed().reduce(into: self) { (current, result) in
-                let range = Range(result.range, in: current)!
-                current.replaceSubrange(range, with: replacement)
-            }
-        } catch {
-            return self
-        }
-    }
-}
+
+
+
diff --git a/Tests/ok/json.pbxproj b/Tests/ok/json.pbxproj
