util.js

'use strict';

let semver = require('semver');
let exceptions = require('./exceptions');

class Util {
  static convertObjectKeysToUnderscores(obj) {
    let newObj = {};

    for (let key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }
      let value = obj[key];
      let newKey = Util.toUnderscore(key);

      if (value instanceof Array) {
        newObj[newKey] =
          value.map((item) => typeof item === 'object' ? Util.convertObjectKeysToUnderscores(item) : item)
        ;
      } else if (typeof value === 'object') {
        if (value instanceof Date || value === null) {
          newObj[newKey] = value;
        } else {
          newObj[newKey] = Util.convertObjectKeysToUnderscores(value);
        }
      } else {
        newObj[newKey] = value;
      }
    }
    return newObj;
  }

  static convertNodeToObject(obj) {
    if (typeof obj === 'object' && obj['@']) {
      if (obj['@'].type === 'array') {
        let newArray = [];

        for (let key in obj) {
          if (!obj.hasOwnProperty(key)) {
            continue;
          }
          let value = obj[key];

          if (key !== '@') {
            if (value instanceof Array) {
              for (let item of value) {
                newArray.push(this.convertNodeToObject(item));
              }
            } else {
              newArray.push(this.convertNodeToObject(value));
            }
          }
        }
        return newArray;
      } else if (obj['@'].type === 'collection') {
        let newObj = {};

        for (let key in obj) {
          if (!obj.hasOwnProperty(key)) {
            continue;
          }
          let value = obj[key];

          if (key !== '@') {
            newObj[this.toCamelCase(key)] = this.convertNodeToObject(value);
          }
        }
        return newObj;
      } else if (obj['@'].nil === 'true') {
        return null;
      } else if (obj['@'].type === 'integer') {
        return parseInt(obj['#'], 10);
      } else if (obj['@'].type === 'boolean') {
        return obj['#'] === 'true';
      }

      return obj['#'];
    } else if (obj instanceof Array) {
      return obj.map((item) => this.convertNodeToObject(item));
    } else if (typeof obj === 'object' && this.objectIsEmpty(obj)) {
      return '';
    } else if (typeof obj === 'object') {
      let newObj = {};

      for (let key in obj) {
        if (!obj.hasOwnProperty(key)) {
          continue;
        }
        let value = obj[key];

        newObj[this.toCamelCase(key)] = this.convertNodeToObject(value);
      }
      return newObj;
    }

    return obj;
  }

  static objectIsEmpty(obj) {
    for (let key in obj) { // eslint-disable-line no-unused-vars
      if (!obj.hasOwnProperty(key)) {
        continue;
      }
      return false;
    }
    return true;
  }

  static arrayIsEmpty(array) {
    if (!(array instanceof Array)) { return false; }
    if (array.length > 0) { return false; }
    return true;
  }

  static toCamelCase(string) {
    return string.replace(/([\-\_][a-z0-9])/g, match => match.toUpperCase().replace('-', '').replace('_', ''));
  }

  static toUnderscore(string) {
    return string.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
  }

  static flatten(array) {
    while (this._containsArray(array)) {
      array = array.reduce((first, rest) => {
        first = first instanceof Array ? first : [first];
        rest = rest instanceof Array ? this.flatten(rest) : rest;
        return first.concat(rest);
      }
      );
    }
    return array;
  }

  static merge(obj1, obj2) {
    for (let key in obj2) {
      if (!obj2.hasOwnProperty(key)) {
        continue;
      }
      let value = obj2[key];

      obj1[key] = value;
    }
    return obj1;
  }

  static without(array1, array2) {
    let newArray = [];

    for (let value of array1) {
      if (!this._containsValue(array2, value)) { newArray.push(value); }
    }
    return newArray;
  }

  static supportsStreams2() {
    return semver.satisfies(process.version, '>=0.10');
  }

  static flattenKeys(obj, prefix) {
    let keys = [];

    for (let key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }
      let value = obj[key];

      if (typeof value === 'object') {
        let keyToPush = prefix ? prefix + '[' + key + ']' : key;

        keys.push(Util.flattenKeys(value, keyToPush));
      } else if (prefix) {
        keys.push(prefix + '[' + key + ']');
      } else {
        keys.push(key);
      }
    }

    return this.flatten(keys);
  }

  static verifyKeys(keys, obj) { // eslint-disable-line consistent-return
    let invalidKeys;
    let unrecognizedKeys = this.without(this.flattenKeys(obj), keys.valid);

    if (keys.ignore) {
      invalidKeys = unrecognizedKeys.filter(function (key) {
        for (let ignoredKey of keys.ignore) {
          if (key.indexOf(ignoredKey) === 0) { return false; }
        }
        return true;
      });
    } else {
      invalidKeys = unrecognizedKeys;
    }

    if (invalidKeys.length > 0) {
      return exceptions.InvalidKeysError(`These keys are invalid: ${invalidKeys.join(', ')}`); // eslint-disable-line new-cap
    }
  }

  static _containsValue(array, element) {
    return array.indexOf(element) !== -1;
  }

  static _containsArray(array) {
    for (let element of array) {
      if (element instanceof Array) {
        return true;
      }
    }

    return false;
  }
}

module.exports = {Util: Util};