dataschema-json-debug.js revision 10d8bafc5c24f3a4285cf6060a1935ba5cfc4b85
18N/AProvides a DataSchema implementation which can be used to work with JSON data. 18N/A@submodule dataschema-json 18N/AProvides a DataSchema implementation which can be used to work with JSON data. 18N/ASee the `apply` method for usage. 18N/A@extends DataSchema.Base 18N/A // TODO: I don't think the calls to Base.* need to be done via Base since 18N/A // Base is mixed into SchemaJSON. Investigate for later. 18N/A///////////////////////////////////////////////////////////////////////////// 18N/A///////////////////////////////////////////////////////////////////////////// 18N/A * Utility function converts JSON locator strings into walkable paths 18N/A * @param locator {String} JSON value locator. 18N/A * @return {String[]} Walkable path to data value. 18N/A // Strip the ["string keys"] and [1] array indexes 18N/A // TODO: the first two steps can probably be reduced to one with 18N/A // /\[\s*(['"])?(.*?)\1\s*\]/g, but the array indices would be 18N/A // stored as strings. This is not likely an issue. 58N/A function (x,$1,$2) {keys[i]=$2;return '.@
'+(i++);}). 18N/A replace(/\[(\d+)\]/g, 42N/A function (x,$1) {keys[i]=parseInt($1,10)|0;return '.@
'+(i++);}). 18N/A replace(/^\./,''); // remove leading dot 42N/A // Validate against problematic characters. 42N/A // should be safe. I'm not sure what makes a locator invalid. 18N/A //if (!/[^\w\.\$@]/.test(locator)) { 42N/A Y.log("Invalid locator: " + locator, "error", "dataschema-json"); 42N/A * Utility function to walk a path and return the value located there. 18N/A * @method getLocationValue 18N/A * @param path {String[]} Locator path. 18N/A * @param data {String} Data to traverse. 18N/A * @return {Object} Data value at location. 42N/A Applies a schema to an array of data located in a JSON structure, returning 42N/A a normalized object with results in the `results` property. Additional 42N/A information can be parsed out of the JSON for inclusion in the `meta` 18N/A property of the response object. If an error is encountered during 18N/A processing, an `error` property will be added. 18N/A The input _data_ is expected to be an object or array. If it is a string, 42N/A it will be passed through `Y.JSON.parse()`. 18N/A If _data_ contains an array of data records to normalize, specify the 18N/A _schema.resultListLocator_ as a dot separated path string just as you would 18N/A reference it in JavaScript. So if your _data_ object has a record array at 18N/A _data.response.results_, use _schema.resultListLocator_ = 18N/A "response.results". Bracket notation can also be used for array indices or 18N/A object properties (e.g. "response['results']"); This is called a "path 42N/A Field data in the result list is extracted with field identifiers in 42N/A _schema.resultFields_. Field identifiers are objects with the following 18N/A * `key` : <strong>(required)</strong> The path locator (String) 18N/A * `parser`: A function or the name of a function on `Y.Parsers` used 42N/A to convert the input value into a normalized type. Parser 42N/A functions are passed the value as input and are expected to 18N/A If no value parsing is needed, you can use path locators (strings) 18N/A instead of field identifiers (objects) -- see example below. 18N/A If no processing of the result list array is needed, _schema.resultFields_ 42N/A can be omitted; the `response.results` will point directly to the array. 42N/A If the result list contains arrays, `response.results` will contain an 18N/A array of objects with key:value pairs assuming the fields in 42N/A _schema.resultFields_ are ordered in accordance with the data array 18N/A If the result list contains objects, the identified _schema.resultFields_ 42N/A will be used to extract a value from those objects for the output result. 18N/A To extract additional information from the JSON, include an array of 18N/A path locators in _schema.metaFields_. The collected values will be 42N/A stored in `response.meta`. 42N/A // Process array of arrays 42N/A resultListLocator: 'produce.fruit', 42N/A resultFields: [ 'name', 'color' ] 42N/A [ 'Banana', 'yellow' ], 42N/A [ 'Orange', 'orange' ], 42N/A [ 'Eggplant', 'purple' ] 42N/A // response.results[0] is { name: "Banana", color: "yellow" } 42N/A // Process array of objects + some metadata 42N/A schema.metaFields = [ 'lastInventory' ]; 58N/A { name: 'Banana', color: 'yellow', price: '1.96' }, 58N/A { name: 'Orange', color: 'orange', price: '2.04' }, 58N/A { name: 'Eggplant', color: 'purple', price: '4.31' } 58N/A lastInventory: '2011-07-19' 58N/A // response.results[0] is { name: "Banana", color: "yellow" } 58N/A // response.meta.lastInventory is '2001-07-19' 18N/A schema.resultFields = [ 18N/A parser: function (val) { return val.toUpperCase(); } parser: 'number' // Uses Y.Parsers.number // Note price was converted from a numeric string to a number // response.results[0] looks like { fruit: "BANANA", price: 1.96 } @param {Object} [schema] Schema to apply. Supported configuration @param {String} [schema.resultListLocator] Path locator for the location of the array of records to flatten into `response.results` @param {Array} [schema.resultFields] Field identifiers to @param {Array} [schema.metaFields] Path locators to extract extra non-record related information from the data object. @param {Object|Array|String} data JSON data or its string serialization. @return {Object} An Object with properties `results` and `meta` // Convert incoming JSON strings Y.
log(
"JSON data could not be schema-parsed: " + Y.
dump(
data) +
" " + Y.
dump(
data),
"error",
"dataschema-json");
* Schema-parsed list of results from full data * @param schema {Object} Schema to parse against. * @param json_in {Object} JSON to parse. * @param data_out {Object} In-progress parsed data to update. * @return {Object} Parsed data object. // Fall back to treat resultListLocator as a simple key // Or if no resultListLocator is supplied, use the input // if no result fields are passed in, then just take // the results array whole-hog Sometimes you're getting // an array of strings, or want the whole object, so // resultFields don't make sense. Y.
log(
"JSON data could not be parsed: " + Y.
dump(
json_in),
"error",
"dataschema-json");
* Get field data values out of list of full results * @method _getFieldValues * @param fields {Array} Fields to find. * @param array_in {Array} Results to parse. * @param data_out {Object} In-progress parsed data to update. * @return {Object} Parsed data object. // First collect hashes of simple paths, complex paths, and parsers field =
fields[i];
// A field can be a simple string or a hash // Validate and store locators for later Y.
log(
"Invalid key syntax: " +
key,
"warn",
"dataschema-json");
// Validate and store parsers for later //TODO: use Y.DataSchema.parse? // Traverse list of array_in, creating records of simple fields, // complex fields, and applying parsers as necessary // Cycle through complexLocators // Fail over keys like "foo.bar" from nested parsing // to single token parsing if a value is found in // Don't try to process the path as complex // Cycle through simpleLocators // Bug 1777850: The result might be an array instead of object // Cycle through fieldParsers * Parses results data according to schema * @param metaFields {Object} Metafields definitions. * @param json_in {Object} JSON to parse. * @param data_out {Object} In-progress parsed data to update. * @return {Object} Schema-parsed meta data. // TODO: Y.Object + mix() might be better here },
'@VERSION@' ,{
requires:[
'dataschema-base',
'json']});