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
 
+
+def CreateFeature(name, model):
+  if isinstance(model, dict):
+    return SimpleFeature(name, model)
+  return ComplexFeature(name, [SimpleFeature(name, child) for child in model])
+
+
+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):
+    self.name = feature_name
+    self.unix_name = UnixName(self.name)
+    self.feature_list = 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
+  - |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):
+    self.name = feature_name
+    self.unix_name = UnixName(self.name)
+    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 21 matching lines @@
     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 {})
     self.documentation_options = json.get('documentation_options', {})
 
+
 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
   - |deprecated| a reason and possible alternative for a deprecated function
@@ skipping 53 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 92 matching lines @@
     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 or json['platforms'] == None:
     return None
   # Sanity check: platforms should not be an empty list.
   if not json['platforms']:
     raise ValueError('"platforms" cannot be an empty list')
   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