Factor abstract base class IDLCompiler, concrete class IDLComplierV8

Source/bindings/scripts/idl_compiler.py

 #!/usr/bin/python
 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
 
 """Compile an .idl file to Blink V8 bindings (.h and .cpp files).
 
 FIXME: Not currently used in build.
 This is a rewrite of the Perl IDL compiler in Python, but is not complete.
 Once it is complete, we will switch all IDL files over to Python at once.
 Until then, please work on the Perl IDL compiler.
 For details, see bug http://crbug.com/239771
 """
 
+import abc
 from optparse import OptionParser
 import os
 import cPickle as pickle
 import sys
 
 from code_generator_v8 import CodeGeneratorV8
 from idl_reader import IdlReader
-# from utilities import write_file  # FIXME: import once in same directory
+from utilities import write_file
 
 
 def parse_options():
     parser = OptionParser()
     parser.add_option('--idl-attributes-file')
     parser.add_option('--output-directory')
     parser.add_option('--interfaces-info-file')
     parser.add_option('--write-file-only-if-changed', type='int')
     # ensure output comes last, so command line easy to parse via regexes
     parser.disable_interspersed_args()
 
     options, args = parser.parse_args()
     if options.output_directory is None:
         parser.error('Must specify output directory using --output-directory.')
     options.write_file_only_if_changed = bool(options.write_file_only_if_changed)
     if len(args) != 1:
         parser.error('Must specify exactly 1 input file as argument, but %d given.' % len(args))
     idl_filename = os.path.realpath(args[0])
     return options, idl_filename
 
 
-# FIXME: import from utilities once moved into same directory (lines vs. text)
-def write_file(new_text, destination_filename, only_if_changed):
-    if only_if_changed and os.path.isfile(destination_filename):
-        with open(destination_filename) as destination_file:
-            if destination_file.read() == new_text:
-                return
-    with open(destination_filename, 'w') as destination_file:
-        destination_file.write(new_text)
+def idl_filename_to_interface_name(idl_filename):
+    basename = os.path.basename(idl_filename)
+    interface_name, _ = os.path.splitext(basename)
+    return interface_name
 
 
 class IdlCompiler(object):
-    def __init__(self, output_directory, interfaces_info, idl_attributes_file, only_if_changed=False):
+    """Abstract Base Class for IDL compilers.
+
+    In concrete classes:
+    * self.code_generator must be set, implementing generate_code()
+      (returning a list of output code), and
+    * compile_file() must be implemented (handling output filenames).
+    """
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, output_directory, idl_attributes_file,
+                 interfaces_info=None, interfaces_info_filename='',
+                 only_if_changed=False):
+        """
+        Args:
+            interfaces_info:
+                interfaces_info dict
+                (avoids auxiliary file in run-bindings-tests)
+            interfaces_info_file: filename of pickled interfaces_info
+        """
+        self.code_generator = None  # Set in derived class

[kouhei (in TOK), 2014/03/10 06:01:52]

optional nit: make this an arg of __init__ to enforce the rule?

[Nils Barth (inactive), 2014/03/10 06:31:02]

Done.
Thanks, that's a bit clearer!
In this case we constructor the CG after constructing the compiler
(to simplify parsing interfaces_info), but in general these can
be independent.

+        if interfaces_info_filename:
+            with open(interfaces_info_filename) as interfaces_info_file:
+                interfaces_info = pickle.load(interfaces_info_file)
+        self.interfaces_info = interfaces_info
+        self.only_if_changed = only_if_changed
         self.output_directory = output_directory
-        self.only_if_changed = only_if_changed
-        self.reader = IdlReader(interfaces_info, idl_attributes_file, output_directory)
-        self.code_generator = CodeGeneratorV8(interfaces_info, output_directory)
+        self.reader = IdlReader(interfaces_info, idl_attributes_file,
+                                output_directory)
 
-    def compile(self, idl_filename):
-        basename = os.path.basename(idl_filename)
-        interface_name, _ = os.path.splitext(basename)
+    def compile_and_write(self, idl_filename, output_filenames):
+        interface_name = idl_filename_to_interface_name(idl_filename)
+        definitions = self.reader.read_idl_definitions(idl_filename)
+        output_code_list = self.code_generator.generate_code(
+            definitions, interface_name)
+        for output_code, output_filename in zip(output_code_list,
+                                                output_filenames):
+            write_file(output_code, output_filename, self.only_if_changed)
 
-        definitions = self.reader.read_idl_definitions(idl_filename)
-        header_text, cpp_text = self.code_generator.generate_code(definitions, interface_name)
+    @abc.abstractmethod
+    def compile_file(self, idl_filename):
+        pass
 
+
+class IdlCompilerV8(IdlCompiler):
+    def __init__(self, *args, **kwargs):
+        IdlCompiler.__init__(self, *args, **kwargs)
+        self.code_generator = CodeGeneratorV8(self.interfaces_info,
+                                              self.output_directory)
+
+    def compile_file(self, idl_filename):
+        interface_name = idl_filename_to_interface_name(idl_filename)
         header_filename = os.path.join(self.output_directory,
                                        'V8%s.h' % interface_name)
         cpp_filename = os.path.join(self.output_directory,
                                     'V8%s.cpp' % interface_name)
-        write_file(header_text, header_filename, self.only_if_changed)
-        write_file(cpp_text, cpp_filename, self.only_if_changed)
+        self.compile_and_write(idl_filename, (header_filename, cpp_filename))
 
 
 def main():
     options, idl_filename = parse_options()
+    idl_compiler = IdlCompilerV8(options.output_directory,
+                                 options.idl_attributes_file,
+                                 interfaces_info_filename=options.interfaces_info_file,
+                                 only_if_changed=options.write_file_only_if_changed)
+    idl_compiler.compile_file(idl_filename)
 
-    interfaces_info_filename = options.interfaces_info_file
-    if interfaces_info_filename:
-        with open(interfaces_info_filename) as interfaces_info_file:
-            interfaces_info = pickle.load(interfaces_info_file)
-    else:
-        interfaces_info = None
-
-    idl_compiler = IdlCompiler(options.output_directory,
-                               interfaces_info,
-                               options.idl_attributes_file,
-                               options.write_file_only_if_changed)
-    idl_compiler.compile(idl_filename)
 
 if __name__ == '__main__':
     sys.exit(main())