motion/lib/runner/cache.js

motion - moving development forward

'use strict';

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

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

var _disk2 = _interopRequireDefault(_disk);

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

var _handleError2 = _interopRequireDefault(_handleError);

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

var _opts2 = _interopRequireDefault(_opts);

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

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

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) { 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 { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

const relative = f => _fns.path.relative(baseDir, f).replace('.motion/.internal/out/', '');

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

let baseDir = '';
let deleteFileCbs = [];
let deleteViewCbs = [];
let addViewCbs = [];

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

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

  deleteFileCbs.forEach(cb => cb({ name, file, state }));
}

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

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

function getFile(path) {
  const file = cache.files[relative(path)];

  if (!file) throw new Error('No file found in cache, ' + path);

  return file;
}

const Cache = {
  relative,

  init() {
    return _asyncToGenerator(function* () {
      if (!(0, _opts2.default)('reset')) {
        try {
          // read in previous cache
          const state = yield _disk2.default.state.read();
          previousCache = state.cache;

          Cache.setBaseDir((0, _opts2.default)('appDir'));
        } catch (e) {
          (0, _handleError2.default)(e);
        }
      }

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

  setBaseDir(dir) {
    baseDir = _fns.path.resolve(dir);
    _fns.log.cache('baseDir', baseDir);
  },

  baseDir() {
    return baseDir;
  },

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

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

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

  get(file) {
    return getFile(file);
  },

  getAll() {
    return cache.files;
  },

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

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

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

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

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

  remove(file) {
    const name = relative(file);
    const state = cache.files[name];
    _fns.log.cache('remove', name);
    delete cache.files[name];
    onDeleteFile({ file, name, state });
  },

  setViews(file, views) {
    if (!file) return;
    const cFile = getFile(file);
    onDeleteViews(_fns._.difference(cFile.views, views));
    // onAddViews(_.difference(views, cFile.views))
    cFile.views = views;
    _fns.log.cache('setViews', views);
  },

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

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

  setFileSrc(file, src) {
    getFile(file).src = src;
  },

  isInternal(file) {
    const f = getFile(file);
    return f && f.isInternal;
  },

  setFileInternal(file, isInternal) {
    const name = relative(file);
    const f = Cache.get(file);

    const wasInternal = f.isInternal;
    f.isInternal = isInternal;

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

  getExported() {
    const result = Object.keys(cache.files).map(name => cache.files[name].isInternal ? name : null).filter(f => f != null);

    return result;
  },

  setFileImports(file, imports) {
    let cacheFile = Cache.get(file) || Cache.add(file);
    let externals = imports;
    let internals = _fns._.remove(externals, n => n && n.charAt(0) == '.');
    cacheFile.externals = externals;
    cacheFile.internals = internals;
  },

  getFile(file) {
    return getFile(file);
  },

  getViews(file) {
    return getFile(file).views;
  },

  _getFileKeys(key) {
    const result = _fns._.flatten(Object.keys(cache.files).map(file => cache.files[file][key])).filter(x => !!x);
    return result;
  },

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

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

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

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

  addError(file, error) {
    if (!file) return;
    let n = relative(file);
    if (!cache.files[n]) Cache.add(n);
    cache.files[n].error = error;
  },

  removeError(file) {
    const f = getFile(file);
    _fns.log.cache('removeError', f);
    f.error = null;
  },

  getLastError() {
    let paths = Object.keys(cache.files);
    let errors = paths.map(p => cache.files[p].error).filter(e => !!e);

    if (errors.length) {
      let latest = errors[0];

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

      return latest;
    }

    return null;
  },

  setWritten(file, time) {
    _fns.log.cache('setWritten', time);
    Cache.get(file).writtenAt = time;
  },

  setFileInstalling(file, val) {
    Cache.get(file).installing = val;
  },

  isInstalling(file) {
    const f = getFile(file);
    return f ? f.installing : false;
  },

  serialize() {
    _fns.log.cache('serialize');
    _disk2.default.state.write((state, write) => {
      state.cache = cache;
      _fns.log.cache('writing cache');
      write(state);
    });
  },

  debug() {
    print(_util2.default.inspect(cache, false, 10));
  }

};

exports.default = Cache;
//# sourceMappingURL=cache.js.map