Add regular expression support in json_schema component

components/json_schema/json_schema_validator.cc

 // Copyright 2013 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.
 
 #include "components/json_schema/json_schema_validator.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
+#include <vector>
 
 #include "base/json/json_reader.h"
+#include "base/logging.h"
+#include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/json_schema/json_schema_constants.h"
+#include "third_party/re2/re2/re2.h"
 
 namespace schema = json_schema_constants;
 
 namespace {
 
 double GetNumberValue(const base::Value* value) {
   double result = 0;
   CHECK(value->GetAsDouble(&result))
       << "Unexpected value type: " << value->GetType();
   return result;
@@ skipping 52 matching lines @@
     { schema::kDescription,             base::Value::TYPE_STRING      },
     { schema::kEnum,                    base::Value::TYPE_LIST        },
     { schema::kId,                      base::Value::TYPE_STRING      },
     { schema::kMaxItems,                base::Value::TYPE_INTEGER     },
     { schema::kMaxLength,               base::Value::TYPE_INTEGER     },
     { schema::kMaximum,                 base::Value::TYPE_DOUBLE      },
     { schema::kMinItems,                base::Value::TYPE_INTEGER     },
     { schema::kMinLength,               base::Value::TYPE_INTEGER     },
     { schema::kMinimum,                 base::Value::TYPE_DOUBLE      },
     { schema::kOptional,                base::Value::TYPE_BOOLEAN     },
+    { schema::kPattern,                 base::Value::TYPE_STRING      },
+    { schema::kPatternProperties,       base::Value::TYPE_DICTIONARY  },
     { schema::kProperties,              base::Value::TYPE_DICTIONARY  },
     { schema::kTitle,                   base::Value::TYPE_STRING      },
   };
 
   bool has_type_or_ref = false;
   const base::ListValue* list_value = NULL;
   const base::DictionaryValue* dictionary_value = NULL;
   std::string string_value;
 
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
@@ skipping 80 matching lines @@
       if (integer_value < 0) {
         *error = base::StringPrintf("Value of %s must be >= 0, got %d",
                                     it.key().c_str(), integer_value);
         return false;
       }
     }
 
     // Validate the "properties" attribute. Each entry maps a key to a schema.
     if (it.key() == schema::kProperties) {
       it.value().GetAsDictionary(&dictionary_value);
-      for (base::DictionaryValue::Iterator it(*dictionary_value);
-           !it.IsAtEnd(); it.Advance()) {
-        if (!it.value().GetAsDictionary(&dictionary_value)) {
-          *error = "Invalid value for properties attribute";
+      for (base::DictionaryValue::Iterator iter(*dictionary_value);
+           !iter.IsAtEnd(); iter.Advance()) {
+        if (!iter.value().GetAsDictionary(&dictionary_value)) {
+          *error = "properties must be a dictionary";
           return false;
         }
         if (!IsValidSchema(dictionary_value, options, error)) {
+          DCHECK(!error->empty());
+          return false;
+        }
+      }
+    }
+
+    // Validate the "patternProperties" attribute. Each entry maps a regular
+    // expression to a schema. The validity of the regular expression expression
+    // won't be checked here for performance reason.

[not at google - send to devlin, 2014/03/25 14:38:06]

.... "reasons. Instead, invalid regular expressions will be caught as validation
errors in Validate".

[binjin, 2014/03/27 12:21:01]

Done.

+    if (it.key() == schema::kPatternProperties) {
+      it.value().GetAsDictionary(&dictionary_value);
+      for (base::DictionaryValue::Iterator iter(*dictionary_value);
+           !iter.IsAtEnd(); iter.Advance()) {
+        if (!iter.value().GetAsDictionary(&dictionary_value)) {
+          *error = "patternProperties must be a dictionary";
+          return false;
+        }
+        if (!IsValidSchema(dictionary_value, options, error)) {
           DCHECK(!error->empty());
           return false;
         }
       }
     }
 
     // Validate "additionalProperties" attribute, which is a schema.
     if (it.key() == schema::kAdditionalProperties) {
       it.value().GetAsDictionary(&dictionary_value);
       if (!IsValidSchema(dictionary_value, options, error)) {
@@ skipping 95 matching lines @@
 const char JSONSchemaValidator::kStringPattern[] =
     "String must match the pattern: *.";
 const char JSONSchemaValidator::kNumberMinimum[] =
     "Value must not be less than *.";
 const char JSONSchemaValidator::kNumberMaximum[] =
     "Value must not be greater than *.";
 const char JSONSchemaValidator::kInvalidType[] =
     "Expected '*' but got '*'.";
 const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] =
     "Expected 'integer' but got 'number', consider using Math.round().";
+const char JSONSchemaValidator::kInvalidRegex[] =
+    "Regular expression /*/ is invalid: *";
 
 
 // static
 std::string JSONSchemaValidator::GetJSONSchemaType(const base::Value* value) {
   switch (value->GetType()) {
     case base::Value::TYPE_NULL:
       return schema::kNull;
     case base::Value::TYPE_BOOLEAN:
       return schema::kBoolean;
     case base::Value::TYPE_INTEGER:
@@ skipping 223 matching lines @@
     }
   }
 
   errors_.push_back(Error(path, kInvalidEnum));
 }
 
 void JSONSchemaValidator::ValidateObject(const base::DictionaryValue* instance,
                                          const base::DictionaryValue* schema,
                                          const std::string& path) {
   const base::DictionaryValue* properties = NULL;
-  schema->GetDictionary(schema::kProperties, &properties);
-  if (properties) {
+  if (schema->GetDictionary(schema::kProperties, &properties)) {
     for (base::DictionaryValue::Iterator it(*properties); !it.IsAtEnd();
          it.Advance()) {
       std::string prop_path = path.empty() ? it.key() : (path + "." + it.key());
       const base::DictionaryValue* prop_schema = NULL;
       CHECK(it.value().GetAsDictionary(&prop_schema));
 
       const base::Value* prop_value = NULL;
       if (instance->Get(it.key(), &prop_value)) {
         Validate(prop_value, prop_schema, prop_path);
       } else {
         // Properties are required unless there is an optional field set to
         // 'true'.
         bool is_optional = false;
         prop_schema->GetBoolean(schema::kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
         }
       }
     }
   }
 
   const base::DictionaryValue* additional_properties_schema = NULL;
-  if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
-    return;
+  bool allow_any_additional_properties =
+      SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema);
 
-  // Validate additional properties.
+  const base::DictionaryValue* pattern_properties = NULL;
+  ScopedVector<re2::RE2> pattern_properties_pattern;
+  std::vector<const base::DictionaryValue*> pattern_properties_schema;
+
+  if (schema->GetDictionary(schema::kPatternProperties, &pattern_properties)) {
+    for (base::DictionaryValue::Iterator it(*pattern_properties); !it.IsAtEnd();
+         it.Advance()) {
+      re2::RE2* prop_pattern = new re2::RE2(it.key());
+      if (!prop_pattern->ok()) {
+        LOG(WARNING) << "Regular expression /" << it.key()
+                     << "/ is invalid: " << prop_pattern->error() << ".";
+        errors_.push_back(
+            Error(path,
+                  FormatErrorMessage(
+                      kInvalidRegex, it.key(), prop_pattern->error())));
+        continue;
+      }
+      const base::DictionaryValue* prop_schema = NULL;
+      CHECK(it.value().GetAsDictionary(&prop_schema));
+      pattern_properties_pattern.push_back(prop_pattern);
+      pattern_properties_schema.push_back(prop_schema);
+    }
+  }
+
+  // Validate pattern properties and additional properties.
   for (base::DictionaryValue::Iterator it(*instance); !it.IsAtEnd();
        it.Advance()) {
-    if (properties && properties->HasKey(it.key()))
+    std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
+
+    bool found_matching_pattern = false;
+    for (size_t index = 0; index < pattern_properties_pattern.size(); ++index) {
+      if (re2::RE2::PartialMatch(it.key(),
+                                 *pattern_properties_pattern[index])) {
+        found_matching_pattern = true;
+        Validate(&it.value(), pattern_properties_schema[index], prop_path);
+        break;
+      }
+    }
+
+    if (found_matching_pattern || allow_any_additional_properties ||
+        (properties && properties->HasKey(it.key())))
       continue;
 
-    std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
     if (!additional_properties_schema) {
       errors_.push_back(Error(prop_path, kUnexpectedProperty));
     } else {
       Validate(&it.value(), additional_properties_schema, prop_path);
     }
   }
 }
 
 void JSONSchemaValidator::ValidateArray(const base::ListValue* instance,
                                         const base::DictionaryValue* schema,
@@ skipping 102 matching lines @@
 
   int max_length = 0;
   if (schema->GetInteger(schema::kMaxLength, &max_length)) {
     CHECK(max_length >= 0);
     if (value.size() > static_cast<size_t>(max_length)) {
       errors_.push_back(Error(path, FormatErrorMessage(
           kStringMaxLength, base::IntToString(max_length))));
     }
   }
 
-  CHECK(!schema->HasKey(schema::kPattern)) << "Pattern is not supported.";
+  std::string pattern;
+  if (schema->GetString(schema::kPattern, &pattern)) {
+    re2::RE2 compiled_regex(pattern);
+    if (!compiled_regex.ok()) {
+      LOG(WARNING) << "Regular expression /" << pattern
+                   << "/ is invalid: " << compiled_regex.error() << ".";
+      errors_.push_back(Error(
+          path,
+          FormatErrorMessage(kInvalidRegex, pattern, compiled_regex.error())));
+    } else if (!re2::RE2::PartialMatch(value, compiled_regex)) {
+      errors_.push_back(
+          Error(path, FormatErrorMessage(kStringPattern, pattern)));
+    }
+  }
 }
 
 void JSONSchemaValidator::ValidateNumber(const base::Value* instance,
                                          const base::DictionaryValue* schema,
                                          const std::string& path) {
   double value = GetNumberValue(instance);
 
   // TODO(aa): It would be good to test that the double is not infinity or nan,
   // but isnan and isinf aren't defined on Windows.
 
@@ skipping 40 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type(schema::kAny);
     CHECK((*additional_properties_schema)->GetString(
         schema::kType, &additional_properties_type));
     return additional_properties_type == schema::kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }