Minor JSON Schema compiler cleanup to remove Property.FromJSON and make

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 copy
 import os.path
 import re
 
 from json_parse import OrderedDict
 
@@ skipping 204 matching lines @@
     self.optional = json.get('optional', False)
     self.parent = parent
     self.nocompile = json.get('nocompile')
     options = json.get('options', {})
     self.conditions = options.get('conditions', [])
     self.actions = options.get('actions', [])
     self.supports_listeners = options.get('supportsListeners', True)
     self.supports_rules = options.get('supportsRules', False)
 
     def GeneratePropertyFromParam(p):
-      return Property.FromJSON(self, p['name'], p, namespace, origin)
+      return Property(self, p['name'], p, namespace, origin)
 
     self.filters = [GeneratePropertyFromParam(filter)
                     for filter in json.get('filters', [])]
     callback_param = None
     for param in json.get('parameters', []):
       if param.get('type') == 'function':
         if callback_param:
           # No ParseException because the webstore has this.
           # Instead, pretend all intermediate callbacks are properties.
           self.params.append(GeneratePropertyFromParam(callback_param))
         callback_param = param
       else:
         self.params.append(GeneratePropertyFromParam(param))
 
     if callback_param:
       self.callback = Function(self,
                                callback_param['name'],
                                callback_param,
                                namespace,
                                Origin(from_client=True))
 
     self.returns = None
     if 'returns' in json:
-      self.returns = Property.FromJSON(
-          self, 'return', json['returns'], namespace, origin)
+      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
   """
-
-  @staticmethod
-  def FromJSON(parent, name, json, namespace, origin):
+  def __init__(self, parent, name, json, namespace, origin):
     """Creates a Property from JSON.
     """
-    opt_args = {}
-    if 'description' in json:
-      opt_args['description'] = json['description']
-    if 'optional' in json:
-      opt_args['optional'] = json.get('optional')
-    if 'isInstanceOf' in json:
-      opt_args['instance_of'] = json.get('isInstanceOf')
+    self.parent = parent
+    self.name = name
+    self._unix_name = UnixName(self.name)
+    self._unix_name_used = False
+    self.origin = origin
+    self.simple_name = _StripNamespace(self.name, namespace)
+    self.description = json.get('description', None)
+    self.optional = json.get('optional', None)
+    self.instance_of = json.get('isInstanceOf', None)
 
     # HACK: only support very specific value types.
     is_allowed_value = (
         '$ref' not in json and
         ('type' not in json or json['type'] == 'integer'
                             or json['type'] == 'string'))
 
+    self.value = None
     if 'value' in json and is_allowed_value:
-      value = json['value']
-      opt_args['value'] = value
+      self.value = json['value']
       if 'type' not in json:
         # Sometimes the type of the value is left out, and we need to figure
         # it out for ourselves.
-        if isinstance(value, int):
+        if isinstance(self.value, int):
           json['type'] = 'integer'
-        elif isinstance(value, basestring):
+        elif isinstance(self.value, basestring):
           json['type'] = 'string'
         else:
           # TODO(kalman): support more types as necessary.
           raise ParseException(
-              parent, '"%s" is not a supported type for "value"' % type(value))
+              parent,
+              '"%s" is not a supported type for "value"' % type(self.value))
 
-    type_ = Type(parent, name, json, namespace, origin)
-    return Property(parent,
-                    name,
-                    namespace,
-                    type_,
-                    origin,
-                    **opt_args);
-
-  def __init__(self,
-               parent,
-               name,
-               namespace,
-               type_,
-               origin,
-               description=None,
-               optional=False,
-               returns=None,
-               instance_of=None,
-               value=None):
-    """Directly initializes the fields of the Property.
-    """
-    self.name = name
-    self.simple_name = _StripNamespace(self.name, namespace)
-    self._unix_name = UnixName(self.name)
-    self._unix_name_used = False
-    self.optional = optional
-    self.description = description
-    self.parent = parent
-    self.origin = origin
-    if not isinstance(type_, Type):
-      raise ValueError("not Type: %s" % type_)
-    self.type_ = type_
-    self.returns = returns
-    if instance_of is not None:
-      self.instance_of = instance_of
-    self.value = value
+    self.type_ = Type(parent, name, json, namespace, origin)
 
   def GetUnixName(self):
     """Gets the property's unix_name. Raises AttributeError if not set.
     """
     if not self._unix_name:
       raise AttributeError('No unix_name set on %s' % self.name)
     self._unix_name_used = True
     return self._unix_name
 
   def SetUnixName(self, unix_name):
@@ skipping 118 matching lines @@
                      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.FromJSON(
-        parent, name, property_json, namespace, origin)
+    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