@masonite/slab-cli/lib/util.js

const fs = require( 'fs' );
const chalk = require( 'chalk' );
const nconf = require( 'nconf' );
const getPort = require( 'get-port' );
const sh = require( 'shelljs' );
const p = require( 'path' );
const app = require( '../lib/app' );

const util = {

	/**
	 * Remove http(s):// + port number from url.
	 * @param {String} url The project's url.
	 * @return {String}
	 */
	getProjectHostname( url ) {
		const domain = url.substring( 0, url.lastIndexOf( ':' ) );
		const hostname = domain.replace( /(^\w+:|^)\/\//, '' );

		return hostname;
	},

	/**
	 * Get the number of profiles available.
	 * @return {Integer}
	 */
	getNumberOfProfiles() {
		const numberOfProfiles = fs.readdirSync( app.profilesDir ).length;

		return numberOfProfiles;
	},

	/**
	 * Get available profiles.
	 * @return {Array}
	 */
	getProfiles() {
		const profiles = [];

		fs.readdirSync( app.profilesDir ).forEach( ( profile ) => {
			const profilePath = `${app.profilesDir}/${profile}`;
			profiles.push( profilePath );
		});

		return profiles;
	},

	/**
	 * Get the info about a specific project.
	 * @param {Object} dataProjects The remote project data.
	 * @param {String} prj Name of project to get available environments from.
	 */
	getProjectInfo( dataProjects, prj ) {
		const project = dataProjects.filter( obj => obj.slug === prj );

		return project[0];
	},

	/**
	 * Get the info about a specific project type.
	 * @param {String} type The selected type.
	 * @param {Object} dataProjectTypes The remote project type data.
	 * @return {Object}
	 */
	getProjectTypeInfo( type, dataProjectTypes ) {
		const typeInfo = dataProjectTypes.filter( obj => obj.name === type );

		return typeInfo[0];
	},

	/**
	 * Check if object is empty.
	 * @param {Object} obj The object.
	 * @return {Boolean}
	 */
	isEmptyObject( obj ) {
		return !Object.keys( obj ).length;
	},

	/**
	 * Check if project has any environments.
	 * @param {Object} dataProjects Remote project data.
	 * @param  {String} prj Name of project to get available environments from.
	 * @return {Boolean}
	 */
	projectHasEnvs( dataProjects, prj ) {
		const project = util.getProjectInfo( dataProjects, prj );
		const envs = project.env;

		if ( envs !== undefined ) {
			if ( !this.isEmptyObject( envs ) ) {
				return true;
			}
		}

		return false;
	},

	/**
	 * Get local projects.
	 * @return {Object}
	 */
	getLocalProjects() {
		const localProjects = nconf.get( 'local_projects' );

		return localProjects;
	},

	/**
	 * Check if any local projects are available.
	 * @return {Boolean}
	 */
	localProjectsExist() {
		const localProjects = nconf.get( 'local_projects' );

		if ( localProjects === undefined ) {
			return false;
		}

		if ( !this.isEmptyObject( localProjects ) ) {
			return true;
		}

		return false;
	},

	/**
	 * Check if an individual project already exists.
	 * @param {String} slug The project's slug.
	 * @return {Boolean}
	 */
	localProjectExists( slug ) {
		const localProject = nconf.get( `local_projects:${slug}` );

		if ( localProject === undefined ) {
			return false;
		}

		if ( !this.isEmptyObject( localProject ) ) {
			return true;
		}

		return false;
	},

	/**
	 * Get varialbe name.
	 * getVarName({ email })
	 * @param {Object} varObj The variable as a single object.
	 * @return {String} Variable name.
	 */
	getVarName( varObj ) {
		return Object.keys( varObj )[0];
	},

	/**
	 * Increment slug.
	 * @param {String} existingSlug The slug for the project that already exists.
	 * @return {String}
	 */
	getNextSlugIncrement( existingSlug ) {
		let newSlug = existingSlug;
		let firstPart;
		let lastPart;

		do {
			firstPart = newSlug.substring( 0, newSlug.lastIndexOf( '_' ) );
			lastPart = newSlug.split( '_' ).pop();

			if ( !Number.isNaN( lastPart ) && lastPart !== '' && lastPart !== newSlug ) {
				let num = parseInt( lastPart, 10 );
				num += 1;
				newSlug = `${firstPart}_${num}`;
			} else {
				newSlug = `${newSlug}_2`;
			}
		}
		while ( this.localProjectExists( newSlug ) );

		return newSlug;
	},

	/**
	 * Remove multiple adjacent, leading, & trailing whitespace.
	 * @param {String} str
	 * @return {String}
	 */
	trimWhitespace( str ) {
		const str1 = str.trim();
		const str2 = str1.replace( /\s\s+/g, ' ' );

		return str2;
	},

	/**
	 * Get the ports already being used by slab.
	 * @return {Array}
	 */
	getReservedSlabPorts() {
		const localProjects = this.getLocalProjects();
		const reservedPorts = [];

		Object.keys( localProjects ).forEach( ( key ) => {
			const reservedPort = nconf.get( `local_projects:${key}:ports` );
			reservedPorts.push( reservedPort );
		});

		return reservedPorts;
	},

	/**
	 * Generate pair of ports that are not already in use.
	 * @return {Array} Port number.
	 */
	async generatePorts() {
		const reservedSlabPortsData = this.getReservedSlabPorts();
		const reservedSlabPorts = [].concat( ...reservedSlabPortsData );
		const ports = [];

		do {
			ports[0] = await getPort();
		}
		while ( reservedSlabPorts.includes( ports[0] ) );

		return ports;
	},

	/**
	 * Execute shell command from within a project.
	 * @param {String} path The absolute path to run command from.
	 * @param {String} cmd The shell command to run within the project's root directory.
	 */
	execFrom( path, cmd ) {
		if ( path === '' || path === undefined || typeof path === 'undefined' || path === '/' ) {
			console.log( chalk`{red Illegal path.}` );
			process.exit( 1 );
		}

		sh.exec( `cd ${path}; ${cmd}` );
	},

	/**
	 * Replace project types data placeholders with corresponding project values.
	 * @param {Object} src The source object that has placeholder values.
	 * @param {String} slug The project's slug.
	 * @param {String} path The project's path.
	 * @param {Array} ports The project's reserved ports.
	 * @param {String} url The project's url.
	 * @return {Object}
	 */
	replacePlaceholders( src, slug, path, ports, url ) {
		let srcStr = JSON.stringify( src );
		const email = nconf.get( 'email' );

		if ( src === undefined || src === null || typeof src === 'undefined' ) {
			console.log( chalk`{red The project has a project type that does not exist.}` );
			process.exit( 1 );
		}

		const port1 = ports[0];

		srcStr = srcStr.replace( /\{{email}}/gim, email );
		srcStr = srcStr.replace( /\{{project_url}}/gim, url );
		srcStr = srcStr.replace( /\{{project_name}}/gim, slug );
		srcStr = srcStr.replace( /\{{project_path}}/gim, path );
		srcStr = srcStr.replace( /\{{project_port_1}}/gim, port1 );
		srcStr = srcStr.replace( /\{{project_slug}}/gim, slug );

		const srcObj = JSON.parse( srcStr );

		return srcObj;
	},

	/**
	 * Check if any configuration profiles exists.
	 * @return {Boolean}
	 */
	profilesExist() {
		const profileDirExists = fs.existsSync( app.profilesDir );

		if ( profileDirExists ) {
			const numberOfProfiles = this.getNumberOfProfiles();

			if ( numberOfProfiles > 0 ) {
				return true;
			}
		}

		return false;
	},

	/**
	 * Get the name of the current profile.
	 * @param {Boolean} output Output name to console.
	 * @return {String}
	 */
	getCurrentProfileName( output = false ) {
		nconf.file( app.config );

		const currentProfilePath = nconf.get( 'current_profile' );
		const name = this.getProfileName( currentProfilePath );

		if ( output ) {
			console.log( name );
		}

		return name;
	},

	/**
	 * Get the path of a specific profile name.
	 * @param {String} name The name of the profile.
	 * @return {String}
	 */
	getProfilePath( name ) {
		let path = '';

		if ( name ) {
			path = `${app.profilesDir}/${name}.json`;
		}

		return path;
	},

	/**
	 * Get the name of a specific profile name.
	 * @param {String} path The path of the profile.
	 * @return {String}
	 */
	getProfileName( path ) {
		let name = '';

		if ( path ) {
			name = p.basename( path, p.extname( path ) );
		}

		return name;
	},

	/**
	 * Get the path to the current profile.
	 * @return {string}
	 */
	getCurrentProfilePath() {
		nconf.file( app.config );

		const currentProfilePath = nconf.get( 'current_profile' );

		return currentProfilePath;
	},

	/**
	 * Enforce keys to be required.
	 * @param {Array} keys Required keys.
	 */
	requireKeys( keys ) {
		const errors = [];

		// Find config errors.
		keys.forEach( ( key ) => {
			const value = nconf.get( key );

			if ( value === undefined ) {
				errors.push({
					item    : key,
					message : chalk`Cannot find the key {blue ${key}}.`,
				});
			}
			if ( value === '' ) {
				errors.push({
					item    : key,
					message : chalk`No value found for {blue ${key}}.`,
				});
			}
		});

		// Report any errors.
		if ( errors.length ) {
			errors.forEach( ( error ) => {
				console.log( chalk`{red Error:} ${error.message}` );
			});
			process.exit( 1 );
		}
	},

};

module.exports = util;