Add regex support in policy schema

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 266 matching lines @@
       'boolean': None,
       'integer': None,
       'null': None,
       'number': None,
       'string': None,
     }
     self.stringlist_type = None
     self.ranges = {}
 
   def GetString(self, s):
-    return self.shared_strings[s] if s in self.shared_strings else '"%s"' % s
+    if s in self.shared_strings:
+      return self.shared_strings[s]
+    # Generate JSON escaped string, which is slightly different from desired
+    # C/C++ escaped string.
+    return json.dumps(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):
     r = (str(first), str(second))
     if not r in self.ranges:
       self.ranges[r] = len(self.restriction_nodes)
@@ skipping 10 matching lines @@
 
   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
+    return any(keyword in schema for keyword in
+        ['minimum', 'maximum', 'enum', 'pattern'])
 
   def IsConsecutiveInterval(self, seq):
     sortedSeq = sorted(seq)
     return all(sortedSeq[i] + 1 == sortedSeq[i + 1]
                for i in xrange(len(sortedSeq) - 1))
 
   def GetEnumIntegerType(self, schema, name):
     assert all(type(x) == int for x in schema['enum'])
     possible_values = schema['enum']
     if self.IsConsecutiveInterval(possible_values):
@@ skipping 19 matching lines @@
   def GetEnumType(self, schema, name):
     if len(schema['enum']) == 0:
       raise RuntimeError('Empty enumeration in %s' % name)
     elif schema['type'] == 'integer':
       return self.GetEnumIntegerType(schema, name)
     elif schema['type'] == 'string':
       return self.GetEnumStringType(schema, name)
     else:
       raise RuntimeError('Unknown enumeration type in %s' % name)
 
+  def GetPatternType(self, schema, name):
+    if schema['type'] != 'string':
+      raise RuntimeError('Unknown pattern type in %s' % name)
+    pattern = schema['pattern']
+    # Try to compile the pattern to validate it, note that the syntax used
+    # here might be slightly different from re2.

[Joao da Silva, 2014/03/21 12:58:12]

Leave a TODO to use a python wrapper for re2 here

[binjin, 2014/03/27 17:57:47]

Done.

+    re.compile(pattern)
+    index = len(self.string_enums);
+    self.string_enums.append(pattern);
+    return self.AppendSchema('TYPE_STRING',
+        self.AppendRestriction(index, index),
+        'string with pattern restriction: %s' % name);
+
   def GetRangedType(self, schema, name):
     if schema['type'] != 'integer':
       raise RuntimeError('Unknown ranged type in %s' % name)
     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
@@ skipping 10 matching lines @@
     """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."""
     if schema['type'] in self.simple_types:
       if not self.SchemaHaveRestriction(schema):
         # Simple types use shared nodes.
         return self.GetSimpleType(schema['type'])
       elif 'enum' in schema:
         return self.GetEnumType(schema, name)
+      elif 'pattern' in schema:
+        return self.GetPatternType(schema, name)
       else:
         return self.GetRangedType(schema, name)
 
     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
       # properties. This makes sure that the root node is the first in the
       # SchemaNodes array.
       index = self.AppendSchema('TYPE_DICTIONARY', -1)
 
       if 'additionalProperties' in schema:
         additionalProperties = self.Generate(
             schema['additionalProperties'],
             'additionalProperties of ' + name)
       else:
         additionalProperties = -1
 
       # Properties must be sorted by name, for the binary search lookup.
       # Note that |properties| must be evaluated immediately, so that all the
       # recursive calls to Generate() append the necessary child nodes; if
       # |properties| were a generator then this wouldn't work.
       sorted_properties = sorted(schema.get('properties', {}).items())
-      properties = [ (self.GetString(key), self.Generate(schema, key))
-                     for key, schema in sorted_properties ]
+      properties = [ (self.GetString(key), self.Generate(subschema, key))
+                     for key, subschema in sorted_properties ]
       begin = len(self.property_nodes)
       self.property_nodes += properties
       end = len(self.property_nodes)
+
+      for pattern, subschema in schema.get('patternProperties', {}).items():
+        self.property_nodes.append((self.GetString(pattern),

[Joao da Silva, 2014/03/21 12:58:12]

appending one by one and making recursive calls to Generate doesn't work (see
the comment above).

Basically you have a [begin, end) range, which must be contiguous. Now you're
building an [end, pattern_end) range, which must also be contiguous; this means
that all generated nodes must be appended together.

However, the recursive call to Generate can append more nodes in between, and
then the array will have the properties of different schemas mixed up.

You have to first generate all of them, and then append them all together
contiguously into property_nodes.

[binjin, 2014/03/27 17:57:47]

Done.

+            self.Generate(subschema, pattern)));
+      pattern_end = len(self.property_nodes)
+
       if index == 0:
         self.root_properties_begin = begin
         self.root_properties_end = end
 
       extra = len(self.properties_nodes)
-      self.properties_nodes.append((begin, end, additionalProperties, name))
+      self.properties_nodes.append((begin, end, pattern_end,
+          additionalProperties, name))
 
       # Set the right data at |index| now.
       self.schema_nodes[index] = ('TYPE_DICTIONARY', extra, name)
       return index
     else:
       assert False
 
   def Write(self, f):
     """Writes the generated structs to the given file.
 
     |f| an open file to write to."""
     f.write('const internal::SchemaNode kSchemas[] = {\n'
             '//  Type                          Extra\n')
     for type, extra, comment in self.schema_nodes:
       type += ','
       f.write('  { base::Value::%-18s %3d },  // %s\n' % (type, extra, comment))
     f.write('};\n\n')
 
     if self.property_nodes:
       f.write('const internal::PropertyNode kPropertyNodes[] = {\n'
               '//  Property                                          #Schema\n')
       for key, schema in self.property_nodes:
         key += ','
         f.write('  { %-50s %6d },\n' % (key, schema))
       f.write('};\n\n')
 
     if self.properties_nodes:
       f.write('const internal::PropertiesNode kProperties[] = {\n'
-              '//  Begin    End  Additional Properties\n')
+              '//  Begin    End  PatternEnd Additional Properties\n')
       for node in self.properties_nodes:
-        f.write('  { %5d, %5d, %5d },  // %s\n' % node)
+        f.write('  { %5d, %5d, %10d, %5d },  // %s\n' % node)
       f.write('};\n\n')
 
     if self.restriction_nodes:
       f.write('const internal::RestrictionNode kRestrictionNodes[] = {\n')
       f.write('//   FIRST, SECOND\n')
       for first, second in self.restriction_nodes:
         f.write('  {{ %-8s %4s}},\n' % (first + ',', second))
       f.write('};\n\n')
 
     if self.int_enums:
@@ skipping 371 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())