exportUser(options) {
let source = jet.dir(options.user);
let target = jet.dir(options.target + '/user');
console_1.console.log('export user from ' + source.path() + ' to ' + target.path());
try {
jet.copy(source.path(), target.path(), {
matching: [
'**',
'!./.git/**/*',
'!**/**claycenter',
'!./claycenter',
'!**claycenter'
],
overwrite: true
});
}
catch (err) {
if (err.code === 'EEXIST') {
console_1.console.error('Error copying, file exists!', err);
}
if (err.code === 'EACCES') {
console_1.console.error('Error copying, file access perrmissions!', err);
}
console_1.console.error('error : ', err);
}
}
exportClientEx(options) {
let source = jet.dir(path.resolve(options.client) + '');
let target = jet.dir(options.target + '/Code/client');
jet.copy(source.path(), target.path(), {
matching: [
'**'
],
overwrite: true
});
}
exportClientDist(options) {
let source = jet.dir(options.root + '/dist/windows/Code/client/');
let target = jet.dir(options.target + '/Code/client');
jet.copy(source.path(), target.path(), {
matching: [
'**'
],
overwrite: true
});
}
exportMisc(options) {
let source = jet.dir(options.root + '/export');
let target = jet.dir(options.target);
jet.copy(source.path(), target.path(), {
matching: [
'**'
],
overwrite: true
});
/**
* update config
*/
let template = io.read(path.resolve(source.path() + '/profile_device_server.json'));
let content = StringUtils_1.replace(template, null, options, {
begin: '%',
end: '%'
});
if (options.linux32) {
jet.exists(target.path() +
path.sep + '/server/linux_32/nxappmain/profile_device_server.json') && io.write(target.path() + path.sep +
'/server/linux_32/nxappmain/profile_device_server.json', content);
}
if (options.linux64) {
jet.exists(target.path() +
path.sep + '/server/linux_64/nxappmain/profile_device_server.json') && io.write(target.path() + path.sep +
'/server/linux_64/nxappmain/profile_device_server.json', content);
}
if (options.windows) {
jet.exists(target.path() +
path.sep + '/server/windows/nxappmain/profile_device_server.json') && io.write(target.path() + path.sep +
'/server/windows/nxappmain/profile_device_server.json', content);
}
if (options.arm) {
jet.exists(target.path() +
path.sep + '/server/arm/nxappmain/profile_device_server.json') && io.write(target.path() + path.sep +
'/server/arm/nxappmain/profile_device_server.json', content);
}
if (options.osx) {
jet.exists(target.path() +
path.sep + '/server/osx_64/nxappmain/profile_device_server.json') && io.write(target.path() + path.sep + '/server/osx_64/nxappmain/profile_device_server.json', content);
}
/**
* update boot start.js
*/
template = io.read(path.resolve(source.path() + '/start.js'));
content = StringUtils_1.replace(template, null, options, {
begin: '%',
end: '%'
});
options.linux32 !== false && jet.exists(target.path() + '/server/linux_32/start.js') && io.write(target.path() + '/server/linux_32/start.js', content);
options.linux64 !== false && jet.exists(target.path() + '/server/linux_64/start.js') && io.write(target.path() + '/server/linux_64/start.js', content);
options.windows !== false && io.write(target.path() + '/server/windows/start.js', content);
options.arm !== false && jet.exists(target.path() + '/server/arm/start.js') && io.write(target.path() + '/server/arm/start.js', content);
options.osx !== false && jet.exists(target.path() + '/server/osx_64/start.js') && io.write(target.path() + '/server/osx_64/start.js', content);
}
exportSystem(options) {
let source = jet.dir(options.system + '/system');
let target = jet.dir(options.target + '/data/system');
console_1.console.log('export system data from ' + source.path() + ' to ' + target.path());
jet.copy(source.path(), target.path(), {
matching: [
'**'
],
overwrite: true
});
}
/**
*
* @param options
*/
exportMongo(options) {
let source = jet.dir(options.serverTemplates + '/mongo');
let target = jet.dir(options.target + '/mongo');
jet.copy(source.path(), target.path(), {
matching: [
'mongod-arm',
'mongod-linux_32',
'mongod-linux_64',
'mongod-windows.exe',
'mongod-32.exe',
'mongod-osx'
],
overwrite: true
});
}
releaseForOs.osx = function (callback) {
var appdmg = require('appdmg');
var releasesDir = projectDir.dir('./releases');
var manifest = projectDir.read('app/package.json', 'json');
var dmgName = manifest.name + '_' + manifest.version + '.dmg';
// Change app bundle name to desired
projectDir.rename("build/node-webkit.app", manifest.prettyName + ".app");
// Prepare appdmg config
var dmgManifest = projectDir.read('os/osx/appdmg.json');
dmgManifest = utils.replace(dmgManifest, {
prettyName: manifest.prettyName,
appPath: projectDir.path("build/" + manifest.prettyName + ".app"),
dmgIcon: projectDir.path("os/osx/dmg-icon.icns"),
dmgBackground: projectDir.path("os/osx/dmg-background.png")
});
tmpDir.write('appdmg.json', dmgManifest);
// Delete dmg with this name if already exists
releasesDir.file(dmgName, { exists: false });
gulpUtil.log('Packaging to DMG image...');
appdmg(tmpDir.path('appdmg.json'), releasesDir.path(dmgName), function (err, path) {
gulpUtil.log('DMG image', path, 'ready!');
cleanTmp();
callback();
});
};
releaseForOs.windows = function (callback) {
projectDir.dir('./releases');
var manifest = projectDir.read('app/package.json', 'json');
var filename = manifest.name + '_' + manifest.version + '.exe';
var installScript = projectDir.read('./os/windows/installer.nsi');
installScript = utils.replace(installScript, {
"name": manifest.name,
"prettyName": manifest.prettyName,
"version": manifest.version,
// The paths expect the .nsi file is in "nw-boilerplate/tmp" folder.
"src": "..\\build",
"dest": "..\\releases\\" + filename,
"icon": "..\\os\\windows\\icon.ico",
"setupIcon": "..\\os\\windows\\setup-icon.ico",
"banner": "..\\os\\windows\\setup-banner.bmp"
});
projectDir.write('./tmp/installer.nsi', installScript);
gulpUtil.log('Building installer with NSIS...');
// Note: NSIS have to be added to PATH!
var nsis = childProcess.spawn('makensis', ['.\\tmp\\installer.nsi']);
nsis.stdout.pipe(process.stdout);
nsis.stderr.pipe(process.stderr);
nsis.on('close', function () {
gulpUtil.log('Installer', filename, 'ready!');
cleanTmp();
callback();
});
};
tmp.dir({unsafeCleanup: true}, function (err, dir) {
if (err) {
throw err;
}
tmpDir = jetpack.dir(dir + '/extracted', { mode: '755' });
done();
});
exportHTMLFile(options) {
let exportRoot = jet.dir(options.root + '/export/');
let source = jet.dir(options.target + '/user/workspace/');
let file = path.resolve(source.path() + '/ascene.dhtml');
let template = io.read(path.resolve(exportRoot.path() + '/app.template.html'));
let templateVariables = _.mixin({
libRoot: '/Code/client/src/lib',
lodashUrl: '/Code/client/src/lib/external/lodash.min.js',
requireBaseUrl: "/Code/client/src/lib/xibm/ibm",
jQueryUrl: "/Code/client/src/lib/external/jquery-1.9.1.min.js",
data: "",
user: "******",
css: "./ascene.css",
theme: "bootstrap",
blox_file: "./ascene.xblox",
mount: "workspace",
"VFS_VARS": json_1.serialize({
"user_drivers": './user/drivers',
"system_drivers": './system/drivers'
}, null, 2)
}, options);
template = StringUtils_1.replace(template, null, templateVariables, {
begin: '%',
end: '%'
});
let content = io.read(file);
content = content.replace('<viewHeaderTemplate/>', template);
let did = false;
content = content.replace(/\burl\s*\(\s*["']?([^"'\r\n\)\(]+)["']?\s*\)/gi, function (matchstr, parens) {
let parts = parens.split('://');
let mount = parts[0];
let path = parts[1];
if (mount && path) {
did = true;
return "url('./" + path + "')";
}
return parens;
});
let dom = cheerio.load(content);
let extra = '\n<script type="text/javascript">';
extra += '\n\tvar test = 0;';
extra += '\n</script>';
dom('HEAD').append(dom(extra));
io.write(file.replace('.dhtml', '.html'), dom.html());
}
var updateMetadataFile = function (key, value) {
var releasesDir = projectDir.dir('./releases');
var manifest = projectDir.read('app/package.json', 'json');
var metadata = releasesDir.read('release.json', 'json') || {};
metadata.version = manifest.version;
metadata.release_date = new Date();
metadata[key] = value;
releasesDir.write('release.json', metadata, { jsonIndent: 2 });
};
module.exports.initDB = function(opts = {}, fn = () => {}) {
if (opts.DEV) {
/**
* Store the database in the /build directory
*/
jetpack.dir(path.resolve(__dirname, '..', 'db'));
db = new Trilogy(path.resolve(__dirname, '..', 'db', 'singularity.db'));
} else {
switch (opts.LOCATION) {
case 'home': {
// app directory in the user home folder
jetpack.dir(path.resolve(Settings.get('dataPath'), 'db'));
db = new Trilogy(path.resolve(Settings.get('dataPath'), 'db', 'singularity.db'));
break;
}
case 'data': {
// app directory in the OS data folder
jetpack.dir(path.resolve(app.getAppPath(), 'db'));
db = new Trilogy(path.resolve(app.getAppPath(), 'db', 'singularity.db'));
break;
}
case 'custom': {
// user configured a custom location for the db
const dbPath = Settings.get('databaseLocation', path.resolve(app.getAppPath(), 'db'));
jetpack.dir(path.resolve(dbPath));
db = new Trilogy(path.resolve(dbPath, 'singularity.db'));
break;
}
default: {
throw new TypeError('ERR in initDB:: Invalid LOCATION property');
}
}
if (db) {
_initTables();
fn && fn(data);
} else {
throw new Error('ERR in initDB:: Database was not initialized.');
}
}
};
releaseForOs.linux = function (callback) {
var releasesDir = projectDir.dir('./releases');
var manifest = projectDir.read('app/package.json', 'json');
var packName = manifest.name + '_' + manifest.version;
var pack = tmpDir.dir(packName);
var debFileName = packName + '_amd64.deb';
gulpUtil.log('Creating DEB package...');
// The whole app will be installed into /opt directory
projectDir.copy('build', pack.path('opt', manifest.name));
// Create .desktop file from the template
var desktop = projectDir.read('os/linux/app.desktop');
desktop = utils.replace(desktop, {
name: manifest.name,
prettyName: manifest.prettyName,
description: manifest.description,
version: manifest.version,
author: manifest.author
});
pack.write('usr/share/applications/' + manifest.name + '.desktop', desktop);
// Counting size of the app in KB
var appSize = Math.round(projectDir.inspectTree('build').size / 1024);
// Preparing debian control file
var control = projectDir.read('os/linux/DEBIAN/control');
control = utils.replace(control, {
name: manifest.name,
description: manifest.description,
version: manifest.version,
author: manifest.author,
size: appSize
});
pack.write('DEBIAN/control', control);
// Build the package...
childProcess.exec('fakeroot dpkg-deb -Zxz --build ' + pack.path() + ' ' + releasesDir.path(debFileName),
function (error, stdout, stderr) {
if (error || stderr) {
console.log("ERROR while building DEB package:");
console.log(error);
console.log(stderr);
} else {
gulpUtil.log('Package', debFileName, 'ready!');
}
cleanTmp();
updateMetadataFile('latest_linux_package', debFileName);
callback();
});
};
exportHTML(options) {
try {
let source = jet.dir(options.target + '/user/workspace/');
let thiz = this;
function parseDirectory(_path, name) {
// name = directory abs
let dirItems = fs.readdirSync(_path);
if (dirItems.length) {
_.each(dirItems, function (file) {
// file = file name
if (file.indexOf('.dhtml') !== -1) {
let root = name.replace(source.path() + '/', '');
thiz.exportHTMLFile2(_path + '/' + file, root, options);
}
});
}
}
function _walk(dir) {
let results = [];
if (fs.existsSync(dir)) {
let list = fs.readdirSync(dir);
list.forEach(function (file) {
file = dir + '/' + file;
let stat = fs.statSync(file);
if (stat) {
let root = file.replace(path + '/', '');
if (stat.isDirectory()) {
parseDirectory(file, root);
}
else {
if (file.indexOf('.dhtml') !== -1) {
root = root.replace(dir + '/', '');
thiz.exportHTMLFile2(file, root, options);
}
}
}
else {
console_1.console.error('cant get stat for ' + file);
}
});
}
else {
console_1.console.error('device path ' + dir + ' doesnt exists');
}
return results;
}
_walk(source.path());
}
catch (e) {
console_1.console.error('Error exporting HTML', e);
}
}
copyServer(options, platform) {
let target = jet.dir(options.target + '/server/' + platform);
let isDebug = false;
let source = "";
if (options.nodeServers) {
if (!jet.exists(options.nodeServers + '/' + platform)) {
return;
}
source = jet.dir(options.nodeServers + '/' + platform);
}
else {
if (!isDebug) {
source = jet.dir(options.root + '/server/' + platform);
}
else {
source = jet.dir(options.root + '/server/nodejs/dist/' + platform);
}
}
if (!jet.exists(source.path())) {
return;
}
console_1.console.info('export Device-Server ' + platform + ' from : ' + source.path());
try {
jet.copy(source.path(), target.path(), {
matching: [
'**'
],
overwrite: true
});
}
catch (err) {
if (err.code === 'EEXIST') {
console_1.console.error('Error copying, file exists!', err);
}
if (err.code === 'EACCES') {
console_1.console.error('Error copying, file access perrmissions!', err);
}
}
}
exportHTMLFile2(file, folder, options) {
let exportRoot = jet.dir(options.root + '/export/');
let template = io.read(path.resolve(exportRoot.path() + '/app.template.html'));
let path_parts = FileUtils_1.pathinfo(file, FileUtils_1.EPATH_PARTS.PATHINFO_ALL);
const dirName = path.dirname(file);
const fileName = path.basename(file);
if (folder === fileName) {
folder = "";
}
let templateVariables = {
libRoot: '/Code/client/src/lib',
lodashUrl: '/Code/client/src/lib/external/lodash.min.js',
requireBaseUrl: "/Code/client/src/lib/xibm/ibm",
jQueryUrl: "/Code/client/src/lib/external/jquery-1.9.1.min.js",
data: "",
user: "******",
css: './' + cleanUrl(fileName.replace('.dhtml', '.css')),
theme: "bootstrap",
blox_file: "./" + folder + '/' + fileName.replace('.dhtml', '.xblox'),
scene_file: "./" + folder + '/' + fileName,
mount: "workspace",
"VFS_VARS": json_1.serialize({
"user_drivers": './user/drivers',
"system_drivers": './system/drivers'
}, null, 2)
};
//console.log('export HTML' + folder + '/' + fileName);
template = StringUtils_1.replace(template, null, templateVariables, {
begin: '%',
end: '%'
});
let content = io.read(file);
content = content.replace('<viewHeaderTemplate/>', template);
content = content.replace(/\burl\s*\(\s*["']?([^"'\r\n\)\(]+)["']?\s*\)/gi, function (matchstr, parens) {
let parts = parens.split('://');
let mount = parts[0];
let path = parts[1];
if (mount && path) {
return "url('./" + path + "')";
}
return parens;
});
let dom = cheerio.load(content);
let extra = '\n<script type="text/javascript">';
extra += '\n\tvar test = 0;';
extra += '\n</script>';
dom('HEAD').append(dom(extra));
io.write(file.replace('.dhtml', '.html'), dom.html());
}
module.exports.getProjectRootJetpack = function() {
if (ardublocklyRootDir === null) {
// Cannot use relative paths in build, so let's try to find the
// ardublockly folder in a node from the executable file path tree
ardublocklyRootDir = jetpack.dir(__dirname);
var oldArdublocklyRootDir = '';
while (ardublocklyRootDir.path() != oldArdublocklyRootDir) {
// Check if /ardublokly/index.html exists within current path
if (jetpack.exists(
ardublocklyRootDir.path('ardublockly', 'index.html'))) {
// Found the right folder, break with this dir loaded
break;
}
oldArdublocklyRootDir = ardublocklyRootDir.path();
ardublocklyRootDir = ardublocklyRootDir.dir('../');
}
if (ardublocklyRootDir.path() == oldArdublocklyRootDir) {
ardublocklyRootDir = jetpack.dir('.');
ardublocklyNotFound(ardublocklyRootDir.path('.'));
}
}
return ardublocklyRootDir;
};
var Q = require('q');
var childProcess = require('child_process');
var projectDir = require('fs-jetpack');
var utils = require('./utils');
// --------------------------------------------------------
// Preparations
// --------------------------------------------------------
var devManifest = projectDir.read('package.json', 'json');
var appManifest = projectDir.read('app/package.json', 'json');
// Version of NW.js we need
var runtimeVersion = devManifest.config.nw.version;
// The directory where runtime should be placed
var destDir = projectDir.dir('nw/' + utils.os());
// First check if we already haven't downloaded this version of runtime.
if (destDir.read('version') === runtimeVersion) {
// No need for continuing
process.exit();
}
// Figure out the URL we have to download.
var url = devManifest.config.nw.downloadUrls[utils.os()];
// URL has places where we have to inject version we are interested with.
url = utils.replace(url, { version: runtimeVersion });
var finalize = function () {
var deferred = Q.defer();
beforeEach(function () {
jetpack.dir(testPath, { empty: true });
});
var jetpack = require('fs-jetpack');
var fillWithSillyBytes = function (buf) {
// Very predictable pattern leads to high compression
// and not blowing up the size of this repo.
for (var i = 0; i < buf.length; i += 1) {
buf[i] = i % 256;
}
return buf;
};
var zero = new Buffer(0);
var oneKib = fillWithSillyBytes(new Buffer(1024));
var twoMib = fillWithSillyBytes(new Buffer(1024 * 1024 * 2));
// Generate the files structure
var root = jetpack.dir('extracted', { empty: true });
root
.dir('dir1')
.dir('dir2')
.file('0B', { content: zero })
.file('1KiB', { content: oneKib })
.file('2MiB', { content: twoMib })
root
.dir('empty');
// Generate spec file to which we can later compare
// our extracted stuff during tests.
var spec = jetpack.inspectTree('extracted', { checksum: 'sha1' });
jetpack.write('spec.json', spec, { jsonIndent: 2 });
afterEach(function() {
jetpack.dir(tmpdir, { exists: false });
});
const errHandler = function(err) {
if (err) Logger.error(err);
};
/**
* Creates or accesses singularity.db
* @function IIFE
*/
{
/**
* Store the database in the /build directory
* Probably best for development, so maybe make it based on dev mode?
* Possibly make it user-defined as well
*/
jetpack.dir(path.resolve(__dirname, '..', 'db'));
db = new Trilogy(path.resolve(__dirname, '..', 'db', 'singularity.db'));
/**
* ... or in the app's directory in the user's home folder?
jetpack.dir(path.resolve(Settings.get('dataPath'), 'db'));
db = dbstore(path.resolve(Settings.get('dataPath'), 'db', 'singularity.db'));
*/
/**
* ... or in the app's directory in the OS app folder?
jetpack.dir(path.resolve(app.getAppPath(), 'db'));
db = dbstore(path.resolve(app.getAppPath(), 'db', 'singularity.db'));
*/
}
'use strict';
var gulp = require('gulp');
var gulpUtil = require('gulp-util');
var childProcess = require('child_process');
var projectDir = require('fs-jetpack');
var utils = require('./utils');
var releaseForOs = {};
var tmpDir = projectDir.dir('./tmp', { empty: true });
var cleanTmp = function () {
tmpDir.remove('.');
};
// -------------------------------------
// OSX
// -------------------------------------
releaseForOs.osx = function (callback) {
var appdmg = require('appdmg');
var releasesDir = projectDir.dir('./releases');
var manifest = projectDir.read('app/package.json', 'json');
var dmgName = manifest.name + '_' + manifest.version + '.dmg';
// Change app bundle name to desired
projectDir.rename("build/node-webkit.app", manifest.prettyName + ".app");
// Prepare appdmg config
var dmgManifest = projectDir.read('os/osx/appdmg.json');