[iOS/GN] Convert .strings file to binary1 plist format.

build/toolchain/mac/copy_bundle_data.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import argparse
 import os
 import shutil
 import sys
 
 
-def detect_encoding(data, default_encoding='UTF-8'):
+def DetectEncoding(data, default_encoding='UTF-8'):
   """Detects the encoding used by |data| from the Byte-Order-Mark if present.
 
   Args:
     data: string whose encoding needs to be detected
     default_encoding: encoding returned if no BOM is found.
 
   Returns:
     The encoding determined from the BOM if present or |default_encoding| if
     no BOM was found.
   """
   if data.startswith('\xFE\xFF'):
     return 'UTF-16BE'
 
   if data.startswith('\xFF\xFE'):
     return 'UTF-16LE'
 
   if data.startswith('\xEF\xBB\xBF'):
     return 'UTF-8'
 
   return default_encoding
 
 
-def copy_strings_file(source, dest):
+def CopyStringsFile(source, dest, strings_format):
   """Copies a .strings file from |source| to |dest| and convert it to UTF-16.
 
   Args:
     source: string, path to the source file
     dest: string, path to the destination file
   """
   with open(source, 'rb') as source_file:
     data = source_file.read()
 
   # Xcode's CpyCopyStringsFile / builtin-copyStrings seems to call
   # CFPropertyListCreateFromXMLData() behind the scenes; at least it prints
   #     CFPropertyListCreateFromXMLData(): Old-style plist parser: missing
   #     semicolon in dictionary.
   # on invalid files. Do the same kind of validation.
-  from CoreFoundation import CFDataCreate, CFPropertyListCreateFromXMLData
-  cfdata = CFDataCreate(None, data, len(data))
-  _, error = CFPropertyListCreateFromXMLData(None, cfdata, 0, None)
+  import CoreFoundation

[Robert Sesek, 2016/06/13 16:50:57]

"as CF" could shorten up some of your callsites.

[sdefresne, 2016/06/14 07:27:39]

Done.

+  cfdata = CoreFoundation.CFDataCreate(None, data, len(data))
+  plist, error = CoreFoundation.CFPropertyListCreateFromXMLData(
+      None, cfdata, 0, None)
   if error:
     raise ValueError(error)
 
-  encoding = detect_encoding(data)
-  with open(dest, 'wb') as dest_file:
-    dest_file.write(data.decode(encoding).encode('UTF-16'))
+  if strings_format == 'legacy':
+    encoding = DetectEncoding(data)
+    with open(dest, 'wb') as dest_file:
+      dest_file.write(data.decode(encoding).encode('UTF-16'))
+  else:
+    cfformat = {
+      'xml1': CoreFoundation.kCFPropertyListXMLFormat_v1_0,
+      'binary1': CoreFoundation.kCFPropertyListBinaryFormat_v1_0,
+    }[strings_format]
+    cfdata, error = CoreFoundation.CFPropertyListCreateData(
+        None, plist, CoreFoundation.kCFPropertyListBinaryFormat_v1_0,
+        0, None)
+    if error:
+      raise ValueError(error)
+
+    data = CoreFoundation.CFDataGetBytes(

[Robert Sesek, 2016/06/13 16:50:57]

GetBytes will do a copy. Is it possible to use GetBytePtr in Python?

[sdefresne, 2016/06/14 07:27:40]

I tried, but when I pass the value to dest_file.write() I get the following
error:

Traceback (most recent call last):
  File "../../build/toolchain/mac/copy_bundle_data.py", line 117, in <module>
    sys.exit(Main())
  File "../../build/toolchain/mac/copy_bundle_data.py", line 114, in Main
    CopyFile(args.source, args.dest, args.strings_format)
  File "../../build/toolchain/mac/copy_bundle_data.py", line 98, in CopyFile
    CopyStringsFile(source, dest, strings_format)
  File "../../build/toolchain/mac/copy_bundle_data.py", line 73, in
CopyStringsFile
    dest_file.write(data)
TypeError: must be string or buffer, not objc.varlist

The obc.varlist is a wrapper around a uint8_t*, so I would have to do the
following:

  data = CoreFoundation.CFDataGetBytePtr(cfdata)
  with open(dest, 'wb') as dest_file:
    for i in xrange(CoreFoundation.CFDataGetLength(cfdata)):
      dest_file.write(data[i])

I think that looping and appending byte per byte in python is going to be slower
than slurping the value in a python array in the C module and writing it to a
file in one go. The .strings file are generally relatively small (a few Mb at
most) and keeping a couple of copies in memory would not be too problematic.

Invoking "plutil" to do the conversion would also involve having the data
multiple time in memory (though in different processes) and will also require
spawning a new process (which is a bit slow), so probably not better than the
current code.

WDYT?

[Robert Sesek, 2016/06/14 13:40:26]

Eesh, what you have here is fine, then.

+        cfdata,
+        CoreFoundation.CFRangeMake(0, CoreFoundation.CFDataGetLength(cfdata)),
+        None)
+    with open(dest, 'wb') as dest_file:
+      dest_file.write(data)
 
 
-def copy_file(source, dest):
+def CopyFile(source, dest, strings_format):
   """Copies a file or directory from |source| to |dest|.
 
   Args:
     source: string, path to the source file
     dest: string, path to the destination file
   """
   if os.path.isdir(source):
     if os.path.exists(dest):
       shutil.rmtree(dest)
     # Copy tree.
     # TODO(thakis): This copies file attributes like mtime, while the
     # single-file branch below doesn't. This should probably be changed to
     # be consistent with the single-file branch.
     shutil.copytree(source, dest, symlinks=True)
     return
 
   if os.path.exists(dest):
     os.unlink(dest)
 
   _, extension = os.path.splitext(source)
   if extension == '.strings':
-    copy_strings_file(source, dest)
+    CopyStringsFile(source, dest, strings_format)
     return
 
   shutil.copy(source, dest)
 
 
-def main():
+def Main():
   parser = argparse.ArgumentParser(
       description='copy source to destination for the creation of a bundle')
+  parser.add_argument('--strings-format',
+      choices=('xml1', 'binary1', 'legacy'), default='legacy',
+      help='convert .strings file to format (default: %(default)s)')
   parser.add_argument('source', help='path to source file or directory')
   parser.add_argument('dest', help='path to destination')
   args = parser.parse_args()
 
-  copy_file(args.source, args.dest)
+  CopyFile(args.source, args.dest, args.strings_format)
 
 if __name__ == '__main__':
-  main()
+  sys.exit(Main())