Generate a single srcjar as output in of the Java mojom generator.

mojo/public/tools/bindings/generators/mojom_java_generator.py

 # Copyright 2014 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.
 
 """Generates java source files from a mojom.Module."""
 
 import argparse
 import ast
+import contextlib
 import os
 import re
 
 from jinja2 import contextfilter
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 from mojom.generate.template_expander import UseJinja
 
 
@@ skipping 324 matching lines @@
     if method.response_parameters:
       return True
   return False
 
 def HasMethodWithoutResponse(interface):
   for method in interface.methods:
     if not method.response_parameters:
       return True
   return False
 
+@contextlib.contextmanager
+def TempDir():

[ppi, 2014/09/25 18:16:49]

Do you think these two should be extracted to, say, 
/mojo/public/tools/bindings/pylib/fileutils ?

+  import tempfile
+  import shutil
+  dirname = tempfile.mkdtemp()
+  try:
+    yield dirname
+  finally:
+    shutil.rmtree(dirname)
+
+def ZipContentInto(directory, root, zip_filename):
+  import zipfile
+  with zipfile.ZipFile(zip_filename, 'w') as zip_file:
+    for dirname, subdirs, files in os.walk(directory):
+      for filename in files:
+        path = os.path.join(dirname, filename)
+        arcname = os.path.relpath(path, root)
+        zip_file.write(path, arcname)
+        print "%s -> %s" % (path, arcname,)
+
 class Generator(generator.Generator):
 
   java_filters = {
     'interface_response_name': GetInterfaceResponseName,
     'constant_value': ConstantValue,
     'default_value': DefaultValue,
     'decode_method': DecodeMethod,
     'expression_to_text': ExpressionToText,
     'encode_method': EncodeMethod,
     'has_method_with_response': HasMethodWithResponse,
@@ skipping 47 matching lines @@
   def GenerateInterfaceInternalSource(self, interface):
     return self.GetJinjaExportsForInterface(interface)
 
   @UseJinja('java_templates/constants.java.tmpl', filters=java_filters)
   def GenerateConstantsSource(self, module):
     exports = self.GetJinjaExports()
     exports.update({'main_entity': GetConstantsMainEntityName(module),
                     'constants': module.constants})
     return exports
 
-  def GenerateFiles(self, unparsed_args):
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--java_output_directory', dest='java_output_directory')
-    args = parser.parse_args(unparsed_args)
-    if self.output_dir and args.java_output_directory:
-      self.output_dir = os.path.join(args.java_output_directory,
-                                     GetPackage(self.module).replace('.', '/'))
-      if not os.path.exists(self.output_dir):
-        try:
-          os.makedirs(self.output_dir)
-        except:
-          # Ignore errors on directory creation.
-          pass
+  def DoGenerateFiles(self):
+    if not os.path.exists(self.output_dir):
+      try:
+        os.makedirs(self.output_dir)
+      except:
+        # Ignore errors on directory creation.
+        pass
 
     # Keep this above the others as .GetStructs() changes the state of the
     # module, annotating structs with required information.
     for struct in self.GetStructs():
       self.Write(self.GenerateStructSource(struct),
                  '%s.java' % GetNameForElement(struct))
 
     for enum in self.module.enums:
       self.Write(self.GenerateEnumSource(enum),
                  '%s.java' % GetNameForElement(enum))
 
     for interface in self.module.interfaces:
       self.Write(self.GenerateInterfaceSource(interface),
                  '%s.java' % GetNameForElement(interface))
       self.Write(self.GenerateInterfaceInternalSource(interface),
                  '%s_Internal.java' % GetNameForElement(interface))
 
     if self.module.constants:
       self.Write(self.GenerateConstantsSource(self.module),
                  '%s.java' % GetConstantsMainEntityName(self.module))
 
+  def GenerateFiles(self, unparsed_args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--java_output_directory', dest='java_output_directory')
+    parser.add_argument('--java_srcjar', dest='java_srcjar',
+                        action='store_true',
+                        help='output a single srcjar in the regular output '
+                             'directory (overrides --java_output_directory)')
+    args = parser.parse_args(unparsed_args)
+    package_path = GetPackage(self.module).replace('.', '/')
+    if args.java_srcjar:
+      # Place the output srcjar in the regular output directory.
+      zip_filename = os.path.join(self.output_dir,
+                                  "%s.srcjar" % self.module.name)
+      # Generate the files in a temporary directory.
+      with TempDir() as temp_java_root:
+        self.output_dir = os.path.join(temp_java_root, package_path)
+        self.DoGenerateFiles();
+        ZipContentInto(self.output_dir, temp_java_root, zip_filename)
+    else:
+      if self.output_dir and args.java_output_directory:
+        self.output_dir = os.path.join(args.java_output_directory, package_path)
+      self.DoGenerateFiles();
+
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'namespace': self.module.namespace,
       'module': self.module,
     }