gulp-gwd/index.js

"use strict";
const PLUGIN_NAME = "gulp-gwd";
const through = require("through2");
const gutil = require("gulp-util");
const PluginError = gutil.PluginError;
const File = gutil.File;
const fs = require('graceful-fs')
const path = require("path");
const fsUtils = require("nodejs-fs-utils");

//const img_regex = /<\s*img\s*.[^>]*? (?:src|source)\s*=\s*['"]?([^'"\s]+)['"]?/gi;
//const css_regex = /url\s*\(['"]?(.[^'"\s]+)['"]?\)/gi;
//const script_regex = /<\s*script\s*[^>]*? src\s*=\s*['"]?([^'"\s]+)['"]?/gi;
//const link_regex = /<\s*link\s*.[^>]*? href\s*=\s*['"]?([^'"\s]+)['"]?/gi;

const ignoreExts = ["", ".cmd", ".db", ".psd", ".fla"];
const ignoreFiles = ["gwd_workspace.json"];

var assets = [];
var checkedAssets = [];
var folder = "";
var logFunc = function(str){ console.log(str) };

module.exports = function(options) {
	var indexExists = false;
	var htmlFiles = [];
	var removedFiles = [];
	
	options = options || {};
	options.step = options.step || "";
	options.ignored = options.ignored || [];
	options.required = options.required || [];
	if (options.logFunc !== null && typeof options.logFunc === "function"){
		logFunc = options.logFunc;
	}

	function filter(file, encoding, callback) {
		if (file.isNull()) { callback(null, file); return; }
		if (file.isStream()) { callback(new PluginError(PLUGIN_NAME, "Streaming not supported")); return; }
		try {
			var filepath = String(file.history);
			if (~ignoreExts.indexOf(path.extname(filepath)) || ~ignoreFiles.indexOf(path.basename(filepath))){ callback(); return; } 
			this.push(file);
		} catch (err) {
			this.emit("error", new PluginError(PLUGIN_NAME, err));
		}

		callback();
	}
	function getFiles(file, encoding, callback) {
		if (file.isNull()) { callback(null, file); return; }
		if (file.isStream()) { callback(new PluginError(PLUGIN_NAME, "Streaming not supported")); return; }
		try {
			var filepath = String(file.history);
			var extname = path.extname(filepath);
			var filename = path.basename(filepath);
			
			if (extname === ".html") { 
				if (filename !== "index.html"){
					htmlFiles.push(String(filepath));
				} else {
					checkedAssets.push(String(filepath));
					indexExists = true;
				}
			} else {
				if (!~options.ignored.indexOf(filename)){
					assets.push(String(filepath));
				} else {
					checkedAssets.push(String(filepath));
				}
			}
			this.push(file);
			
		} catch (err) {
			this.emit("error", new PluginError(PLUGIN_NAME, err));
		}
		callback();
	}
	function renameHtml(callback) {
		if (indexExists === true) { callback(); return }
		if (htmlFiles.length === 1){
			var oldPath = path.normalize(htmlFiles[0]);
			var newPath = path.join(path.dirname(oldPath), "index.html"); 
			if (fs.existsSync(oldPath)){
				fs.createReadStream(oldPath).pipe(fs.createWriteStream(newPath));
				checkedAssets.push(String(newPath));
			}
		} else if (htmlFiles.length > 1){
			this.emit("error", new PluginError(PLUGIN_NAME, "Found " + htmlFiles.length + " .html files, just 1 needed"));
		} else {
			this.emit("error", new PluginError(PLUGIN_NAME, "HTML file is missing"));
		}
		callback();
	};
	
	function replacer(str, group, offset) {
		if (group.indexOf("data:") === 0 || path.isAbsolute(group) === true) return str;
		var newName = String(path.basename(group));
		var oldPath = path.join(folder, group);
		
		if (group !== newName){
			var newPath = path.join(folder, newName);
			
			if (!~checkedAssets.indexOf(newPath)){
				checkedAssets.push(newPath);
				if (fs.existsSync(oldPath) && fs.statSync(oldPath).isFile() === true) {
					fs.renameSync(oldPath, newPath);
				}
			}
			return str.replace(group, newName);
			
		} else {
			if (!~checkedAssets.indexOf(oldPath)){
				checkedAssets.push(oldPath);
			}
			return str;
		}
		
	}
	function index(file, encoding, callback) {
		if (file.isNull()) { callback(null, file); return; }
		if (file.isStream()) { callback(new PluginError(PLUGIN_NAME, "Streaming not supported")); return; }
		try {
			var filepath = String(file.history);
			var filename = path.basename(filepath);
			if (filename !== "index.html" || folder !== ""){ callback(); return; }
			folder = path.dirname(filepath);
			
			var regAssets = [];
			for (var i = 0; i < assets.length; i++) {
				regAssets[i] = path.relative(folder, assets[i]).replace(/(\\|\/)/, unescape('[\\/|\\\\]'));
			}
			var assetsRegExp = new RegExp(unescape("[\"\'\()][\\/|\\\\]?") + "(" + regAssets.join("|") + ")[\"\'\)]", "g");
			
			var data = file.contents.toString();
			data = data.replace(assetsRegExp, replacer);
			file.contents = new Buffer(data);
			this.push(file);
			
		} catch (err) {
			this.emit("error", new PluginError(PLUGIN_NAME, err));
		}
		callback();
	}
	
	function output_filter(file, encoding, callback) {
		if (file.isNull()) { callback(null, file); return; }
		if (file.isStream()) { callback(new PluginError(PLUGIN_NAME, "Streaming not supported")); return; }
		try {
			var filepath = String(file.history);
			var filename = path.basename(filepath);
			
			if (~checkedAssets.indexOf(String(filepath))){ 
				this.push(file);
			} else {
				var extname = path.extname(filename);
				if (extname !== ".js" && extname !== ".css" && extname !== ".html") removedFiles.push(filename);
			}
		} catch (err) {
			this.emit("error", new PluginError(PLUGIN_NAME, err));
		}
		
		callback();
	}
	function output_report(callback) {
		if (removedFiles.length > 0){
			gutil.log(gutil.colors.bold.yellow("Removed files: " + removedFiles.join(", ")));
		}
		callback();
	};
	function finish(file, encoding, callback) {
		if (file.isNull()) { callback(null, file); return; }
		if (file.isStream()) { callback(new PluginError(PLUGIN_NAME, "Streaming not supported")); return; }
		try {
			var filepath = String(file.history);
			var filename = path.basename(filepath);
			if (filename !== "index.html"){ callback(); return; }
			
			var outputFolder = path.dirname(filepath);
			var outputFolderSize = fsUtils.fsizeSync(outputFolder);
			
			//emptyFolders
			var all = fs.readdirSync(outputFolder);
			for (var i = 0; i < all.length; i++) {
				var elemPath = path.join(outputFolder, all[i]);
				if (fs.statSync(elemPath).isDirectory() === true && fsUtils.fsizeSync(elemPath) === 0){
					fsUtils.rmdirsSync(elemPath);
				}
			}
			this.push(file);
			
			if (options.required.length > 0) {
				for (var i = 0; i < options.required.length; i++) {
					var req = options.required[i];
					var found = false;
					for (var j = 0; j < req[0].length; j++) {
						if (~checkedAssets.indexOf(path.join(folder, req[0][j]))){
							found = true;
							break;
						}
					}
					if (found === false){
						/*var newfile = new File({
							cwd: __dirname,
							base: __dirname,
							path: path.join(__dirname, req[1]),
							contents: new Buffer("")
						});
						this.push(newfile);*/
						logFunc("<br><span style='color:red'>" + req[1] + " is missing</span>");
					} 
				}
			}
		} catch (err) {
			this.emit("error", new PluginError(PLUGIN_NAME, err));
		}

		callback();
	}
	if (options.step === "filter"){
		return through.obj(filter);
	} else if (options.step === "init"){
		return through.obj(getFiles, renameHtml);
	} else if (options.step === "output"){
		return through.obj(output_filter, output_report);
	} else if (options.step === "finish"){
		return through.obj(finish);
	} else {
		return through.obj(index);
	}
};