@masonite/slab-cli/commands/clone.js

const inquirer = require( 'inquirer' );
const fs = require( 'fs' );
const sh = require( 'shelljs' );
const chalk = require( 'chalk' );
const opn = require( 'opn' );
const nconf = require( 'nconf' );
const prompt = require( '../lib/prompt' );
const config = require( '../lib/config' );
const util = require( '../lib/util' );
const docker = require( '../lib/docker' );
const git = require( '../lib/git' );

/**
 * The main command.
 * @param {Object} program Program options.
 * @param {Object} dataProjects Remote project data.
 * @param {Array} dataProjectTypes The types of projects available to create.
 */
async function clone( program, dataProjects, dataProjectTypes ) {
	const optionProject = program.args[0].project;
	const optionDirectory = program.args[0].directory;
	const optionEnvironment = program.args[0].environment;

	let envObj;
	let cloneAgainObj;

	// Get the available ports to use for this project.
	const ports = await util.generatePorts();

	// Get project.
	let projectResponse;
	if ( optionProject ) {
		projectResponse = optionProject;
	} else {
		const projObj = await inquirer.prompt( prompt.getProjPrompt( dataProjects ) );
		projectResponse = projObj.answer;
	}
	const project = await util.getProjectInfo( dataProjects, projectResponse );
	const { name, type } = project;
	let { slug } = project;
	if ( util.localProjectExists( slug ) ) {
		const newSlug = util.getNextSlugIncrement( slug );
		cloneAgainObj = await inquirer.prompt( prompt.getAlreadyExistsPrompt( slug, newSlug ) );
		if ( !cloneAgainObj.answer ) {
			process.exit();
		} else {
			slug = newSlug;
		}
	}

	// Get Url.
	const url = `http://${slug}.slab:${ports[0]}`;

	// Get directory.
	let directoryResponse;
	if ( optionDirectory ) {
		if ( optionDirectory === 'default' ) {
			directoryResponse = nconf.get( 'default_clone_path' );
		} else {
			directoryResponse = optionDirectory;
		}
	} else {
		const dirObj = await inquirer.prompt( prompt.getDirPrompt() );
		directoryResponse = dirObj.answer;
	}
	const path = `${directoryResponse}/${slug}`;

	// Get type.
	const typeInfoDirty = util.getProjectTypeInfo( type, dataProjectTypes );
	const typeInfo = util.replacePlaceholders( typeInfoDirty, slug, path, ports, url );
	const projectRepo = project.repo.dev;

	const cmdBeforeContainersInit = typeInfo.cmd_before_containers_init;
	const cmdAfterContainersInit = typeInfo.cmd_after_containers_init;
	const { files } = typeInfo;

	// Get environment.
	let environmentResponse;
	if ( optionEnvironment ) {
		environmentResponse = optionEnvironment;
	} else if ( util.projectHasEnvs( dataProjects, projectResponse ) ) {
		envObj = await inquirer.prompt( prompt.getEnvPrompt( dataProjects, projectResponse ) );
		environmentResponse = envObj.answer;
	}

	// Create directory to filesystem if it doesn't exist.
	sh.mkdir( '-p', path );

	// If project directory was able to be created.
	if ( fs.existsSync( path ) ) {
		// Clone project to filesystem.
		await git.clone( projectRepo, path );

		// Save project data to local slab config.
		config.updateName( slug, name );
		config.updateType( slug, type );
		config.updatePath( slug, path );
		config.updateUrl( slug, url );
		config.updateLastUpdatedTime( slug );
		config.updatePorts( slug, ports );

		// Shell command to run before docker container is created.
		if ( cmdBeforeContainersInit ) {
			util.execFrom( path, cmdBeforeContainersInit );
		}

		// Setup docker container for selected project.
		await docker.setup( slug, url, typeInfo );

		// Create files.
		if ( files ) {
			files.forEach( ( file ) => {
				fs.writeFileSync( `${file.location}/${file.filename}`, file.contents );
			});
		}

		// Shell command to run after docker container is created.
		if ( cmdAfterContainersInit ) {
			await util.execFrom( path, cmdAfterContainersInit );
		}

		// Open site in default browser.
		opn( url, { wait: false });
	}

	console.log( 'done.' );
}

module.exports = clone;