Add additional restriction to policy schema internal (part1)

components/policy/tools/generate_policy_source.py

 #!/usr/bin/env python
 # 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.
 
 '''python %prog [options] platform chromium_os_flag template
 
 platform specifies which platform source is being generated for
   and can be one of (win, mac, linux)
 chromium_os_flag should be 1 if this is a Chromium OS build
@@ skipping 239 matching lines @@
 
 # A mapping of the simple schema types to base::Value::Types.
 SIMPLE_SCHEMA_NAME_MAP = {
   'boolean': 'TYPE_BOOLEAN',
   'integer': 'TYPE_INTEGER',
   'null'   : 'TYPE_NULL',
   'number' : 'TYPE_DOUBLE',
   'string' : 'TYPE_STRING',
 }
 
-
 class SchemaNodesGenerator:
   """Builds the internal structs to represent a JSON schema."""
 
   def __init__(self, shared_strings):
     """Creates a new generator.
 
     |shared_strings| is a map of strings to a C expression that evaluates to
     that string at runtime. This mapping can be used to reuse existing string
     constants."""
     self.shared_strings = shared_strings
     self.schema_nodes = []
     self.property_nodes = []
     self.properties_nodes = []
+    self.restriction_nodes = []
+    self.int_enums = []
+    self.string_enums = []
     self.simple_types = {
       'boolean': None,
       'integer': None,
       'null': None,
       'number': None,
       'string': None,
     }
     self.stringlist_type = None
 
   def GetString(self, s):
     return self.shared_strings[s] if s in self.shared_strings else '"%s"' % s
 
   def AppendSchema(self, type, extra, comment=''):
     index = len(self.schema_nodes)
     self.schema_nodes.append((type, extra, comment))
     return index
 
+  def AppendRestriction(self, first, second):
+    index = len(self.restriction_nodes)
+    self.restriction_nodes.append((first, second))
+    return index
+
   def GetSimpleType(self, name):
     if self.simple_types[name] == None:
       self.simple_types[name] = self.AppendSchema(
           SIMPLE_SCHEMA_NAME_MAP[name],
           -1,
           'simple type: ' + name)
     return self.simple_types[name]
 
   def GetStringList(self):
     if self.stringlist_type == None:
       self.stringlist_type = self.AppendSchema(
           'TYPE_LIST',
           self.GetSimpleType('string'),
           'simple type: stringlist')
     return self.stringlist_type
 
+  def SchemaHaveRestriction(self, schema):
+    return 'minimum' in schema or 'maximum' in schema or 'enum' in schema
+
+  def GetEnumIntegerType(self, schema):
+    offset_begin = len(self.int_enums)

[Joao da Silva, 2014/01/16 10:56:34]

Add a check at the beginning:

  assert all(type(x) == int for x in schema['enum'])

[Joao da Silva, 2014/01/16 10:56:34]

You had a nice idea about converting enums into ranges when possible. How about
this:

enums = sorted(schema['enums'])
if max(enums) - min(enums) + 1 == len(enums):
  index = self.AppendRestriction(min(enums), max(enums))
  return self.AppendSchema('TYPE_INTEGER', index, name)

(see below about the "name" variable)

[binjin, 2014/01/17 14:29:01]

Done.

[binjin, 2014/01/17 14:29:01]

Done.

+    self.int_enums += schema['enum']
+    offset_end = len(self.int_enums)
+    return self.AppendSchema('TYPE_INTEGER',
+        self.AppendRestriction(offset_begin, offset_end),
+        'integer with enumeration restriction')

[Joao da Silva, 2014/01/16 10:56:34]

Use "name" (from Generate()) for the 3rd argument (which is the comment in the
output). You'll have to pass it as an argument to this function

[binjin, 2014/01/17 14:29:01]

Done.

+
+  def GetEnumStringType(self, schema):
+    offset_begin = len(self.string_enums)

[Joao da Silva, 2014/01/16 10:56:34]

Add a check at the beginning:

  assert all(type(x) == str for x in schema['enum']

[binjin, 2014/01/17 14:29:01]

Done.

+    self.string_enums += schema['enum']
+    offset_end = len(self.string_enums)
+    return self.AppendSchema('TYPE_STRING',
+        self.AppendRestriction(offset_begin, offset_end),
+        'string with enumeration restriction')

[Joao da Silva, 2014/01/16 10:56:34]

Use "name" from Generate() for the 3rd argument

[binjin, 2014/01/17 14:29:01]

Done.

+
+  def GetEnumType(self, schema):
+    if len(schema['enum']) == 0:
+      raise RuntiemError('Empty enumeration in %s' % schema['name'])

[Joao da Silva, 2014/01/16 10:56:34]

RuntimeError

schema['name'] does not exist; you have to pass "name" from Generate into this
function.

You can also use assertions for this:

  assert len(schema['enum']) > 0, 'Empty enumeration in %s' % name

[binjin, 2014/01/17 14:29:01]

Done.

+    elif schema['type'] == 'integer':
+      return self.GetEnumIntegerType(schema)
+    elif schema['type'] == 'string':
+      return self.GetEnumStringType(schema)
+    else:
+      raise RuntimeError('Unknown enumeration type in %s' % schema['name'])

[Joao da Silva, 2014/01/16 10:56:34]

schema['name'] does not exist

[binjin, 2014/01/17 14:29:01]

Done.

+
+  def GetRangedType(self, schema):
+    if schema['type'] != 'integer':
+      raise RuntimeError('Unknown ranged type in %s' % schema['name'])

[Joao da Silva, 2014/01/16 10:56:34]

schema['name' does not exist; pass "name" from Generate to this function

[binjin, 2014/01/17 14:29:01]

Done.

+    min_value_set, max_value_set = False, False
+    if 'minimum' in schema:
+      min_value = int(schema['minimum'])
+      min_value_set = True
+    if 'maximum' in schema:
+      max_value = int(schema['minimum'])
+      max_value_set = True
+    if min_value_set and max_value_set and min_value > max_value:
+      raise RuntimeError('Invalid ranged type in %s' % schema['name'])

[Joao da Silva, 2014/01/16 10:56:34]

schema['name'] does not exist

[binjin, 2014/01/17 14:29:01]

Done.

+    index = self.AppendRestriction(
+        str(max_value) if max_value_set else 'INT_MAX',
+        str(min_value) if min_value_set else 'INT_MIN')
+    return self.AppendSchema('TYPE_INTEGER',
+        index,
+        'integer with ranged restriction')

[Joao da Silva, 2014/01/16 10:56:34]

Use "name" for the 3rd argument

[binjin, 2014/01/17 14:29:01]

Done.

+
   def Generate(self, schema, name):
     """Generates the structs for the given schema.
 
     |schema|: a valid JSON schema in a dictionary.
     |name|: the name of the current node, for the generated comments."""
-    # Simple types use shared nodes.
     if schema['type'] in self.simple_types:
-      return self.GetSimpleType(schema['type'])
+      if not self.SchemaHaveRestriction(schema):
+        # Simple types use shared nodes.
+        return self.GetSimpleType(schema['type'])
+      elif 'enum' in schema:
+        return self.GetEnumType(schema)
+      else:
+        return self.GetRangedType(schema)
 
     if schema['type'] == 'array':
       # Special case for lists of strings, which is a common policy type.
       if schema['items']['type'] == 'string':
         return self.GetStringList()
       return self.AppendSchema(
           'TYPE_LIST',
           self.Generate(schema['items'], 'items of ' + name))
     elif schema['type'] == 'object':
       # Reserve an index first, so that dictionaries come before their
@@ skipping 48 matching lines @@
       key += ','
       f.write('  { %-50s %7d },\n' % (key, schema))
     f.write('};\n\n')
 
     f.write('const internal::PropertiesNode kProperties[] = {\n'
             '//  Begin    End  Additional Properties\n')
     for node in self.properties_nodes:
       f.write('  { %5d, %5d, %5d },  // %s\n' % node)
     f.write('};\n\n')
 
+    f.write('const internal::RestrictionNode kRestrictionNodes[] = {\n')
+    for first, second in self.restriction_nodes:
+      f.write('{{%s,%s}},\n' % (first, second))

[Joao da Silva, 2014/01/16 10:56:34]

Use spacing and a header comment like the arrays above, so that the output is
more readable

[binjin, 2014/01/17 14:29:01]

Done.

+    f.write('};\n\n')
+
+    f.write('const int kIntegerEnumerations[] = {\n')
+    for possible_values in self.int_enums:
+      f.write('%d,\n' % possible_values)

[Joao da Silva, 2014/01/16 10:56:34]

Indent with 2 spaces

[binjin, 2014/01/17 14:29:01]

Done.

+    f.write('};\n\n')
+
+    f.write('const char* kStringEnumerations[] = {\n')
+    for possible_values in self.string_enums:
+      f.write('%s\n' % self.GetString(possible_values))

[Joao da Silva, 2014/01/16 10:56:34]

Indent with 2 spaces

[binjin, 2014/01/17 14:29:01]

Done.

+    f.write('};\n\n')
+
     f.write('const internal::SchemaData kChromeSchemaData = {\n'
             '  kSchemas,\n'
             '  kPropertyNodes,\n'
             '  kProperties,\n'
+            '  kRestrictionNodes,\n'
+            '  kIntegerEnumerations,\n'
+            '  kStringEnumerations,\n'

[Joao da Silva, 2014/01/16 10:56:34]

Compilation fails when an array is empty. So if any of these is empty this must
be set to NULL instead. You should also test the size of the arrays before
outputting them above.

That happens when compiling on platforms that don't include any of the
enum/range policies (e.g. on iOS). All platforms use the other structures, so
that's why they don't have similar tests.

[binjin, 2014/01/17 14:29:01]

Done.

             '};\n\n')
 
 
 def _WritePolicyConstantSource(policies, os, f):
   f.write('#include "policy/policy_constants.h"\n'
           '\n'
           '#include <algorithm>\n'
+          '#include <climits>\n'
           '\n'
           '#include "base/logging.h"\n'
           '#include "components/policy/core/common/schema_internal.h"\n'
           '\n'
           'namespace policy {\n'
           '\n'
           'namespace {\n'
           '\n')
 
   # Generate the Chrome schema.
@@ skipping 335 matching lines @@
 def _WriteCloudPolicyDecoder(policies, os, f):
   f.write(CPP_HEAD)
   for policy in policies:
     if policy.is_supported and not policy.is_device_only:
       _WritePolicyCode(f, policy)
   f.write(CPP_FOOT)
 
 
 if __name__ == '__main__':
   sys.exit(main())