All files / node_modules/js-yaml/lib/js-yaml schema.js

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