Initial code generation for features.

tools/json_schema_compiler/model.py

 # 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.
 
 import os.path
 
 from json_parse import OrderedDict
 from memoize import memoize
 
+
 class ParseException(Exception):
   """Thrown when data in the model is invalid.
   """
   def __init__(self, parent, message):
     hierarchy = _GetModelHierarchy(parent)
     hierarchy.append(message)
     Exception.__init__(
         self, 'Model parse exception at:\n' + '\n'.join(hierarchy))
 
+
 class Model(object):
   """Model of all namespaces that comprise an API.
 
   Properties:
   - |namespaces| a map of a namespace name to its model.Namespace
   """
   def __init__(self):
     self.namespaces = {}
 
   def AddNamespace(self, json, source_file, include_compiler_options=False):
     """Add a namespace's json to the model and returns the namespace.
     """
     namespace = Namespace(json,
                           source_file,
                           include_compiler_options=include_compiler_options)
     self.namespaces[namespace.name] = namespace
     return namespace
 
+
+class ComplexFeature(object):
+  """A complex feature which may be made of several simple features.
+
+  Properties:
+  - |name| the name of the feature
+  - |unix_name| the unix_name of the feature
+  - |feature_list| a list of simple features which make up the feature
+  """
+  def __init__(self, feature_name, features, source_file):

[not at google - send to devlin, 2013/09/17 01:28:07]

I thought you weren't using the source_file here anymore, same below?

[dhnishi (use Chromium), 2013/09/17 18:17:47]

That is correct. Extraneous parameter removed.

+    self.name = feature_name
+    self.unix_name = UnixName(self.name)
+    self.feature_list = []
+    if isinstance(features, dict):

[not at google - send to devlin, 2013/09/17 01:28:07]

instead of this, have a factory method defined in here, like

def CreateFeature(name, model):
  if isinstance(model, dict):
    return SimpleFeature(name, model)
  return ComplexFeature(
      name, [SimpleFeature(name, child) for child in model])

something like that.

and call that from feature_compiler.

[dhnishi (use Chromium), 2013/09/17 18:17:47]

Done.

+      self.feature_list.append(SimpleFeature(feature_name, features,
+          source_file))
+    else:
+      self.feature_list += [SimpleFeature(feature_name, single_def, source_file)
+                            for single_def in features]
+
+
+class SimpleFeature(object):
+  """A simple feature, which can make up a complex feature, as specified in
+  files such as chrome/common/extensions/api/_permission_features.json.
+
+  Properties:
+  - |name| the name of the feature
+  - |unix_name| the unix_name of the feature
+  - |source_file| the file that contained the namespace definition
+  - |channel| the channel where the feature is released
+  - |extension_types| the types which can use the feature
+  - |whitelist| a list of extensions allowed to use the feature
+  """
+  def __init__(self, feature_name, feature_def, source_file):
+    self.name = feature_name
+    self.unix_name = UnixName(self.name)
+    self.source_file = source_file
+    self.channel = feature_def['channel']
+    self.extension_types = feature_def['extension_types']
+    self.whitelist = feature_def.get('whitelist')
+
+
 class Namespace(object):
   """An API namespace.
 
   Properties:
   - |name| the name of the namespace
   - |description| the description of the namespace
   - |unix_name| the unix_name of the namespace
   - |source_file| the file that contained the namespace definition
   - |source_file_dir| the directory component of |source_file|
   - |source_file_filename| the filename component of |source_file|
@@ skipping 20 matching lines @@
     self.parent = None
     self.platforms = _GetPlatforms(json)
     toplevel_origin = Origin(from_client=True, from_json=True)
     self.types = _GetTypes(self, json, self, toplevel_origin)
     self.functions = _GetFunctions(self, json, self)
     self.events = _GetEvents(self, json, self)
     self.properties = _GetProperties(self, json, self, toplevel_origin)
     self.compiler_options = (json.get('compiler_options', {})
         if include_compiler_options else {})
 
+
 class Origin(object):
   """Stores the possible origin of model object as a pair of bools. These are:
 
   |from_client| indicating that instances can originate from users of
                 generated code (for example, function results), or
   |from_json|   indicating that instances can originate from the JSON (for
                 example, function parameters)
 
   It is possible for model objects to originate from both the client and json,
   for example Types defined in the top-level schema, in which case both
   |from_client| and |from_json| would be True.
   """
   def __init__(self, from_client=False, from_json=False):
     if not from_client and not from_json:
       raise ValueError('One of from_client or from_json must be true')
     self.from_client = from_client
     self.from_json = from_json
 
+
 class Type(object):
   """A Type defined in the json.
 
   Properties:
   - |name| the type name
   - |namespace| the Type's namespace
   - |description| the description of the type (if provided)
   - |properties| a map of property unix_names to their model.Property
   - |functions| a map of function names to their model.Function
   - |events| a map of event names to their model.Event
@@ skipping 86 matching lines @@
         self.additional_properties = None
     elif json_type == 'function':
       self.property_type = PropertyType.FUNCTION
       # Sometimes we might have an unnamed function, e.g. if it's a property
       # of an object. Use the name of the property in that case.
       function_name = json.get('name', name)
       self.function = Function(self, function_name, json, namespace, origin)
     else:
       raise ParseException(self, 'Unsupported JSON type %s' % json_type)
 
+
 class Function(object):
   """A Function defined in the API.
 
   Properties:
   - |name| the function name
   - |platforms| if not None, the list of platforms that the function is
                 available to
   - |params| a list of parameters to the function (order matters). A separate
              parameter is used for each choice of a 'choices' parameter
   - |description| a description of the function (if provided)
@@ skipping 50 matching lines @@
                                Origin(from_client=True))
 
     self.returns = None
     if 'returns' in json:
       self.returns = Type(self,
                           '%sReturnType' % name,
                           json['returns'],
                           namespace,
                           origin)
 
+
 class Property(object):
   """A property of a type OR a parameter to a function.
   Properties:
   - |name| name of the property as in the json. This shouldn't change since
     it is the key used to access DictionaryValues
   - |unix_name| the unix_style_name of the property. Used as variable name
   - |optional| a boolean representing whether the property is optional
   - |description| a description of the property (if provided)
   - |type_| the model.Type of this property
   - |simple_name| the name of this Property without a namespace
@@ skipping 51 matching lines @@
       return
     if self._unix_name_used:
       raise AttributeError(
           'Cannot set the unix_name on %s; '
           'it is already used elsewhere as %s' %
           (self.name, self._unix_name))
     self._unix_name = unix_name
 
   unix_name = property(GetUnixName, SetUnixName)
 
+
 class _Enum(object):
   """Superclass for enum types with a "name" field, setting up repr/eq/ne.
   Enums need to do this so that equality/non-equality work over pickling.
   """
   @staticmethod
   def GetAll(cls):
     """Yields all _Enum objects declared in |cls|.
     """
     for prop_key in dir(cls):
       prop_value = getattr(cls, prop_key)
       if isinstance(prop_value, _Enum):
         yield prop_value
 
   def __init__(self, name):
     self.name = name
 
   def __eq__(self, other):
     return type(other) == type(self) and other.name == self.name
   def __ne__(self, other):
     return not (self == other)
 
   def __repr__(self):
     return self.name
 
   def __str__(self):
     return repr(self)
 
+
 class _PropertyTypeInfo(_Enum):
   def __init__(self, is_fundamental, name):
     _Enum.__init__(self, name)
     self.is_fundamental = is_fundamental
 
+
 class PropertyType(object):
   """Enum of different types of properties/parameters.
   """
   ANY = _PropertyTypeInfo(False, "any")
   ARRAY = _PropertyTypeInfo(False, "array")
   BINARY = _PropertyTypeInfo(False, "binary")
   BOOLEAN = _PropertyTypeInfo(True, "boolean")
   CHOICES = _PropertyTypeInfo(False, "choices")
   DOUBLE = _PropertyTypeInfo(True, "double")
   ENUM = _PropertyTypeInfo(False, "enum")
   FUNCTION = _PropertyTypeInfo(False, "function")
   INT64 = _PropertyTypeInfo(True, "int64")
   INTEGER = _PropertyTypeInfo(True, "integer")
   OBJECT = _PropertyTypeInfo(False, "object")
   REF = _PropertyTypeInfo(False, "ref")
   STRING = _PropertyTypeInfo(True, "string")
 
+
 @memoize
 def UnixName(name):
   '''Returns the unix_style name for a given lowerCamelCase string.
   '''
   unix_name = []
   for i, c in enumerate(name):
     if c.isupper() and i > 0 and name[i - 1] != '_':
       # Replace lowerUpper with lower_Upper.
       if name[i - 1].islower():
         unix_name.append('_')
       # Replace ACMEWidgets with ACME_Widgets
       elif i + 1 < len(name) and name[i + 1].islower():
         unix_name.append('_')
     if c == '.':
       # Replace hello.world with hello_world.
       unix_name.append('_')
     else:
       # Everything is lowercase.
       unix_name.append(c.lower())
   return ''.join(unix_name)
 
+
 def _StripNamespace(name, namespace):
   if name.startswith(namespace.name + '.'):
     return name[len(namespace.name + '.'):]
   return name
 
+
 def _GetModelHierarchy(entity):
   """Returns the hierarchy of the given model entity."""
   hierarchy = []
   while entity is not None:
     hierarchy.append(getattr(entity, 'name', repr(entity)))
     if isinstance(entity, Namespace):
       hierarchy.insert(0, '  in %s' % entity.source_file)
     entity = getattr(entity, 'parent', None)
   hierarchy.reverse()
   return hierarchy
 
+
 def _GetTypes(parent, json, namespace, origin):
   """Creates Type objects extracted from |json|.
   """
   types = OrderedDict()
   for type_json in json.get('types', []):
     type_ = Type(parent, type_json['id'], type_json, namespace, origin)
     types[type_.name] = type_
   return types
 
+
 def _GetFunctions(parent, json, namespace):
   """Creates Function objects extracted from |json|.
   """
   functions = OrderedDict()
   for function_json in json.get('functions', []):
     function = Function(parent,
                         function_json['name'],
                         function_json,
                         namespace,
                         Origin(from_json=True))
     functions[function.name] = function
   return functions
 
+
 def _GetEvents(parent, json, namespace):
   """Creates Function objects generated from the events in |json|.
   """
   events = OrderedDict()
   for event_json in json.get('events', []):
     event = Function(parent,
                      event_json['name'],
                      event_json,
                      namespace,
                      Origin(from_client=True))
     events[event.name] = event
   return events
 
+
 def _GetProperties(parent, json, namespace, origin):
   """Generates Property objects extracted from |json|.
   """
   properties = OrderedDict()
   for name, property_json in json.get('properties', {}).items():
     properties[name] = Property(parent, name, property_json, namespace, origin)
   return properties
 
+
 class _PlatformInfo(_Enum):
   def __init__(self, name):
     _Enum.__init__(self, name)
 
+
 class Platforms(object):
   """Enum of the possible platforms.
   """
   CHROMEOS = _PlatformInfo("chromeos")
   CHROMEOS_TOUCH = _PlatformInfo("chromeos_touch")
   LINUX = _PlatformInfo("linux")
   MAC = _PlatformInfo("mac")
   WIN = _PlatformInfo("win")
 
+
 def _GetPlatforms(json):
   if 'platforms' not in json:
     return None
   platforms = []
   for platform_name in json['platforms']:
     for platform_enum in _Enum.GetAll(Platforms):
       if platform_name == platform_enum.name:
         platforms.append(platform_enum)
         break
   return platforms