Fix Generation of Sub-Keys in Dictionaries

The tool was previously non-deterministic in code generation for
different orders of property lists passed as parameters. This
generated some side effects where blocks of code wouldn’t be generated
at all depending on the order of property lists that were passed to
the tool **and** the difference in keys between these property lists.

This commit introduces a smarter behavior for property lists that
contain dictionaries, and these dictionaries contain different keys,
also called sub-keys in this context. Before code generation already
known keys that aren’t present in the currently processed property
list are merged with its contents, so that further code generation
methods can determine the optionality of these keys. These keys were
previously not part of the generated code.

Author: rbugajewski

Plist2swift/Plist2swift.swift

@@ -620,22 +620,31 @@ for plistPath in plists {
 	}
 
 	for key in allKeys {
-		if (keysAndTypes[key] == nil) {
-			let type = typeForValue(tuples[key]!)
-			keysAndTypes[key] = type
-			// Generate protocols for Dictionary entries
-			if (type == "Dictionary<String, Any>") {
+		guard let tuple = tuples[key] else {
+			continue
+		}
 
-				let dictionary = tuples[key] as? Dictionary<String, Any>
-				let sortedDictionary = dictionary?.sorted { (pairOne, pairTwo) -> Bool in
-					return pairOne.key < pairTwo.key
+		let type = typeForValue(tuple)
+		if (type != "Dictionary<String, Any>") { // Just register the existence of primitive types
+			keysAndTypes[key] = type
+		} else { // Generate protocols for Dictionary entries
+			var dictionary = tuples[key] as? Dictionary<String, Any> ?? [:]
+
+			// Merge sub-keys in dictionaries from current property list with already known sub-keys from dictionaries
+			// with the same name.
+			if let keyValueTuples = allKeyValueTuples[key] {
+				for knownKey in Set<String>(keyValueTuples.keys).subtracting(Set(dictionary.keys)) {
+					for (tupleKey, tupleValue) in keyValueTuples.tuples {
+						if (tupleKey == knownKey) {
+							dictionary[tupleKey] = tupleValue
+						}
+					}
 				}
-
-				allKeyValueTuples[key] = KeyValueTuples(tuples: sortedDictionary ?? [])
-				let name = key.uppercaseFirst()
-				let protocolName = name.appending("Protocol")
-				keysAndTypes[key] = protocolName
 			}
+
+			allKeyValueTuples[key] = KeyValueTuples(tuples: dictionary.sorted { $0.key < $1.key })
+			// Generate protocol name
+			keysAndTypes[key] = key.uppercaseFirst().appending("Protocol")
 		}
 	}