Homec4science
Diffusion Primo_3_package (master) Browse

Primo3/gulp/tasks/prepareAddon.js
6bd6fcd52732master

Last Change
Raw File

prepareAddon.js
View Options

'use strict';
const gulp = require('gulp');
const config = require('../config.js');
const spawn = require('child_process').spawn;
const fs = require('fs');
const Promise = require('bluebird');
const prompt = require('prompt');
const camelCase = require('camel-case');
const streamToPromise = require('stream-to-promise');
const colors = require('colors/safe');
const path = require('path');
let buildParams = config.buildParams;
gulp.task('prepare-addon', ['select-view', 'custom-js','custom-scss','custom-css'], function() {
let view = config.view();
let packageJsonPath = buildParams.viewRootDir() + '/package.json';
let npmId;
let directoryName;
let hookName;
let runNpmInitIfNeeded = new Promise((resolve, reject) => {
if (!fs.existsSync(packageJsonPath)) {
let childProcess = spawn('npm', ['init'], {cwd: buildParams.viewRootDir(), shell: true, stdio: 'inherit'});
childProcess.on('error', err => {
reject(err);
});
childProcess.on('exit', (code, signal) => {
if (!code) {
resolve();
}
});
} else {
resolve();
}
});
return runNpmInitIfNeeded
.then(findNpmIdInPackageJson, handleError)
.then(makeDirectory, handleError)
.then(copyFiles, handleError)
.then(compileAddon, handleError)
.then(createDescriptorJson, handleError)
.then(announceFinishedProcess, handleError);
function findNpmIdInPackageJson() {
return new Promise((resolve, reject) => {
fs.exists(packageJsonPath, exists => {
if (exists) {
fs.readFile(packageJsonPath, (err, data) => {
if (err) {
reject(err);
}
let packageJson = JSON.parse(data.toString());
npmId = camelCase(packageJson.name);
resolve();
});
}
});
});
}
function makeDirectory() {
return new Promise((resolve, reject) => {
directoryName = './addons/' + npmId;
fs.mkdir(directoryName, err => reject(err));
resolve();
})
}
function copyFiles() {
return streamToPromise(gulp.src(['./primo-explore/custom/' + view + '/package*.json', './primo-explore/custom/' + view + '/html/**', './primo-explore/custom/' + view + '/img/**', './primo-explore/custom/' + view + '/css/custom1.css', './primo-explore/custom/' + view + '/js/custom.js'], {base: './primo-explore/custom/' + view})
.pipe(gulp.dest(directoryName)));
}
function compileAddon() {
return new Promise((resolve, reject) => {
let customJsPath = directoryName + '/js/' + buildParams.customFile;
if (fs.existsSync(customJsPath)) {
fs.readFile(customJsPath, (err, data) => {
if (err) {
reject(err);
}
let dataString = data.toString();
// remove comments
dataString = dataString.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '');
// group 1 = component name, group 2 = controller name if exists controller
let componentRegex = /\.component[\s]*?\([\s]*?['"](prm.*?After)['"](?:(?:(?!\.component)[\s\S])*?controller[\s]*?:[\s]*?['"](.*)['"])?/g;
if (dataString.match(componentRegex).length > 1) {
let arr = [];
let match;
while (match = componentRegex.exec(dataString)) {
arr.push(match[1]);
}
reject(new Error('Only one Primo hook allowed, you tried to use several: ' + arr.toString()));
}
let match = componentRegex.exec(dataString);
if (match) {
hookName = match[1];
let controllerName = match[2]; // may be null
dataString = dataString.replace(new RegExp(controllerName || '', 'g'), npmId + 'Controller');
dataString = dataString.replace(new RegExp(hookName, 'g'), npmId);
}
// remove wrapping function
let wrappingFunctionRegex = /\s*?\(\s*?function\s*?\(\s*?\)\s*?{\s*(?:["']use strict["'];\s*)?([\s\S]*)\s*?}\s*?\)\s*?\(\s*?\)\s*?;?/g;
if (match = wrappingFunctionRegex.exec(dataString)) {
dataString = dataString.replace(wrappingFunctionRegex, match[1]);
}
// remove app declaration
// group 1 = app variable name
let appDeclarationViewOrCentralCustomRegex = /[\s]*(?:var|let)?[\s]*(.*?)[\s]*=[\s]*angular[\s]*\.module\([\s]*['"](?:view|central)Custom['"][\s]*,[\s]*\[['"]angularLoad['"]\]\);/g;
if (match = appDeclarationViewOrCentralCustomRegex.exec(dataString)) {
// remove matched line
dataString = dataString.replace(appDeclarationViewOrCentralCustomRegex, '');
// change all the occurrences of the variable to 'app'
let variableName = match[1];
if (variableName !== 'app') {
let variableUseRegex = new RegExp('([[=(,]\\s*?)' + variableName + '([^\\w])|([^\\w])' + variableName + '(\\s*?[.)|\\]}=;])', 'gm');
dataString = dataString.replace(variableUseRegex, '$1$3app$2$4');
}
}
// remove constant config if exists
// group 1 = config name
let studioConfigDeclerationRegex = /\.(?:constant|value|service|factory)[\s]*?\([\s]*['"](.*?StudioConfig)/g;
if (dataString.match(studioConfigDeclerationRegex)) {
dataString = dataString.replace(studioConfigDeclerationRegex, '$&DevenvTest');
}
// group 1 = module name
let moduleRegex = /\.module[\s]*?\([\s]*((?:').*?(?:')|(?:").*?(?:")|.*?)[\s]*?[),]/g;
// push all modules
while (match = moduleRegex.exec(dataString)) {
dataString = dataString + '\napp.requires.push(' + match[1] + ');';
}
// write content to {{npmId}}.js
let wstream = fs.createWriteStream(directoryName + '/js/' + npmId + '.js');
wstream.write(dataString);
wstream.end();
// delete custom.js file
fs.unlink(customJsPath, err1 => {
if (err1) {
reject(err1);
}
});
resolve();
});
} else {
resolve();
}
});
}
function createDescriptorJson() {
return new Promise((resolve, reject) => {
let npmignorePath = directoryName + '/.npmignore';
let descriptorJsonFileName = 'descriptor.json';
let descriptorJsonPath = directoryName + '/' + descriptorJsonFileName;
console.log("Creating '.npmignore' file\n");
// create .npmignore file with descriptor.json
let wstream = fs.createWriteStream(npmignorePath);
wstream.write(descriptorJsonFileName + '\n');
wstream.end();
console.log("Creating 'descriptor.json' file\n");
// needed values for descriptor.json: face (image), notes (description), who (author), what (title), linkGit, npmid, version, hook
let descriptor = {'face': '', 'notes': '', 'who': '', 'what': '', 'linkGit': '', 'npmid': '', 'version': '', 'hook': hookName};
// get known values from package.json
fs.readFile(packageJsonPath, (err, data) => {
if (err) {
reject(err);
}
let packageJson = JSON.parse(data.toString());
descriptor.notes = packageJson.description;
descriptor.who = packageJson.author.name || packageJson.author; // maybe empty, but is string
if (packageJson.repository) {
descriptor.linkGit = packageJson.repository.url || packageJson.repository; // maybe null
}
descriptor.npmid = packageJson.name;
descriptor.version = packageJson.version;
// until here have: notes (description), who (author) {maybe}, linkGit {maybe}, npmid, version, hook
// need to ask for: face (image), who (author) {maybe}, what (title), linkGit {maybe}
// ask for values not exists already
console.log("This utility will walk you through creating a 'descriptor.json' file.\n" +
"It only covers the most common items, and tries to guess sensible defaults.");
prompt.start();
prompt.colors = false;
prompt.message = '';
let properties = [
{
name: 'what',
message: 'Enter title',
required: true,
default: descriptor.npmid
}, {
name: 'face',
message: 'Enter a link to photo of you',
required: true
}
];
if (!descriptor.who) {
properties.push(
{
name: 'who',
message: 'Enter author/s name/s',
required: true
});
}
if (!descriptor.linkGit) {
properties.push(
{
name: 'linkGit',
message: 'Enter link to repository',
required: true
});
}
prompt.get(properties, (err, result) => {
if (err) {
reject(err);
}
descriptor.what = result.what;
descriptor.face = result.face;
if (result.who) {
descriptor.who = result.who;
}
if (result.linkGit) {
descriptor.linkGit = result.linkGit;
}
// create descriptor json with values
wstream = fs.createWriteStream(descriptorJsonPath);
wstream.write(JSON.stringify(descriptor));
wstream.close();
resolve();
});
});
});
}
function announceFinishedProcess() {
console.log('\n');
process.stdout.write('Finished compiling addon\n');
console.log('');
process.stdout.write(colors.green('Addon can be found at ' ));
process.stdout.write(colors.cyan(path.resolve('./addons/' + npmId)));
process.stdout.write(colors.green('.\nIn order to publish to NPM: Navigate to the addon folder. Review the \'package.json\' file. Then run \'npm publish\'.\n'));
process.stdout.write(colors.green('A basic descriptor for your addon was created in the file \'descriptor.json\'. Please review it and edit fields accordingly.\n'));
process.stdout.write(colors.green('When you are ready to publish to Primo-Studio, create a pull request at '));
process.stdout.write(colors.cyan('https://github.com/primousers/primostudio/tree/submit_here'));
process.stdout.write(colors.green(' appending your descriptor to the \'features.json\' file.\n'));
}
function handleError(err) {
// if fails at any time - clean addon folder
if (directoryName) {
fs.unlink(directoryName);
}
console.error(err.message);
}
});
c4science · Help