[NaCl SDK] cleanup python unittests

native_client_sdk/src/tools/create_nmf.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 from __future__ import with_statement
 
 import errno
 import optparse
 import os
 import re
 import shutil
 import struct
 import subprocess
 import sys
 import urllib
 
+import quote
+
 try:
   import json
 except ImportError:
   import simplejson as json
 
 NeededMatcher = re.compile('^ *NEEDED *([^ ]+)\n$')
 FormatMatcher = re.compile('^(.+):\\s*file format (.+)\n$')
 
 OBJDUMP_ARCH_MAP = {
     # Names returned by Linux's objdump:
@@ skipping 344 matching lines @@
         Trace("copy: %s -> %s" % (source, destination))
         shutil.copy2(source, destination)
 
   def _GenerateManifest(self):
     '''Create a JSON formatted dict containing the files
 
     NaCl will map url requests based on architecture.  The startup NEXE
     can always be found under the top key PROGRAM.  Additional files are under
     the FILES key further mapped by file name.  In the case of 'runnable' the
     PROGRAM key is populated with urls pointing the runnable-ld.so which acts
-    as the startup nexe.  The application itself, is then placed under the
-    FILES key mapped as 'main.exe' instead of it's original name so that the
-    loader can find it.'''
+    as the startup nexe.  The application itself is then placed under the
+    FILES key mapped as 'main.exe' instead of the original name so that the
+    loader can find it. '''
     manifest = { FILES_KEY: {}, PROGRAM_KEY: {} }
 
     needed = self.GetNeeded()
 
     runnable = any(n.endswith(RUNNABLE_LD) for n in needed)
 
-    for need, archinfo in needed.items():
+    extra_files_kv = [(key, ArchFile(name=key,
+                                     arch=arch,
+                                     path=url,
+                                     url=url))
+                      for key, arch, url in self.extra_files]
+
+    for need, archinfo in needed.items() + extra_files_kv:
       urlinfo = { URL_KEY: archinfo.url }
       name = archinfo.name
 
       # If starting with runnable-ld.so, make that the main executable.
       if runnable:
         if need.endswith(RUNNABLE_LD):
           manifest[PROGRAM_KEY][archinfo.arch] = urlinfo
           continue
 
       # For the main nexes:
@@ skipping 31 matching lines @@
     return '\n'.join([line.rstrip() for line in pretty_lines]) + '\n'
 
 
 def Trace(msg):
   if Trace.verbose:
     sys.stderr.write(str(msg) + '\n')
 
 Trace.verbose = False
 
 
+def ParseExtraFiles(encoded_list, err):
+  """Parse the extra-files list and return a canonicalized list of
+  [key, arch, url] triples.  The |encoded_list| should be a list of
+  strings of the form 'key:url' or 'key:arch:url', where an omitted
+  'arch' is taken to mean 'portable'.
+
+  All entries in |encoded_list| are checked for syntax errors before
+  returning.  Error messages are written to |err| (typically
+  sys.stderr) so that the user has actionable feedback for fixing all
+  errors, rather than one at a time.  If there are any errors, None is
+  returned instead of a list, since an empty list is a valid return
+  value.
+  """
+  seen_error = False
+  canonicalized = []
+  for ix in range(len(encoded_list)):
+    kv = encoded_list[ix]
+    unquoted = quote.unquote(kv, ':')
+    if len(unquoted) == 3:
+      if unquoted[1] != ':':
+        err.write('Syntax error for key:value tuple ' +
+                  'for --extra-files argument: ' + kv + '\n')
+        seen_error = True
+      else:
+        canonicalized.append([unquoted[0], 'portable', unquoted[2]])
+    elif len(unquoted) == 5:
+      if unquoted[1] != ':' or unquoted[3] != ':':
+        err.write('Syntax error for key:arch:url tuple ' +
+                  'for --extra-files argument: ' +
+                  kv + '\n')
+        seen_error = True
+      else:
+        canonicalized.append([unquoted[0], unquoted[2], unquoted[4]])
+    else:
+      err.write('Bad key:arch:url tuple for --extra-files: ' + kv + '\n')
+  if seen_error:
+    return None
+  return canonicalized
+
+
 def main(argv):
   parser = optparse.OptionParser(
       usage='Usage: %prog [options] nexe [extra_libs...]')
   parser.add_option('-o', '--output', dest='output',
                     help='Write manifest file to FILE (default is stdout)',
                     metavar='FILE')
   parser.add_option('-D', '--objdump', dest='objdump',
                     help='Use TOOL as the "objdump" tool to run',
                     metavar='TOOL')
   parser.add_option('-L', '--library-path', dest='lib_path',
                     action='append', default=[],
                     help='Add DIRECTORY to library search path',
                     metavar='DIRECTORY')
   parser.add_option('-P', '--path-prefix', dest='path_prefix', default='',
                     help='A path to prepend to shared libraries in the .nmf',
                     metavar='DIRECTORY')
   parser.add_option('-s', '--stage-dependencies', dest='stage_dependencies',
                     help='Destination directory for staging libraries',
                     metavar='DIRECTORY')
   parser.add_option('-r', '--remove', dest='remove',
                     help='Remove the prefix from the files.',
                     metavar='PATH')
   parser.add_option('-t', '--toolchain', help='Legacy option, do not use')
   parser.add_option('-n', '--name', dest='name',
                     help='Rename FOO as BAR',
                     action='append', default=[], metavar='FOO,BAR')
+  parser.add_option('-x', '--extra-files',
+                    help=('Add extra key:file tuple to the "files"' +
+                          ' section of the .nmf'),
+                    action='append', default=[], metavar='FILE')
   parser.add_option('-v', '--verbose',
                     help='Verbose output', action='store_true')
   parser.add_option('-d', '--debug-mode',
                     help='Debug mode', action='store_true')
   options, args = parser.parse_args(argv)
   if options.verbose:
     Trace.verbose = True
   if options.debug_mode:
     DebugPrint.debug_mode = True
 
   if options.toolchain is not None:
     print "warning: option -t/--toolchain is deprecated."
 
   if len(args) < 1:
     raise Error("No nexe files specified.  See --help for more info")
 
+  canonicalized = ParseExtraFiles(options.extra_files, sys.stderr)
+  if canonicalized is None:
+    parser.error("Bad --extra-files (-x) argument syntax")
+
   remap = {}
   for ren in options.name:
     parts = ren.split(',')
     if len(parts) != 2:
       raise Error('Expecting --name=<orig_arch.so>,<new_name.so>')
     remap[parts[0]] = parts[1]
 
   if options.path_prefix:
     path_prefix = options.path_prefix.split('/')
   else:
     path_prefix = []
 
   nmf = NmfUtils(objdump=options.objdump,
                  main_files=args,
                  lib_path=options.lib_path,
+                 extra_files=canonicalized,
                  lib_prefix=path_prefix,
                  remap=remap)
 
   nmf.GetManifest()
   if options.output is None:
     sys.stdout.write(nmf.GetJson())
   else:
     with open(options.output, 'w') as output:
       output.write(nmf.GetJson())
 
   if options.stage_dependencies:
     Trace("Staging dependencies...")
     nmf.StageDependencies(options.stage_dependencies)
 
   return 0
 
 
 # Invoke this file directly for simple testing.
 if __name__ == '__main__':
   try:
     rtn = main(sys.argv[1:])
   except Error, e:
     sys.stderr.write("%s: %s\n" % (os.path.basename(__file__), e))
     rtn = 1
   sys.exit(rtn)