Return array of structs from LocalizableStrings

The returned struct includes any comment associated with the strings file entry. Returning an array allows for future features such as detecting duplicates within a single file.

Author: nolanw

R.swift/Generators/StringsGenerator.swift

@@ -67,13 +67,13 @@ struct StringsGenerator: Generator {
       baseKeys = nil
     }
     else {
-      baseKeys = Set(bases.flatMap { $0.dictionary.keys })
+      baseKeys = Set(bases.flatMap { $0.keys })
     }
 
     // Warnings about duplicates and empties
     for ls in strings {
       let filenameLocale = ls.locale.withFilename(filename)
-      let groupedKeys = ls.dictionary.keys.groupBySwiftNames { $0 }
+      let groupedKeys = ls.keys.groupBySwiftNames { $0 }
 
       for (sanitizedName, duplicates) in groupedKeys.duplicates {
         warn("Skipping \(duplicates.count) strings in \(filenameLocale) because symbol '\(sanitizedName)' would be generated for all of these keys: \(duplicates.map { "'\($0)'" }.joinWithSeparator(", "))")
@@ -88,13 +88,17 @@ struct StringsGenerator: Generator {
       }
 
       // Save uniques
+      var byKey: [String: LocalizableStrings.Entry] = [:]
+      for entry in ls.entries {
+        byKey[entry.key] = entry
+      }
       for key in groupedKeys.uniques {
-        if let (params, commentValue) = ls.dictionary[key] {
+        if let entry = byKey[key] {
           if let _ = allParams[key] {
-            allParams[key]?.append((ls.locale, commentValue, params))
+            allParams[key]?.append((ls.locale, entry.val, entry.params))
           }
           else {
-            allParams[key] = [(ls.locale, commentValue, params)]
+            allParams[key] = [(ls.locale, entry.val, entry.params)]
           }
         }
       }
@@ -105,7 +109,7 @@ struct StringsGenerator: Generator {
       let filenameLocale = locale.withFilename(filename)
       let sourceKeys = baseKeys ?? Set(allParams.keys)
 
-      let missing = sourceKeys.subtract(lss.flatMap { $0.dictionary.keys })
+      let missing = sourceKeys.subtract(lss.flatMap { $0.keys })
 
       if missing.isEmpty {
         continue

R.swift/ResourceTypes/LocalizableStrings.swift

@@ -13,12 +13,12 @@ struct LocalizableStrings : WhiteListedExtensionsResourceType {
 
   let filename: String
   let locale: Locale
-  let dictionary: [String : (params: [StringParam], commentValue: String)]
+  let entries: [Entry]
 
-  init(filename: String, locale: Locale, dictionary: [String : (params: [StringParam], commentValue: String)]) {
+  init(filename: String, locale: Locale, entries: [Entry]) {
     self.filename = filename
     self.locale = locale
-    self.dictionary = dictionary
+    self.entries = entries
   }
 
   init(url: NSURL) throws {
@@ -37,45 +37,56 @@ struct LocalizableStrings : WhiteListedExtensionsResourceType {
     }
 
     // Parse dicts from NSDictionary
-    let dictionary: [String : (params: [StringParam], commentValue: String)]
+    let entries: [Entry]
     switch url.pathExtension {
     case "strings"?:
-      dictionary = try parseStrings(String(contentsOfURL: url), source: locale.withFilename("\(filename).strings"))
+      entries = try parseStrings(String(contentsOfURL: url), source: locale.withFilename("\(filename).strings"))
     case "stringsdict"?:
-      dictionary = try parseStringsdict(nsDictionary, source: locale.withFilename("\(filename).stringsdict"))
+      entries = try parseStringsdict(nsDictionary, source: locale.withFilename("\(filename).stringsdict"))
     default:
       throw ResourceParsingError.UnsupportedExtension(givenExtension: url.pathExtension, supportedExtensions: LocalizableStrings.supportedExtensions)
     }
 
     self.filename = filename
     self.locale = locale
-    self.dictionary = dictionary
+    self.entries = entries
+  }
+  
+  var keys: [String] {
+    return entries.map { $0.key }
+  }
+  
+  struct Entry {
+    let key: String
+    let val: String
+    let params: [StringParam]
+    let comment: String?
   }
 }
 
-private func parseStrings(stringsFile: String, source: String) throws -> [String : (params: [StringParam], commentValue: String)] {
-  var dictionary: [String : (params: [StringParam], commentValue: String)] = [:]
-
-  for entry in StringsEntry.parse(stringsFile) {
-      var params: [StringParam] = []
-
-      for part in FormatPart.formatParts(formatString: entry.val) {
-        switch part {
-        case .Reference:
-          throw ResourceParsingError.ParsingFailed("Non-specifier reference in \(source): \(entry.key) = \(entry.val)")
-
-        case .Spec(let formatSpecifier):
-          params.append(StringParam(name: nil, spec: formatSpecifier))
-        }
+private func parseStrings(stringsFile: String, source: String) throws -> [LocalizableStrings.Entry] {
+  var entries: [LocalizableStrings.Entry] = []
+  
+  for parsed in StringsFileEntry.parse(stringsFile) {
+    var params: [StringParam] = []
+    
+    for part in FormatPart.formatParts(formatString: parsed.val) {
+      switch part {
+      case .Reference:
+        throw ResourceParsingError.ParsingFailed("Non-specifier reference in \(source): \(parsed.key) = \(parsed.val)")
+        
+      case .Spec(let formatSpecifier):
+        params.append(StringParam(name: nil, spec: formatSpecifier))
       }
-
-      dictionary[entry.key] = (params, entry.val)
+    }
+    
+    entries.append(LocalizableStrings.Entry(key: parsed.key, val: parsed.val, params: params, comment: parsed.comment))
   }
-
-  return dictionary
+  
+  return entries
 }
 
-private struct StringsEntry {
+private struct StringsFileEntry {
   let comment: String?
   let key: String
   let val: String
@@ -113,15 +124,15 @@ private struct StringsEntry {
     val = extract(match.rangeAtIndex(4), unescape: true)!
   }
 
-  static func parse(stringsFileContents: String) -> [StringsEntry] {
+  static func parse(stringsFileContents: String) -> [StringsFileEntry] {
     return regex.matchesInString(stringsFileContents, options: [], range: NSRange(0..<stringsFileContents.utf16.count))
-      .map { StringsEntry(source: stringsFileContents, match: $0) }
+      .map { StringsFileEntry(source: stringsFileContents, match: $0) }
   }
 }
 
-private func parseStringsdict(nsDictionary: NSDictionary, source: String) throws -> [String : (params: [StringParam], commentValue: String)] {
+private func parseStringsdict(nsDictionary: NSDictionary, source: String) throws -> [LocalizableStrings.Entry] {
 
-  var dictionary: [String : (params: [StringParam], commentValue: String)] = [:]
+  var entries: [LocalizableStrings.Entry] = []
 
   for (key, obj) in nsDictionary {
     if let
@@ -134,7 +145,7 @@ private func parseStringsdict(nsDictionary: NSDictionary, source: String) throws
 
       do {
         let params = try parseStringsdictParams(localizedFormat, dict: dict)
-        dictionary[key] = (params, localizedFormat)
+        entries.append(LocalizableStrings.Entry(key: key, val: localizedFormat, params: params, comment: nil))
       }
       catch ResourceParsingError.ParsingFailed(let message) {
         warn("\(message) in '\(key)' \(source)")
@@ -145,7 +156,7 @@ private func parseStringsdict(nsDictionary: NSDictionary, source: String) throws
     }
   }
 
-  return dictionary
+  return entries
 }
 
 private func parseStringsdictParams(format: String, dict: [String: AnyObject]) throws -> [StringParam] {