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. Known differences includes unicode escaping format.
+    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.
+    # TODO(binjin): Add a python wrapper of re2 and use it here.
+    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 ]
+
+      pattern_properties = []
+      for pattern, subschema in schema.get('patternProperties', {}).items():
+        pattern_properties.append((self.GetString(pattern),
+            self.Generate(subschema, pattern)));
+
       begin = len(self.property_nodes)
       self.property_nodes += properties
       end = len(self.property_nodes)
+      self.property_nodes += pattern_properties
+      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())