www.aleph1.co.uk Git - yaffs-website/blob - node_modules/js-yaml/lib/js-yaml/schema.js

   1 'use strict';
   2
   3 /*eslint-disable max-len*/
   4
   5 var common        = require('./common');
   6 var YAMLException = require('./exception');
   7 var Type          = require('./type');
   8
   9
  10 function compileList(schema, name, result) {
  11   var exclude = [];
  12
  13   schema.include.forEach(function (includedSchema) {
  14     result = compileList(includedSchema, name, result);
  15   });
  16
  17   schema[name].forEach(function (currentType) {
  18     result.forEach(function (previousType, previousIndex) {
  19       if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
  20         exclude.push(previousIndex);
  21       }
  22     });
  23
  24     result.push(currentType);
  25   });
  26
  27   return result.filter(function (type, index) {
  28     return exclude.indexOf(index) === -1;
  29   });
  30 }
  31
  32
  33 function compileMap(/* lists... */) {
  34   var result = {
  35         scalar: {},
  36         sequence: {},
  37         mapping: {},
  38         fallback: {}
  39       }, index, length;
  40
  41   function collectType(type) {
  42     result[type.kind][type.tag] = result['fallback'][type.tag] = type;
  43   }
  44
  45   for (index = 0, length = arguments.length; index < length; index += 1) {
  46     arguments[index].forEach(collectType);
  47   }
  48   return result;
  49 }
  50
  51
  52 function Schema(definition) {
  53   this.include  = definition.include  || [];
  54   this.implicit = definition.implicit || [];
  55   this.explicit = definition.explicit || [];
  56
  57   this.implicit.forEach(function (type) {
  58     if (type.loadKind && type.loadKind !== 'scalar') {
  59       throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
  60     }
  61   });
  62
  63   this.compiledImplicit = compileList(this, 'implicit', []);
  64   this.compiledExplicit = compileList(this, 'explicit', []);
  65   this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);
  66 }
  67
  68
  69 Schema.DEFAULT = null;
  70
  71
  72 Schema.create = function createSchema() {
  73   var schemas, types;
  74
  75   switch (arguments.length) {
  76     case 1:
  77       schemas = Schema.DEFAULT;
  78       types = arguments[0];
  79       break;
  80
  81     case 2:
  82       schemas = arguments[0];
  83       types = arguments[1];
  84       break;
  85
  86     default:
  87       throw new YAMLException('Wrong number of arguments for Schema.create function');
  88   }
  89
  90   schemas = common.toArray(schemas);
  91   types = common.toArray(types);
  92
  93   if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
  94     throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
  95   }
  96
  97   if (!types.every(function (type) { return type instanceof Type; })) {
  98     throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
  99   }
 100
 101   return new Schema({
 102     include: schemas,
 103     explicit: types
 104   });
 105 };
 106
 107
 108 module.exports = Schema;