soya/lib/ComponentFinder.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _htmlEntities = require('html-entities');

var _htmlEntities2 = _interopRequireDefault(_htmlEntities);

var _helper = require('./data/redux/helper');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var entities = new _htmlEntities2.default.AllHtmlEntities();

/**
 * @SERVER
 */

var ComponentFinder = function () {
  function ComponentFinder() {
    _classCallCheck(this, ComponentFinder);
  }

  _createClass(ComponentFinder, [{
    key: 'find',

    /**
     * 1) Find recursively every component in the directory.
     * 2) Validate the component.
     *
     * @param {string} absoluteProjectDir
     * @param {Function} callback
     */
    value: function find(absoluteProjectDir, callback) {
      this._find(absoluteProjectDir, '', callback);
    }

    /**
     * Since the convention is to put all components and pages inside the project,
     * we can safely assume that relative dir won't contain
     *
     *
     */

  }, {
    key: '_find',
    value: function _find(absoluteRootDir, relativeDir, callback) {
      var currentAbsoluteDir = _path2.default.join(absoluteRootDir, relativeDir);
      this._check(currentAbsoluteDir, true, false);
      var i, candidates, candidate, stat, candidatePath, newRelativeDir;
      candidates = _fs2.default.readdirSync(currentAbsoluteDir);
      for (i = 0; i < candidates.length; i++) {
        candidate = candidates[i];
        candidatePath = _path2.default.join(currentAbsoluteDir, candidate);
        stat = _fs2.default.statSync(candidatePath);
        if (stat.isDirectory()) {
          newRelativeDir = _path2.default.join(relativeDir, candidate);
          this._find(absoluteRootDir, newRelativeDir, callback);
          continue;
        }
        if (stat.isFile() && candidate == 'component.json') {
          this._reg(absoluteRootDir, relativeDir, candidatePath, callback);
        }
      }
    }
  }, {
    key: '_reg',
    value: function _reg(absoluteRootDir, relativePath, jsonAbsolutePath, callback) {
      var componentJson;
      try {
        componentJson = JSON.parse(_fs2.default.readFileSync(jsonAbsolutePath, 'utf8'));
      } catch (error) {
        console.log('IGNORED: Failed to read this component file: ' + jsonAbsolutePath);
      }

      var result = this._validateComponentJson(componentJson, jsonAbsolutePath);
      if (!result) return;

      var thumbRelativePath = _path2.default.join(relativePath, componentJson.thumbnail);
      var thumbFilePath = _path2.default.join(absoluteRootDir, thumbRelativePath);
      if (!this._fileExists(thumbFilePath)) {
        console.log('IGNORED: Thumbnail component does not exist: ' + thumbFilePath + ' in: ' + jsonAbsolutePath);
        return;
      }
      var unescapedCode = _fs2.default.readFileSync(thumbFilePath).toString();
      var code = entities.encode(unescapedCode);

      var testRelativePath = this._ensureComponentFileExists(componentJson, absoluteRootDir, relativePath, jsonAbsolutePath, 'test');
      var docRelativePath = this._ensureComponentFileExists(componentJson, absoluteRootDir, relativePath, jsonAbsolutePath, 'doc');

      callback(thumbRelativePath, testRelativePath, docRelativePath, code, componentJson);
    }

    /**
     * Returns null if component file doesn't exist, otherwise returns the
     * component's relative path.
     *
     * @param {Object} componentJson
     * @param {string} absoluteRootDir
     * @param {string} relativePath
     * @param {string} jsonAbsolutePath
     * @param {string} name
     * @returns {?string}
     */

  }, {
    key: '_ensureComponentFileExists',
    value: function _ensureComponentFileExists(componentJson, absoluteRootDir, relativePath, jsonAbsolutePath, name) {
      var fileRelativePath, absolutePath;
      if ((0, _helper.isStringAndNotEmpty)(componentJson[name])) {
        fileRelativePath = _path2.default.join(relativePath, componentJson[name]);
        absolutePath = _path2.default.join(absoluteRootDir, fileRelativePath);
        if (!this._fileExists(absolutePath)) {
          console.log('IGNORED: ' + name + ' component does not exist: ' + absolutePath + ' in ' + jsonAbsolutePath);
          return null;
        }
        return fileRelativePath;
      }
      return null;
    }
  }, {
    key: '_fileExists',
    value: function _fileExists(filePath) {
      try {
        var stats = _fs2.default.statSync(filePath);
        return stats.isFile();
      } catch (e) {
        if (e.code == 'ENOENT') return false;
        throw e;
      }
    }

    /**
     * @param {Object} componentJson
     * @param {string} jsonAbsolutePath
     * @return {boolean}
     */

  }, {
    key: '_validateComponentJson',
    value: function _validateComponentJson(componentJson, jsonAbsolutePath) {
      var vendor = componentJson.vendor;
      var name = componentJson.name;
      var thumbnail = componentJson.thumbnail;
      var author = componentJson.author;
      var category = componentJson.category;

      if (!(0, _helper.isStringAndNotEmpty)(vendor)) {
        console.log('IGNORED: component.json does not contain vendor: ' + jsonAbsolutePath);
        return false;
      }

      if (!(0, _helper.isStringAndNotEmpty)(name)) {
        console.log('IGNORED: component.json does not contain name: ' + jsonAbsolutePath);
        return false;
      }

      if (!(0, _helper.isStringAndNotEmpty)(thumbnail)) {
        console.log('IGNORED: component.json does not contain thumbnail component: ' + jsonAbsolutePath);
        return false;
      }

      if (author == null) {
        console.log('IGNORED: component.json does not contain author information: ' + jsonAbsolutePath);
        return false;
      }

      if (!(0, _helper.isStringAndNotEmpty)(author.name) || !(0, _helper.isStringAndNotEmpty)(author.email)) {
        console.log('IGNORED: component.json does not contain author name and/or email: ' + jsonAbsolutePath);
        return false;
      }

      if (!(0, _helper.isStringAndNotEmpty)(category)) {
        console.log('IGNORED: component.json does not contain category: ' + jsonAbsolutePath);
        return false;
      }

      return true;
    }

    /**
     * @param {string} absPath
     * @param {boolean} shouldBeDir
     * @param {boolean} shouldIgnore
     * @return {boolean}
     */

  }, {
    key: '_check',
    value: function _check(absPath, shouldBeDir, shouldIgnore) {
      var stat;
      try {
        stat = _fs2.default.statSync(absPath);
      } catch (error) {
        if (shouldIgnore) {
          console.log('Ignored: Component file/dir does no exist: \'' + absPath + '\'.');
          return false;
        } else {
          throw error;
        }
      }

      var isMismatchType = shouldBeDir && !stat.isDirectory() || !shouldBeDir && !stat.isFile();
      if (isMismatchType) {
        if (shouldIgnore) {
          console.log(this._mismatchTypeMessage(absPath, shouldBeDir, 'Ignored: '));
          return false;
        } else {
          throw new Error(this._mismatchTypeMessage(absPath, shouldBeDir, ''));
        }
      }
      return true;
    }

    /**
     * @param {string} absPath
     * @param {string} shouldBeDir
     * @param {string} prefix
     */

  }, {
    key: '_mismatchTypeMessage',
    value: function _mismatchTypeMessage(absPath, shouldBeDir, prefix) {
      if (shouldBeDir) {
        return prefix + 'Expected directory, but file found: \'' + absPath + '\'.';
      }
      return prefix + 'Expected file, but directory found: \'' + absPath + '\'.';
    }
  }]);

  return ComponentFinder;
}();

exports.default = ComponentFinder;
//# sourceMappingURL=ComponentFinder.js.map