particle-commands/dist/cmd/projects.js

Library of UX-neutral commands that provide key functionality for developer tools

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.Projects = exports.Libraries = exports.ParticleFolder = undefined;

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 _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _os = require('os');

var _os2 = _interopRequireDefault(_os);

var _es6Promisify = require('es6-promisify');

var _es6Promisify2 = _interopRequireDefault(_es6Promisify);

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

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

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

var particle = 'Particle';
var libraries = 'libraries';
var projects = 'projects';
var community = 'community';

var SystemFolders = function () {
	function SystemFolders() {
		var fs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : require('fs');

		_classCallCheck(this, SystemFolders);

		this.fsMkdir = (0, _es6Promisify2.default)(fs.mkdir);
		this.fsStat = (0, _es6Promisify2.default)(fs.stat);
	}

	_createClass(SystemFolders, [{
		key: 'mkdir',
		value: function mkdir(name) {
			return this.fsMkdir(name).then(function () {
				return true;
			}).catch(function (error) {
				if (error.code === 'EEXIST') {
					return false;
				}
				throw error;
			});
		}
	}, {
		key: 'mkdirp',
		value: function mkdirp(name) {
			var _this = this;

			return this.fsStat(name).then(function (stat) {
				if (!stat.isDirectory()) {
					var error = new Error('file already exists');
					error.code = 'EEXIST';
					throw error;
				}
				return false;
			}).catch(function (error) {
				if (error.code === 'ENOENT') {
					var parent = _path2.default.dirname(name);
					var promise = void 0;
					if (parent && parent !== '/' && parent !== '.') {
						promise = _this.mkdirp(parent);
					}
					// even simply creating the promise causes them to be executed out of order
					// we can only get the correct order by creating the promise when we are sure
					// the parent folder has been created.
					return promise ? promise.then(function () {
						return _this.mkdir(name);
					}) : _this.mkdir(name);
				}
				throw error;
			});
		}
	}, {
		key: 'findHomePath',
		value: function findHomePath() {
			var defaultPath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : __dirname;
			var fs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : require('fs');

			var envVars = ['home', 'HOME', 'HOMEPATH', 'USERPROFILE'];

			for (var i = 0; i < envVars.length; i++) {
				var dir = process.env[envVars[i]];
				if (dir && fs.existsSync(dir)) {
					return dir;
				}
			}
			return defaultPath;
		}
	}, {
		key: 'userHomeFolder',
		value: function userHomeFolder() {
			return _os2.default.homedir();
		}
	}, {
		key: 'windowsDocumentsFolder',
		value: function windowsDocumentsFolder() {
			return new Promise(function (fulfill, _rej) {
				var winreg = require('winreg');
				var regKey = winreg({
					hive: winreg.HKCU, // open registry hive HKEY_CURRENT_USER
					key: '\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders' // key containing user folder paths
				});
				var documents = void 0;

				// list "Documents" folder path
				regKey.values(function (err, items) {
					if (err) {
						//					console.log('ERROR: '+err);
					} else {
						for (var i = 0; i < items.length && !documents; i++) {
							if (items[i].name.toLowerCase() === 'personal') {
								documents = items[i].value;
								return fulfill(documents);
							}
						}
					}
				});
			});
		}
	}, {
		key: 'documentsFolder',
		value: function documentsFolder() {
			var _this2 = this;

			if (process.platform === 'win32') {
				return this.windowsDocumentsFolder().then(function (documents) {
					return documents || _this2.userHomeFolder();
				});
			} else {
				return this.userHomeFolder();
			}
		}
	}, {
		key: 'ensureDirectoryExists',
		value: function ensureDirectoryExists(directory) {
			return this.mkdirp(directory);
		}
	}]);

	return SystemFolders;
}();

var ParticleFolder = exports.ParticleFolder = function (_SystemFolders) {
	_inherits(ParticleFolder, _SystemFolders);

	function ParticleFolder() {
		_classCallCheck(this, ParticleFolder);

		return _possibleConstructorReturn(this, (ParticleFolder.__proto__ || Object.getPrototypeOf(ParticleFolder)).apply(this, arguments));
	}

	_createClass(ParticleFolder, [{
		key: 'particleFolder',
		value: function particleFolder() {
			return this.join(this.documentsFolder(), particle);
		}
	}, {
		key: '_communityFolder',
		value: function _communityFolder() {
			return this.join(this.particleFolder(), community);
		}
	}, {
		key: 'join',
		value: function join(path1, path2) {
			return Promise.resolve(path1).then(function (path1) {
				return _path2.default.join(path1, path2);
			});
		}
	}]);

	return ParticleFolder;
}(SystemFolders);

var Libraries = exports.Libraries = function (_ParticleFolder) {
	_inherits(Libraries, _ParticleFolder);

	function Libraries() {
		_classCallCheck(this, Libraries);

		return _possibleConstructorReturn(this, (Libraries.__proto__ || Object.getPrototypeOf(Libraries)).apply(this, arguments));
	}

	_createClass(Libraries, [{
		key: 'myLibrariesFolder',
		value: function myLibrariesFolder() {
			return this.join(this.particleFolder(), libraries);
		}
	}, {
		key: 'communityLibrariesFolder',
		value: function communityLibrariesFolder() {
			return this.join(this._communityFolder(), libraries);
		}
	}]);

	return Libraries;
}(ParticleFolder);

var Projects = exports.Projects = function (_ParticleFolder2) {
	_inherits(Projects, _ParticleFolder2);

	function Projects() {
		_classCallCheck(this, Projects);

		return _possibleConstructorReturn(this, (Projects.__proto__ || Object.getPrototypeOf(Projects)).apply(this, arguments));
	}

	_createClass(Projects, [{
		key: 'myProjectsFolder',
		value: function myProjectsFolder() {
			return this.join(this.particleFolder(), projects);
		}
	}, {
		key: 'communityProjectsFolder',
		value: function communityProjectsFolder() {
			return this.join(this._communityFolder(), projects);
		}
	}]);

	return Projects;
}(ParticleFolder);