alchemymvc 1.3.21 → 1.4.0-alpha.1

package/lib/scripts/create_stages.js

@@ -0,0 +1,55 @@
+/**
+ * Load all the stages
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+requireCorePathAll('stages');
+
+/**
+ * Add the launching event listener
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {Alchemy.Stages.Stage}   stage
+ */
+STAGES.on('launching', function onLaunch(stage) {
+
+	if (typeof alchemy == 'undefined') {
+		return;
+	}
+
+	if (!alchemy.getSetting('debugging.debug')) {
+		return;
+	}
+
+	let id = stage.id.after('root.');
+
+	let colored_name = alchemy.colors.fg.getRgb(0, 5, 5) + id + alchemy.colors.reset;
+
+	let args = ['Launching', colored_name, 'stage…'];
+
+	let line = alchemy.printLog(alchemy.INFO, args, {level: 1});
+
+	if (line && line.args) {
+		stage.pledge.then(function finished() {
+			line.args.push('Done in', stage.ended - stage.started, 'ms');
+			line.dissect();
+			line.render();
+		});
+	}
+});
+
+/**
+ * Start all the stages
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+STAGES.launch([
+	'load_core',
+]);

package/lib/scripts/init_alchemy.js

@@ -0,0 +1,51 @@
+/**
+ * The alchemy global, where everything will be stored
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.0.1
+ * @version  0.4.0
+ *
+ * @type     {Alchemy}
+ */
+DEFINE('alchemy', new Alchemy());
+
+/**
+ * Define the log function
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.0.1
+ * @version  0.4.0
+ *
+ * @type     {Function}
+ */
+DEFINE('log', alchemy.log);
+
+for (let key in alchemy.Janeway.LEVELS) {
+	let name = key.toLowerCase();
+	let val = alchemy.Janeway.LEVELS[key];
+
+	log[name] = function(...args) {
+		return alchemy.printLog(val, args, {level: 2});
+	};
+}
+
+log.warn = log.warning;
+
+/**
+ * Define the todo log function
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.2.0
+ * @version  0.4.0
+ *
+ * @type     {Function}
+ */
+log.todo = function todo(...args) {
+
+	var options = {
+		gutter: alchemy.Janeway.esc(91) + '\u2620 Todo:' + alchemy.Janeway.esc(39),
+		level: 2
+	};
+
+	return alchemy.printLog(alchemy.TODO, args, options);
+};

package/lib/{init/requirements.js → scripts/preload_modules.js}

@@ -58,9 +58,22 @@ alchemy.hawkejs = Classes.Hawkejs.Hawkejs.getInstance();
 alchemy.toobusy = alchemy.use('toobusy-js', 'toobusy');
 
 /**
- * Load Sputnik, the stage-based launcher
+ * Compatibility for old Sputnik stage system
  */
