Share JSON schema constants.

chrome/common/json_schema_validator.cc

 // Copyright (c) 2011 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 "chrome/common/json_schema_validator.h"
 
 #include <cfloat>
 #include <cmath>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
+#include "chrome/common/json_schema_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using namespace json_schema_constants;
+
 namespace {
 
 double GetNumberValue(Value* value) {
   double result = 0;
   CHECK(value->GetAsDouble(&result))
       << "Unexpected value type: " << value->GetType();
   return result;
 }
 
 }  // namespace
@@ skipping 39 matching lines @@
 const char JSONSchemaValidator::kNumberMaximum[] =
     "Value must not be greater than *.";
 const char JSONSchemaValidator::kInvalidType[] =
     "Expected '*' but got '*'.";
 
 
 // static
 std::string JSONSchemaValidator::GetJSONSchemaType(Value* value) {
   switch (value->GetType()) {
     case Value::TYPE_NULL:
-      return "null";
+      return kNull;
     case Value::TYPE_BOOLEAN:
-      return "boolean";
+      return kBoolean;
     case Value::TYPE_INTEGER:
-      return "integer";
+      return kInteger;
     case Value::TYPE_DOUBLE: {
       double double_value = 0;
       value->GetAsDouble(&double_value);
       if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
           double_value == floor(double_value)) {
-        return "integer";
+        return kInteger;
       } else {
-        return "number";
+        return kNumber;
       }
     }
     case Value::TYPE_STRING:
-      return "string";
+      return kString;
     case Value::TYPE_DICTIONARY:
-      return "object";
+      return kObject;
     case Value::TYPE_LIST:
-      return "array";
+      return kArray;
     default:
       NOTREACHED() << "Unexpected value type: " << value->GetType();
       return "";
   }
 }
 
 // static
 std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
                                                     const std::string& s1) {
   std::string ret_val = format;
@@ skipping 19 matching lines @@
                                          ListValue* types)
     : schema_root_(schema), default_allow_additional_properties_(false) {
   if (!types)
     return;
 
   for (size_t i = 0; i < types->GetSize(); ++i) {
     DictionaryValue* type = NULL;
     CHECK(types->GetDictionary(i, &type));
 
     std::string id;
-    CHECK(type->GetString("id", &id));
+    CHECK(type->GetString(kId, &id));
 
     CHECK(types_.find(id) == types_.end());
     types_[id] = type;
   }
 }
 
 JSONSchemaValidator::~JSONSchemaValidator() {}
 
 bool JSONSchemaValidator::Validate(Value* instance) {
   errors_.clear();
   Validate(instance, schema_root_, "");
   return errors_.empty();
 }
 
 void JSONSchemaValidator::Validate(Value* instance,
                                    DictionaryValue* schema,
                                    const std::string& path) {
   // If this schema defines itself as reference type, save it in this.types.
   std::string id;
-  if (schema->GetString("id", &id)) {
+  if (schema->GetString(kId, &id)) {
     TypeMap::iterator iter = types_.find(id);
     if (iter == types_.end())
       types_[id] = schema;
     else
       DCHECK(iter->second == schema);
   }
 
   // If the schema has a $ref property, the instance must validate against
   // that schema. It must be present in types_ to be referenced.
   std::string ref;
   if (schema->GetString("$ref", &ref)) {
     TypeMap::iterator type = types_.find(ref);
     if (type == types_.end()) {
       errors_.push_back(
           Error(path, FormatErrorMessage(kUnknownTypeReference, ref)));
     } else {
       Validate(instance, type->second, path);
     }
     return;
   }
 
   // If the schema has a choices property, the instance must validate against at
   // least one of the items in that array.
   ListValue* choices = NULL;
-  if (schema->GetList("choices", &choices)) {
+  if (schema->GetList(kChoices, &choices)) {
     ValidateChoices(instance, choices, path);
     return;
   }
 
   // If the schema has an enum property, the instance must be one of those
   // values.
   ListValue* enumeration = NULL;
-  if (schema->GetList("enum", &enumeration)) {
+  if (schema->GetList(kEnum, &enumeration)) {
     ValidateEnum(instance, enumeration, path);
     return;
   }
 
   std::string type;
-  schema->GetString("type", &type);
+  schema->GetString(kType, &type);
   CHECK(!type.empty());
-  if (type != "any") {
+  if (type != kAny) {
     if (!ValidateType(instance, type, path))
       return;
 
     // These casts are safe because of checks in ValidateType().
-    if (type == "object")
+    if (type == kObject)
       ValidateObject(static_cast<DictionaryValue*>(instance), schema, path);
-    else if (type == "array")
+    else if (type == kArray)
       ValidateArray(static_cast<ListValue*>(instance), schema, path);
-    else if (type == "string")
+    else if (type == kString)
       ValidateString(static_cast<StringValue*>(instance), schema, path);
-    else if (type == "number" || type == "integer")
+    else if (type == kNumber || type == kInteger)
       ValidateNumber(instance, schema, path);
-    else if (type != "boolean" && type != "null")
+    else if (type != kBoolean && type != kNull)
       NOTREACHED() << "Unexpected type: " << type;
   }
 }
 
 void JSONSchemaValidator::ValidateChoices(Value* instance,
                                           ListValue* choices,
                                           const std::string& path) {
   size_t original_num_errors = errors_.size();
 
   for (size_t i = 0; i < choices->GetSize(); ++i) {
@@ skipping 42 matching lines @@
     }
   }
 
   errors_.push_back(Error(path, kInvalidEnum));
 }
 
 void JSONSchemaValidator::ValidateObject(DictionaryValue* instance,
                                          DictionaryValue* schema,
                                          const std::string& path) {
   DictionaryValue* properties = NULL;
-  schema->GetDictionary("properties", &properties);
+  schema->GetDictionary(kProperties, &properties);
   if (properties) {
     for (DictionaryValue::key_iterator key = properties->begin_keys();
          key != properties->end_keys(); ++key) {
       std::string prop_path = path.empty() ? *key : (path + "." + *key);
       DictionaryValue* prop_schema = NULL;
       CHECK(properties->GetDictionary(*key, &prop_schema));
 
       Value* prop_value = NULL;
       if (instance->Get(*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("optional", &is_optional);
+        prop_schema->GetBoolean(kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
         }
       }
     }
   }
 
   DictionaryValue* additional_properties_schema = NULL;
   if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
     return;
@@ skipping 13 matching lines @@
       Validate(prop_value, additional_properties_schema, prop_path);
     }
   }
 }
 
 void JSONSchemaValidator::ValidateArray(ListValue* instance,
                                         DictionaryValue* schema,
                                         const std::string& path) {
   DictionaryValue* single_type = NULL;
   size_t instance_size = instance->GetSize();
-  if (schema->GetDictionary("items", &single_type)) {
+  if (schema->GetDictionary(kItems, &single_type)) {
     int min_items = 0;
-    if (schema->GetInteger("minItems", &min_items)) {
+    if (schema->GetInteger(kMinItems, &min_items)) {
       CHECK(min_items >= 0);
       if (instance_size < static_cast<size_t>(min_items)) {
         errors_.push_back(Error(path, FormatErrorMessage(
             kArrayMinItems, base::IntToString(min_items))));
       }
     }
 
     int max_items = 0;
-    if (schema->GetInteger("maxItems", &max_items)) {
+    if (schema->GetInteger(kMaxItems, &max_items)) {
       CHECK(max_items >= 0);
       if (instance_size > static_cast<size_t>(max_items)) {
         errors_.push_back(Error(path, FormatErrorMessage(
             kArrayMaxItems, base::IntToString(max_items))));
       }
     }
 
     // If the items property is a single schema, each item in the array must
     // validate against that schema.
     for (size_t i = 0; i < instance_size; ++i) {
       Value* item = NULL;
       CHECK(instance->Get(i, &item));
       std::string i_str = base::UintToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       Validate(item, single_type, item_path);
     }
 
     return;
   }
 
   // Otherwise, the list must be a tuple type, where each item in the list has a
   // particular schema.
   ValidateTuple(instance, schema, path);
 }
 
 void JSONSchemaValidator::ValidateTuple(ListValue* instance,
                                         DictionaryValue* schema,
                                         const std::string& path) {
   ListValue* tuple_type = NULL;
-  schema->GetList("items", &tuple_type);
+  schema->GetList(kItems, &tuple_type);
   size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
   if (tuple_type) {
     for (size_t i = 0; i < tuple_size; ++i) {
       std::string i_str = base::UintToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       DictionaryValue* item_schema = NULL;
       CHECK(tuple_type->GetDictionary(i, &item_schema));
       Value* item_value = NULL;
       instance->Get(i, &item_value);
       if (item_value && item_value->GetType() != Value::TYPE_NULL) {
         Validate(item_value, item_schema, item_path);
       } else {
         bool is_optional = false;
-        item_schema->GetBoolean("optional", &is_optional);
+        item_schema->GetBoolean(kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(item_path, kArrayItemRequired));
           return;
         }
       }
     }
   }
 
   DictionaryValue* additional_properties_schema = NULL;
   if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
@@ skipping 16 matching lines @@
   }
 }
 
 void JSONSchemaValidator::ValidateString(StringValue* instance,
                                          DictionaryValue* schema,
                                          const std::string& path) {
   std::string value;
   CHECK(instance->GetAsString(&value));
 
   int min_length = 0;
-  if (schema->GetInteger("minLength", &min_length)) {
+  if (schema->GetInteger(kMinLength, &min_length)) {
     CHECK(min_length >= 0);
     if (value.size() < static_cast<size_t>(min_length)) {
       errors_.push_back(Error(path, FormatErrorMessage(
           kStringMinLength, base::IntToString(min_length))));
     }
   }
 
   int max_length = 0;
-  if (schema->GetInteger("maxLength", &max_length)) {
+  if (schema->GetInteger(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("pattern")) << "Pattern is not supported.";
+  CHECK(!schema->HasKey(kPattern)) << "Pattern is not supported.";
 }
 
 void JSONSchemaValidator::ValidateNumber(Value* instance,
                                          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.
 
   double minimum = 0;
-  if (schema->GetDouble("minimum", &minimum)) {
+  if (schema->GetDouble(kMinimum, &minimum)) {
     if (value < minimum)
       errors_.push_back(Error(path, FormatErrorMessage(
           kNumberMinimum, base::DoubleToString(minimum))));
   }
 
   double maximum = 0;
-  if (schema->GetDouble("maximum", &maximum)) {
+  if (schema->GetDouble(kMaximum, &maximum)) {
     if (value > maximum)
       errors_.push_back(Error(path, FormatErrorMessage(
           kNumberMaximum, base::DoubleToString(maximum))));
   }
 }
 
 bool JSONSchemaValidator::ValidateType(Value* instance,
                                        const std::string& expected_type,
                                        const std::string& path) {
   std::string actual_type = GetJSONSchemaType(instance);
   if (expected_type == actual_type ||
-      (expected_type == "number" && actual_type == "integer")) {
+      (expected_type == kNumber && actual_type == kInteger)) {
     return true;
   } else {
     errors_.push_back(Error(path, FormatErrorMessage(
         kInvalidType, expected_type, actual_type)));
     return false;
   }
 }
 
 bool JSONSchemaValidator::SchemaAllowsAnyAdditionalItems(
     DictionaryValue* schema, DictionaryValue** additional_properties_schema) {
   // If the validator allows additional properties globally, and this schema
   // doesn't override, then we can exit early.
-  schema->GetDictionary("additionalProperties", additional_properties_schema);
+  schema->GetDictionary(kAdditionalProperties, additional_properties_schema);
 
   if (*additional_properties_schema) {
-    std::string additional_properties_type("any");
+    std::string additional_properties_type(kAny);
     CHECK((*additional_properties_schema)->GetString(
-        "type", &additional_properties_type));
-    return additional_properties_type == "any";
+        kType, &additional_properties_type));
+    return additional_properties_type == kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }