motion/lib/runner/cache.js

motion - moving development forward

exports.__esModule = true;

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { var callNext = step.bind(null, 'next'); var callThrow = step.bind(null, 'throw'); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(callNext, callThrow); } } callNext(); }); }; }

var _disk = require('./disk');

var _disk2 = _interopRequireDefault(_disk);

var _libHandleError = require('./lib/handleError');

var _libHandleError2 = _interopRequireDefault(_libHandleError);

var _opts = require('./opts');

var _opts2 = _interopRequireDefault(_opts);

var _libFns = require('./lib/fns');

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var relative = function relative(f) {
  return _libFns.path.relative(_baseDir, f).replace('.motion/.internal/out/', '');
};

var meta = {};
var previousCache = undefined;
var cache = {
  files: {},
  imports: [],
  fileMeta: {}
};

var _baseDir = '';
var deleteFileCbs = [];
var deleteViewCbs = [];
var addViewCbs = [];

function onSetExported(file, val) {
  // debugger // TODO: remove from either out or add to out
}

function onDeleteFile(_ref) {
  var name = _ref.name;
  var file = _ref.file;
  var state = _ref.state;

  deleteFileCbs.forEach(function (cb) {
    return cb({ name: name, file: file, state: state });
  });
}

function onDeleteViews(views) {
  views.forEach(function (view) {
    return deleteViewCbs.forEach(function (cb) {
      return cb(view);
    });
  });
}

function onAddViews(views) {
  views.forEach(function (view) {
    return addViewCbs.forEach(function (cb) {
      return cb(view);
    });
  });
}

var files = function files(file) {
  return cache.files[relative(file)];
};

var Cache = {
  relative: relative,

  init: _asyncToGenerator(function* () {
    if (!_opts2['default']('reset')) {
      try {
        // read in previous cache
        var state = yield _disk2['default'].state.read();
        previousCache = state.cache;

        Cache.setBaseDir(_opts2['default']('appDir'));
      } catch (e) {
        _libHandleError2['default'](e);
      }
    }

    previousCache = previousCache || {
      files: {}
    };
  }),

  setBaseDir: function setBaseDir(dir) {
    _baseDir = _libFns.path.resolve(dir);
    _libFns.log.cache('baseDir', _baseDir);
  },

  baseDir: function baseDir() {
    return _baseDir;
  },

  name: function name(file) {
    return relative(file);
  },

  add: function add(file) {
    if (!file) return;
    var n = relative(file);
    cache.files[n] = cache.files[n] || {};
    cache.files[n].added = Date.now();
    return cache.files[n];
  },

  update: function update(file) {
    Cache.setWritten(file, Date.now());
    Cache.removeError(file);
  },

  get: function get(file) {
    return files(file);
  },

  getAll: function getAll() {
    return cache.files;
  },

  getPrevious: function getPrevious(file) {
    return previousCache.files[relative(file)];
  },

  restorePrevious: function restorePrevious(file) {
    var n = relative(file);
    cache.files[n] = previousCache.files[n];
  },

  onDeleteFile: function onDeleteFile(cb) {
    deleteFileCbs.push(cb);
  },

  onDeleteView: function onDeleteView(cb) {
    deleteViewCbs.push(cb);
  },

  onAddView: function onAddView(cb) {
    addViewCbs.push(cb);
  },

  remove: function remove(file) {
    var name = relative(file);
    var state = cache.files[name];
    _libFns.log.cache('remove', name);
    delete cache.files[name];
    onDeleteFile({ file: file, name: name, state: state });
  },

  setViews: function setViews(file, views) {
    if (!file) return;
    var cFile = files(file);
    onDeleteViews(_libFns._.difference(cFile.views, views));
    // onAddViews(_.difference(views, cFile.views))
    cFile.views = views;
    _libFns.log.cache('setViews', views);
  },

  setFileMeta: function setFileMeta(file, fileMeta) {
    meta[relative(file)] = fileMeta;
  },

  getFileMeta: function getFileMeta(file) {
    return meta[relative(file)];
  },

  setFileSrc: function setFileSrc(file, src) {
    files(file).src = src;
  },

  isInternal: function isInternal(file) {
    var f = files(file);
    return f && f.isInternal;
  },

  setFileInternal: function setFileInternal(file, val) {
    var name = relative(file);
    var f = cache.files[name];

    if (!f) return;

    var isInternal = f.isInternal;
    cache.files[name].isInternal = val;

    if (isInternal != val) onSetExported(name, val);
  },

  getExported: function getExported() {
    _libFns.log.cache('cache', 'getExported', cache.files);
    return Object.keys(cache.files).map(function (name) {
      return cache.files[name].isInternal ? name : null;
    }).filter(function (f) {
      return f != null;
    });
  },

  setFileImports: function setFileImports(file, imports) {
    var cacheFile = Cache.get(file) || Cache.add(file);
    var externals = imports;
    var internals = _libFns._.remove(externals, function (n) {
      return n && n.charAt(0) == '.';
    });
    cacheFile.externals = externals;
    cacheFile.internals = internals;
  },

  getFile: function getFile(file) {
    return files(file);
  },

  getViews: function getViews(file) {
    return files(file).views;
  },

  _getFileKeys: function _getFileKeys(key) {
    var result = _libFns._.flatten(Object.keys(cache.files).map(function (file) {
      return cache.files[file][key];
    })).filter(function (x) {
      return !!x;
    });
    return result;
  },

  // npm
  getExternals: function getExternals(file) {
    if (!file) return Cache._getFileKeys('externals');
    return files(file).externals;
  },

  // ./local
  getInternals: function getInternals(file) {
    if (!file) return Cache._getFileKeys('internals');
    return files(file).internals;
  },

  // npm + local
  getImports: function getImports(file) {
    return [].concat(cache.getInterals(file), cache.getExternals(file));
  },

  getInternalImporters: function getInternalImporters() {
    return Object.keys(cache.files).map(function (file) {
      var data = cache.files[file];
      return data.internals && data.internals.length && file;
    }).filter(function (x) {
      return !!x;
    });
  },

  addError: function addError(file, error) {
    if (!n) return;

    var n = relative(file);

    if (!cache.files[n]) Cache.add(n);

    cache.files[n].error = error;
  },

  removeError: function removeError(file) {
    if (files(file)) files(file).error = null;
  },

  getLastError: function getLastError() {
    var paths = Object.keys(cache.files);
    var errors = paths.map(function (p) {
      return cache.files[p].error;
    }).filter(function (e) {
      return !!e;
    });

    if (errors.length) {
      var _ret = (function () {
        var latest = errors[0];

        errors.forEach(function (err) {
          if (err.timestamp > latest.timestamp) latest = err;
        });

        return {
          v: latest
        };
      })();

      if (typeof _ret === 'object') return _ret.v;
    }

    return null;
  },

  setWritten: function setWritten(file, time) {
    var f = files(file);
    _libFns.log.cache('setWritten', time);
    if (f) f.writtenAt = time;
  },

  serialize: function serialize() {
    _libFns.log.cache('serialize');
    _disk2['default'].state.write(function (state, write) {
      state.cache = cache;
      _libFns.log.cache('writing cache');
      write(state);
    });
  },

  debug: function debug() {
    print(_util2['default'].inspect(cache, false, 10));
  }

};

exports['default'] = Cache;
module.exports = exports['default'];