IDL: Avoid global variables in compute_interfaces_info_individual.py

Source/bindings/scripts/compute_interfaces_info_individual.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.
@@ skipping 35 matching lines @@
 import os
 import posixpath
 import sys
 
 from idl_reader import IdlReader
 from utilities import get_file_contents, read_file_to_list, idl_filename_to_interface_name, idl_filename_to_component, write_pickle_file, get_interface_extended_attributes_from_idl, is_callback_interface_from_idl
 
 module_path = os.path.dirname(__file__)
 source_path = os.path.normpath(os.path.join(module_path, os.pardir, os.pardir))
 
-# Global variables (filled in and exported)
-interfaces_info = {}
-partial_interface_files = defaultdict(lambda: {
-    'full_paths': [],
-    'include_paths': [],
-})
-
 
 class IdlBadFilenameError(Exception):
     """Raised if an IDL filename disagrees with the interface name in the file."""
     pass
 
 
 def parse_options():
     usage = 'Usage: %prog [options] [generated1.idl]...'
     parser = optparse.OptionParser(usage=usage)
     parser.add_option('--cache-directory', help='cache directory')
@@ skipping 31 matching lines @@
     """
     relative_dir = relative_dir_posix(idl_filename)
 
     # IDL file basename is used even if only a partial interface file
     idl_file_basename, _ = os.path.splitext(os.path.basename(idl_filename))
     cpp_class_name = implemented_as or idl_file_basename
 
     return posixpath.join(relative_dir, cpp_class_name + '.h')
 
 
-def add_paths_to_partials_dict(partial_interface_name, full_path, this_include_path=None):
-    paths_dict = partial_interface_files[partial_interface_name]
-    paths_dict['full_paths'].append(full_path)
-    if this_include_path:
-        paths_dict['include_paths'].append(this_include_path)
-
-
 def get_implements_from_definitions(definitions, definition_name):
     left_interfaces = []
     right_interfaces = []
     for implement in definitions.implements:
         if definition_name == implement.left_interface:
             right_interfaces.append(implement.right_interface)
         elif definition_name == implement.right_interface:
             left_interfaces.append(implement.left_interface)
         else:
             raise IdlBadFilenameError(
                 'implements statement found in unrelated IDL file.\n'
                 'Statement is:\n'
                 '    %s implements %s;\n'
                 'but filename is unrelated "%s.idl"' %
                 (implement.left_interface, implement.right_interface, definition_name))
     return left_interfaces, right_interfaces
 
 
 def get_put_forward_interfaces_from_definition(definition):
     return sorted(set(attribute.idl_type.base_type
                       for attribute in definition.attributes
                       if 'PutForwards' in attribute.extended_attributes))
 
 
-def compute_info_individual(idl_filename, reader):
-    definitions = reader.read_idl_file(idl_filename)
-    if len(definitions.interfaces) > 0:
-        definition = next(definitions.interfaces.itervalues())
-        interface_info = {
-            'is_callback_interface': definition.is_callback,
-            'is_dictionary': False,
-            # Interfaces that are referenced (used as types) and that we introspect
-            # during code generation (beyond interface-level data ([ImplementedAs],
-            # is_callback_interface, ancestors, and inherited extended attributes):
-            # deep dependencies.
-            # These cause rebuilds of referrers, due to the dependency, so these
-            # should be minimized; currently only targets of [PutForwards].
-            'referenced_interfaces': get_put_forward_interfaces_from_definition(definition),
+class InterfaceInfoGeneratorIndividual(object):

[Jens Widell, 2014/10/22 10:10:26]

"Invididual" here (in various names) is the opposite of "overall" (I guess), and
doesn't necessarily need to be repeated quite as much. It doesn't add anything
of value to this class name, I think.

And "Generator" sounds a bit odd to me. This class really generate anything, it
collects (or "computes".)

So maybe InterfaceInfoCollector? Or *Computer, although that sounds a bit
strange to me. Maybe *Computer with compute_info(), or *Collector with
collect_info()/collect_info_from().

Ah, I don't know. Naming things is always the hardest part. :-)

[haraken, 2014/10/22 11:58:52]

+1 to Collector :)

[bashi, 2014/10/23 22:55:12]

Done. I couldn't come up with a good name for this class...

+    """A class that computes interface information from individual idl files."""
+    def __init__(self, cache_directory=None):
+        self.reader = IdlReader(interfaces_info=None, outputdir=cache_directory)
+        self.interfaces_info = {}
+        self.partial_interface_files = defaultdict(lambda: {
+            'full_paths': [],
+            'include_paths': [],
+        })
+
+    def add_paths_to_partials_dict(self, partial_interface_name, full_path,
+                                   this_include_path=None):
+        paths_dict = self.partial_interface_files[partial_interface_name]
+        paths_dict['full_paths'].append(full_path)
+        if this_include_path:
+            paths_dict['include_paths'].append(this_include_path)
+
+    def compute_info(self, idl_filename):
+        """Reads an idl file and compute information which is required by the
+        binding code generation."""
+        definitions = self.reader.read_idl_file(idl_filename)
+        if len(definitions.interfaces) > 0:
+            definition = next(definitions.interfaces.itervalues())
+            interface_info = {
+                'is_callback_interface': definition.is_callback,
+                'is_dictionary': False,
+                # Interfaces that are referenced (used as types) and that we
+                # introspect during code generation (beyond interface-level
+                # data ([ImplementedAs], is_callback_interface, ancestors, and
+                # inherited extended attributes): deep dependencies.
+                # These cause rebuilds of referrers, due to the dependency,
+                # so these should be minimized; currently only targets of
+                # [PutForwards].
+                'referenced_interfaces': get_put_forward_interfaces_from_definition(definition),
+            }
+        elif len(definitions.dictionaries) > 0:
+            definition = next(definitions.dictionaries.itervalues())
+            interface_info = {
+                'is_callback_interface': False,
+                'is_dictionary': True,
+                'referenced_interfaces': None,
+            }
+        else:
+            raise Exception('IDL file must contain one interface or dictionary')
+
+        extended_attributes = definition.extended_attributes
+        implemented_as = extended_attributes.get('ImplementedAs')
+        full_path = os.path.realpath(idl_filename)
+        this_include_path = None if 'NoImplHeader' in extended_attributes else include_path(idl_filename, implemented_as)
+        if definition.is_partial:
+            # We don't create interface_info for partial interfaces, but
+            # adds paths to another dict.
+            self.add_paths_to_partials_dict(definition.name, full_path, this_include_path)
+            return
+
+        # 'implements' statements can be included in either the file for the
+        # implement*ing* interface (lhs of 'implements') or implement*ed* interface
+        # (rhs of 'implements'). Store both for now, then merge to implement*ing*
+        # interface later.
+        left_interfaces, right_interfaces = get_implements_from_definitions(
+            definitions, definition.name)
+
+        interface_info.update({
+            'extended_attributes': extended_attributes,
+            'full_path': full_path,
+            'implemented_as': implemented_as,
+            'implemented_by_interfaces': left_interfaces,
+            'implements_interfaces': right_interfaces,
+            'include_path': this_include_path,
+            # FIXME: temporary private field, while removing old treatement of
+            # 'implements': http://crbug.com/360435
+            'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes,
+            'parent': definition.parent,
+            'relative_dir': relative_dir_posix(idl_filename),
+        })
+        self.interfaces_info[definition.name] = interface_info
+
+    def get_info_as_dict(self):
+        """Returns info packaged as a dict."""
+        return {
+            'interfaces_info': self.interfaces_info,
+            # Can't pickle defaultdict, convert to dict
+            'partial_interface_files': dict(self.partial_interface_files),
         }
-    elif len(definitions.dictionaries) > 0:
-        definition = next(definitions.dictionaries.itervalues())
-        interface_info = {
-            'is_callback_interface': False,
-            'is_dictionary': True,
-            'referenced_interfaces': None,
-        }
-    else:
-        raise Exception('IDL file must contain one interface or dictionary')
-
-    extended_attributes = definition.extended_attributes
-    implemented_as = extended_attributes.get('ImplementedAs')
-    full_path = os.path.realpath(idl_filename)
-    this_include_path = None if 'NoImplHeader' in extended_attributes else include_path(idl_filename, implemented_as)
-    if definition.is_partial:
-        # We don't create interface_info for partial interfaces, but
-        # adds paths to another dict.
-        add_paths_to_partials_dict(definition.name, full_path, this_include_path)
-        return
-
-    # 'implements' statements can be included in either the file for the
-    # implement*ing* interface (lhs of 'implements') or implement*ed* interface
-    # (rhs of 'implements'). Store both for now, then merge to implement*ing*
-    # interface later.
-    left_interfaces, right_interfaces = get_implements_from_definitions(definitions, definition.name)
-
-    interface_info.update({
-        'extended_attributes': extended_attributes,
-        'full_path': full_path,
-        'implemented_as': implemented_as,
-        'implemented_by_interfaces': left_interfaces,
-        'implements_interfaces': right_interfaces,
-        'include_path': this_include_path,
-        # FIXME: temporary private field, while removing old treatement of
-        # 'implements': http://crbug.com/360435
-        'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes,
-        'parent': definition.parent,
-        'relative_dir': relative_dir_posix(idl_filename),
-    })
-    interfaces_info[definition.name] = interface_info
-
-
-def info_individual():
-    """Returns info packaged as a dict."""
-    return {
-        'interfaces_info': interfaces_info,
-        # Can't pickle defaultdict, convert to dict
-        'partial_interface_files': dict(partial_interface_files),
-    }
 
 
 ################################################################################
 
 def main():
     options, args = parse_options()
 
     # Static IDL files are passed in a file (generated at GYP time), due to OS
     # command line length limits
     idl_files = read_file_to_list(options.idl_files_list)
     # Generated IDL files are passed at the command line, since these are in the
     # build directory, which is determined at build time, not GYP time, so these
     # cannot be included in the file listing static files
     idl_files.extend(args)
 
     # Compute information for individual files
     # Information is stored in global variables interfaces_info and
     # partial_interface_files.
-    reader = IdlReader(interfaces_info=None, outputdir=options.cache_directory)
+    info_generator = InterfaceInfoGeneratorIndividual(options.cache_directory)
     for idl_filename in idl_files:
-        compute_info_individual(idl_filename, reader)
+        info_generator.compute_info(idl_filename)
 
     write_pickle_file(options.interfaces_info_file,
-                      info_individual(),
+                      info_generator.get_info_as_dict(),
                       options.write_file_only_if_changed)
 
 
 if __name__ == '__main__':
     sys.exit(main())