-alchemy.sputnik = new (alchemy.use('sputnik', 'sputnik'))();
+alchemy.sputnik = STAGES.createSputnikShim({
+	http          : 'server.create_http',
+	core_app      : 'load_app.core_app',
+	plugins       : 'load_app.plugins',
+	base_app      : 'load_app.main_app',
+	middleware    : 'routes.middleware',
+	datasources   : 'datasource',
+	define_debug  : 'server.warn_debug',
+	socket        : 'server.websocket',
+	hawkejs_setup : 'routes.hawkejs',
+	routes        : 'routes',
+	start_server  : 'server.start',
+	listening     : 'server.listening',
+});
 
 /**
  * Real-time apps made cross-browser & easy with a WebSocket-like API.

package/lib/scripts/setup_devwatch.js

@@ -0,0 +1,238 @@
+'use strict';
+
+if (process.argv.indexOf('--disable-devwatch') > -1) {
+	return;
+}
+
+if (!alchemy.settings.debugging.kill_on_file_change) {
+	return;
+}
+
+const chokidar = alchemy.use('chokidar');
+
+if (!chokidar) {
+	log.warn('Can not watch files because Chokidar is not installed');
+	return;
+}
+
+let allowedPattern,
+    extensions,
+    prevcount,
+    watchlog,
+    watcher,
+    allowed,
+    ignored,
+    count,
+    cwd,
+    fs;
+
+fs = alchemy.use('fs');
+
+prevcount = 0;
+count = 0;
+
+ignored = /^app\/public\/views|^temp/;
+extensions = ['js', 'json'];
+cwd = process.cwd();
+
+// Get the extensions allowed to kill the server
+if (Array.isArray(alchemy.settings.debugging.kill_extensions)) {
+	extensions = alchemy.settings.debugging.kill_extensions;
+}
+
+allowedPattern = '';
+
+// Go over every extensionin the array
+extensions.forEach(function eachExtension(extension) {
+
+	if (allowedPattern) {
+		allowedPattern += '|';
+	}
+
+	allowedPattern += '\\.' + extension + '$';
+});
+
+// Create the regex
+allowed = new RegExp(allowedPattern);
+
+watchlog = Function.throttle(function watchlog() {
+
+	if (prevcount == count) {
+		return;
+	}
+
+	log.warn(count, 'files are being monitored for changes');
+	prevcount = count;
+}, 1500, false, true);
+
+// Use a map to log path results, because chokidar calls the `ignored`
+// option multiple times for each file
+let seen_map = new Map();
+
+// Start watching all the files, starting with the current working directory
+watcher = chokidar.watch(cwd, {ignored: function ignoreThisPath(_path) {
+
+	let cached = seen_map.get(_path);
+
+	if (cached != null) {
+		return cached;
+	}
+
+	let isAllowed,
+		path = _path,
+		stat = arguments[1],
+		file;
+
+	// Ignore git folders
+	if (~path.indexOf('.git')) {
+		seen_map.set(_path, true);
+		return true;
+	}
+
+	// Ignore non-stylesheet files in asset or public folders
+	if (~path.indexOf('/assets/') || ~path.indexOf('/public/')) {
+		// DO watch less files, for the stylesheet reload!
+		if (path.indexOf('.') > -1 && !path.endsWith('.less') && !path.endsWith('.css') && !path.endsWith('.scss')) {
+			seen_map.set(_path, true);
+			return true;
+		} else {
+			isAllowed = true;
+		}
+	}
+
+	// Skip some big module folders by default
+	if (path.endsWith('/less') || path.endsWith('/caniuse-lite') || path.endsWith('/bcrypt') || path.endsWith('/sass') || path.endsWith('/mmmagic') || path.endsWith('/node-gyp') || path.endsWith('/lodash')) {
+		seen_map.set(_path, true);
+		return true;
+	}
+
+	watchlog();
+
+	if (count > 4999) {
+		if (count == 5000) {
+			count++
+			log.warn('Already watching 5000 files, not watching any more');
+		}
+
+		seen_map.set(_path, true);
+		return true;
+	}
+
+	path = path.replace(cwd+'/', '');
+	file = path.split('/');
+	file = file[file.length-1];
+
+	if (file == 'package.json' || file == 'package-lock.json' || file.startsWith('scratch')) {
+		seen_map.set(_path, true);
+		return true;
+	}
+
+	if (path.count('/coverage/') || path.count('/.') || path.count('/test/') || path.count('/benchmark/') || path.count('/deoptigate/')) {
+		seen_map.set(_path, true);
+		return true;
+	}
+
+	if (isAllowed == null) {
+		// Only allow the specified extensions
+		isAllowed = allowed.exec(file);
+	}
+
+	// If it's already false, return it
+	if (!isAllowed) {
+		// Only disallow if it's not a directory
+		try {
+
+			// The stat supplied by chokidar (if it is suppliad at all)
+			// does not follow symlinks, so *sigh* get it again
+			stat = fs.statSync(path);
+
+			if (!stat.isDirectory()) {
+				seen_map.set(_path, true);
+				return true;
+			}
+		} catch (err) {
+			seen_map.set(_path, true);
+			// Ignore files that have been removed
+			return true;
+		}
+	}
+
+	// See if it's still allowed based on patterns to ignore
+	isAllowed = !ignored.exec(path);
+
+	if (isAllowed && path.count('/plugins/') == 1 && path.count('node_modules')) {
+		isAllowed = false;
+	}
+
+	if (isAllowed && path.count('node_modules')) {
+		if (path.count('/codecov/') || path.count('/mocha/') || path.count('/nyc/')) {
+			isAllowed = false;
+		}
+	}
+
+	// If it's still allowed, make sure it isn't 2 or more node_modules deep
+	if (isAllowed && path.count('node_modules') > 1) {
+
+		if (path.count('node_modules') == 2 && path.endsWith('node_modules')) {
+			isAllowed = true;
+		} else if (path.count('protoblast') || path.count('hawkejs') || path.count('janeway')) {
+			if (path.count('node_modules') > 2) {
+				isAllowed = false;
+			}
+		} else {
+			isAllowed = false;
+		}
+	}
+
+	// If it's still allowed, increase the watch count
+	if (isAllowed) {
+		count++;
+	}
+
+	seen_map.set(_path, !isAllowed);
+
+	// Return if it should be ignored or not
+	return !isAllowed;
+
+}, persistent: true});
+
+// Kill the server when any of the files change
+watcher.on('change', function onFileChange(path, stats) {
+
+	// Skip hawkejs client file
+	if (path.indexOf('hawkejs-client-side.js') > -1) {
+		return false;
+	}
+
+	// Skip protoblast client files
+	if (path.indexOf('protoblast/client-file') > -1) {
+		return false;
+	}
+
+	// Also skip files in the temp directory
+	if (path.indexOf('temp/') === 0) {
+		return false;
+	}
+
+	// Skip assets or public files
+	if (path.indexOf('/assets/') > -1 || path.indexOf('/public/') > -1) {
+
+		if (path.endsWith('.css') || path.endsWith('.scss') || path.endsWith('.less')) {
+			broadcastReload(path);
+		}
+
+		return false;
+	}
+
+	// Only allow defined extensions
+	if (!allowed.exec(path)) {
+		return false;
+	}
+
+	// Kill the process, run together with something like "forever" to restart
+	die('Killing server because', JSON.stringify(path.replace(cwd + '/', '')), 'has been modified');
+});
+
+let broadcastReload = Function.throttle(function broadcastReload(path) {
+	alchemy.broadcast('css_reload', path);
+}, 10, false, true);

package/lib/stages/00-load_core.js

@@ -0,0 +1,342 @@
+const libpath = require('path');
+
+/**
+ * The "load_core" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const load_core = STAGES.createStage('load_core');
+
+/**
+ * The "load_core.init_settings" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const init_settings = load_core.createStage('init_settings', () => {
+	/**
+	 * Load the setting class
+	 */
+	requireCorePath('core', 'setting');
+
+	/**
+	 * Load the actual settings
+	 */
+	requireCorePath('scripts', 'create_settings');
+});
+
+/**
+ * The "load_core.init_alchemy" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const init_alchemy = load_core.createStage('init_alchemy', () => {
+	/**
+	 * Load the setting class
+	 */
+	requireCorePath('core', 'alchemy');
+
+	/**
+	 * Load the actual settings
+	 */
+	requireCorePath('scripts', 'init_alchemy');
+
+	/**
+	 * Require basic functions
+	 */
+	requireCorePath('core', 'alchemy_functions');
+
+	/**
+	 * Require load functions
+	 */
+	requireCorePath('core', 'alchemy_load_functions');
+});
+
+/**
+ * The "load_core.init_languages" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const init_languages = load_core.createStage('init_languages', () => {
+	/**
+	 * Get all the languages by their locale
+	 */
+	requireCorePath('scripts', 'create_languages');
+});
+
+/**
+ * The "load_core.preload_modules" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const preload_modules = load_core.createStage('preload_modules', () => {
+	/**
+	 * Pre-load basic requirements
+	 */
+	requireCorePath('scripts', 'preload_modules');
+});
+
+/**
+ * The "load_core.devwatch" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const devwatch = load_core.createStage('devwatch', () => {
+	/**
+	 * Set up file change watchers for development
+	 */
+	requireCorePath('scripts', 'setup_devwatch');
+});
+
+/**
+ * The "load_core.migration_class" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const migration_class = load_core.createStage('migration_class', () => {
+	/**
+	 * The migration class
+	 */
+	requireCorePath('class', 'migration');
+});
+
+/**
+ * The "load_core.core_classes" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const core_classes = load_core.createStage('core_classes', () => {
+
+	const CLIENT_HAWKEJS_OPTIONS = {
+
+		// Do not load on the server
+		server : false,
+
+		// Turn it into a commonjs load
+		make_commonjs: true,
+
+		// The arguments to add to the wrapper function
+		arguments : 'hawkejs'
+	};
+
+	const SERVER_HAWKEJS_OPTIONS = {
+
+		// Also load on the server
+		server : true,
+
+		// Turn it into a commonjs load
+		make_commonjs: true,
+
+		// The arguments to add to the wrapper function
+		arguments : 'hawkejs'
+	};
+
+	/**
+	 * Require the base class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    0.3.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('core', 'base'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the client_base class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.0.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('core', 'client_base'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the error class
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'error'), SERVER_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the client_alchemy class on the client side
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.0.5
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('core', 'client_alchemy'), SERVER_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the path_evaluator class
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'path_evaluator'), SERVER_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the field_value class
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'field_value'), SERVER_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the path_definition class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.0.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'path_definition'), CLIENT_HAWKEJS_OPTIONS);
+	alchemy.hawkejs.load(resolveCorePath('class', 'path_param_definition'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the element class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.0.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'element'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the helper class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.0.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'helper'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the datasource class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'datasource'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the field class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'field'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the schema_client class on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.1.0
+	 * @version  1.1.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('class', 'schema_client'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Require the setting classes on the client side too
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.4.0
+	 * @version  1.4.0
+	 */
+	alchemy.hawkejs.load(resolveCorePath('core', 'setting'), CLIENT_HAWKEJS_OPTIONS);
+
+	/**
+	 * Set up prefixes
+	 */
+	alchemy.useOnce(resolveCorePath('core', 'prefix'));
+
+	/**
+	 * Set up middleware functions
+	 */
+	alchemy.useOnce(resolveCorePath('core', 'middleware'));
+
+	/**
+	 * Load discovery code
+	 */
+	alchemy.useOnce(resolveCorePath('core', 'discovery'));
+
+	/**
+	 * Load inode classes
+	 */
+	alchemy.useOnce(resolveCorePath('class', 'inode'));
+	alchemy.useOnce(resolveCorePath('class', 'inode_file'));
+	alchemy.useOnce(resolveCorePath('class', 'inode_dir'));
+	alchemy.useOnce(resolveCorePath('class', 'inode_list'));
+});
+
+/**
+ * The "load_core.main_classes" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const main_classes = load_core.createStage('main_classes', () => {
+	// Load in all main classes
+	alchemy.usePath(resolveCorePath('class'));
+});
+
+/**
+ * The "load_core.app_bootstrap" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const app_bootstrap = load_core.createStage('app_bootstrap', () => {
+	// Load the base bootstrap file
+	try {
+		alchemy.useOnce(libpath.resolve(PATH_ROOT, 'app', 'config', 'bootstrap'));
+	} catch (err) {
+		if (err.message.indexOf('Cannot find') === -1) {
+			alchemy.printLog(alchemy.WARNING, 'Could not load app bootstrap file');
+			throw err;
+		} else {
+			alchemy.printLog(alchemy.SEVERE, 'Could not load config bootstrap file', {err: err});
+		}
+	}
+});