JSON Schema Compiler: Added event compilation.

tools/json_schema_compiler/cc_generator.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.
 
 from code import Code
 from model import PropertyType
 import any_helper
 import cpp_util
 import model
 import schema_util
@@ skipping 68 matching lines @@
       (c.Append('//')
         .Append('// Functions')
         .Append('//')
         .Append()
       )
     for function in self._namespace.functions.values():
       (c.Concat(self._GenerateFunction(
           cpp_util.Classname(function.name), function))
         .Append()
       )
+    if self._namespace.events:
+      (c.Append('//')
+        .Append('// Events')
+        .Append('//')
+        .Append()
+      )
+    for event in self._namespace.events.values():
+      (c.Concat(self._GenerateCallbackCreate(
+          cpp_util.Classname(event.name), event))
+        .Append()
+      )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
       .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
     )
-    # TODO(calamity): Events

[not at google - send to devlin, 2012/07/03 14:21:39]

hooray!

     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       for function in type_.functions.values():
@@ skipping 169 matching lines @@
           function.params))
       (c.Append('%(cpp_namespace)s::Params::Params() {}')
         .Append('%(cpp_namespace)s::Params::~Params() {}')
         .Append()
         .Concat(self._GenerateFunctionParamsCreate(cpp_namespace, function))
         .Append()
       )
 
     # Result::Create function
     if function.callback:
-      c.Concat(self._GenerateFunctionResultCreate(cpp_namespace, function))
+      c.Concat(self._GenerateCallbackCreate(

[not at google - send to devlin, 2012/07/03 14:21:39]

Some of the function names in json_schema_compiler are quite vague / hard to
parse. Let's try to break that tradition, like "GenerateCreateCallbackArguments"
or something.

[Matt Tytel, 2012/07/11 02:08:50]

Done.

+          "%s::Result" % cpp_namespace, function.callback))
 
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     return c
 
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the |StringValue|
     representation of an enum.
     """
     c = Code()
@@ skipping 322 matching lines @@
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, [param.item_type]))
       elif param.type_ == PropertyType.CHOICES:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, param.choices.values()))
       elif param.type_ == PropertyType.ENUM:
         c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
         c.Append()
     return c
 
-  def _GenerateFunctionResultCreate(self, cpp_namespace, function):
-    """Generate function to create a Result given the return value.
+  def _GenerateCallbackCreate(self, function_scope, callback):

[not at google - send to devlin, 2012/07/03 14:21:39]

the name "function_scope" keeps tripping me up. just make it function_name?

document args while you're here?

[Matt Tytel, 2012/07/11 02:08:50]

In this meaning, for a function A::B::C(), A::B is the passed in function_scope.
I don't think function_name captures this, any alternatives?

+    """Generate function to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Result::Create
+    E.g for event "Gar", generate Gar::Create

[not at google - send to devlin, 2012/07/03 14:21:39]

ITYM "Baz".

[Matt Tytel, 2012/07/11 02:08:50]

ITYR
Done.

     """
     c = Code()
-    params = function.callback.params
+    params = callback.params
 
     if not params:
-      (c.Append('Value* %s::Result::Create() {' % cpp_namespace)
+      (c.Append('Value* %s::Create() {' % function_scope)
         .Append('  return Value::CreateNullValue();')
         .Append('}')
       )
     else:
       expanded_params = self._cpp_type_generator.GetExpandedChoicesInParams(
           params)
-      c.Concat(self._GeneratePropertyFunctions(
-          cpp_namespace + '::Result', expanded_params))
+      c.Concat(self._GeneratePropertyFunctions(function_scope, expanded_params))
 
       # If there is a single parameter, this is straightforward. However, if
       # the callback parameter is of 'choices', this generates a Create method
       # for each choice. This works because only 1 choice can be returned at a
       # time.

[not at google - send to devlin, 2012/07/03 14:21:39]

This will, sadly, require some more reshuffling to support events than this.

It's kind of explained in the comment above here, but "expanded_params" comes
from GetExpandedChoicesInParams, which returns a list of "fake" parameter
objects representing each "choice"... if the parameter is of type "choices".
Otherwise it returns just the singleton parameter.

The reason this works is because callbacks can only ever take a single argument.
By, err, odd convention, and because that's what ExtensionFunction expects.
Which is why these methods return Value not ListValue.

On the other hand, event arguments take *multiple* arguments. A more
general/sensible system, and it's what ExtensionEventRouter expects (actually it
expects JSON of a list, to add to the confusion).

I think the solution to this problem is still mostly what you've done, you'll
just need to do a bit more.

Firstly, make this method accept a flag like single_argument, and pass that
through when you generate the function. We might as well make the default
behaviour the "sensible" one i.e. generating the full arguments... particularly
since you're changing function callbacks to be able to take multiple arguments?

If single_argument is False (i.e. events case), the return type should be
scoped_ptr<ListValue>. This code will also generally have to change to accept
multiple arguments in Create, know how to make up a ListValue, etc.

If single_argument is True (i.e. functions case), the return type should be
scoped_ptr<Value> and asserted that there's only a single parameter to the
callback.

(note that we can't just say if len(params) == 1 because many events have a
single parameter but we still need to generate ListValue for them)

That leaves the problem with the expanded params stuff. To solve this *properly*
the algorithm which expands choices will need to expand *all permutations* of
choices... e.g. if an event has 5 arguments, each with 3 choices, that's a lot
of stuff to generate :\ not that it would actually ever happen, hopefully, but
you get the idea.

[Matt Tytel, 2012/07/11 02:08:50]

Done.

       for param in expanded_params:
         if param.type_ == PropertyType.ANY:
           # Generation of Value* Create(Value*) is redundant.
           continue
         # We treat this argument as 'required' to avoid wrapping it in a
         # scoped_ptr if it's optional.
         param_copy = param.Copy()
         param_copy.optional = False
-        c.Sblock('Value* %(cpp_namespace)s::Result::Create(const %(arg)s) {')
+        c.Sblock('Value* %(function_scope)s::Create(const %(arg)s) {')

[not at google - send to devlin, 2012/07/03 14:21:39]

possible cleanup: make this return scoped_ptr<Value>

you might want to do this in a separate change, since there will be a bunch of
other code to update... thought it'd just be a matter of changing cases of

result_.reset(Foo::Result::Create(...));

with

result_ = Foo::Result::Create(...);

which is quite nice actually, and everybody will thank you.

[Matt Tytel, 2012/07/11 02:08:50]

I really like this, I'll file a separate issue if you haven't already.

         c.Append('return %s;' %
            self._CreateValueFromProperty(param_copy, param_copy.unix_name))
         c.Eblock('}')
         c.Substitute({
-            'cpp_namespace': cpp_namespace,
+            'function_scope': function_scope,
             'arg': cpp_util.GetParameterDeclaration(
                 param_copy, self._cpp_type_generator.GetType(param_copy))
         })
 
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
     E.g for optional enum "state", generate dst->state = STATE_NONE;
@@ skipping 23 matching lines @@
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
   def _IsFundamentalOrFundamentalRef(self, prop):
     """Determines if this property is a Fundamental type or is a ref to a
     Fundamental type.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_.
         is_fundamental)