funkophile 0.0.1

package/README.md

@@ -0,0 +1,45 @@
+# Funkophile
+
+The _func_ tional _file_ processor.
+
+### About
+#### *What* is Funkophile?
+
+Funkophile is a build tool that inputs files, processes them, and then outputs them. Optionally, it can watch those files for changes, and updating the output files very efficiently. No plugins are needed because what once was configuration is now code- EVERYTHING is done in redux selectors.
+
+#### What is Funkophile *not*?
+
+- Funkophile is _not_ webpack or rollup. It does not *just* build JS bundles, though it could help you do so.
+- Funkophile is _not_ grunt or gulp. It is not *just* a task runner, it is a file-processor. The "tasks" Funkophile runs are functions run on files. 
+- Funkophile is _not_ a module loader.
+- Funkophile is _not necessarily_ for web development. It has a much broader use-case.
+
+#### *Why* is Funkophile **awesome**?
+
+Funkophile is a functional file processor. It lets you manipulate files in a *functional* way- using redux selectors- and it does so efficiently- using promises. **It lets you focus on the logic of your selectors and disregard the processing of files**. You setup in some files to read, some files to write, and some selectors filled with easily testable logic- Funkophile will handle the borings parts for you! When you first start Funkophile, it will process every file. Subsequent changes to an input file will run through your selectors and automatically update _only_ the dependent output files. It just works! (tm)
+
+#### What Funkophile *can do*
+
+- Funkophile can replace your flavor-of-the-week State Site Generator with a hackable and lightweight solution.
+- Funkophile can replace some of the things that grunt or gulp do.
+- Funkophile can replace some of the things that webpack is used for.
+- Funkophile can replace both build tools (like grunt and gulp) and bundlers (like webpack and rollup).
+- Funkophile is also very unopinionated and works well with other tools grunt, gulp, webpack, and rollups.
+- Funkophile can functionally and efficiently watch files for changes, process them, then write them back to the filesystem.
+
+#### What Funkophile *should not be used for*
+
+- Funkophile should only be used in a purely functional way. __Funkophile is asynchronous so that your code does not need to be.__ You should only use Funkophile if you can write purely functional redux selectors. Luckily, these concepts are not that difficult to learn!
+
+### Funkophile.config.js
+
+Funkophile is configured with Funkophile.config.js. It has 3 sections of note:
+
+#### inputs
+`inputs` is a list of configurations defining which files get read and where to store those results in the redux stores
+
+#### outputs
+`outputs` is a function which accepts object of selectors, keyed by inputs. These selectors are connected to the redux state and you can use it to handle changes to the redux state, which itself is reacting to changes in the filesystem. This function returns hash object, where the keys are files to write, and the values are the contents of those files.
+
+#### selectors
+At the heart of Funkophile is the selector. Within the `outputs` function, you can define any selectors you like, using any JS library you want, provided they are _purely functional_. This means that Funkophile needs no community plugins and can be made to do complex logic cleanly.

package/funkophileHelpers.js

@@ -0,0 +1,44 @@
+const createSelector = require('reselect').createSelector;
+
+module.exports = {
+
+	contentsOfFiles: (selector) => {
+		return createSelector([selector], (selected) => {
+			return Object.keys(selected).reduce((mm, k) => mm + selected[k], '')
+		})
+	},
+
+	contentOfFile: (selector) => {
+		return createSelector([selector], (selected) => {
+			try{
+        return selected[Object.keys(selected)[0]]
+      } catch (e) {
+        console.error("error", e)
+				console.error("selected", selected)
+				console.error("selector", selector)
+				process.exit(-1)
+      }
+		})
+	},
+
+	srcAndContentOfFile: (selector, key) => {
+		return createSelector([selector], (selected) => {
+			return {
+				src: key,
+				content: selected[key]
+			}
+		})
+	},
+
+	srcAndContentOfFiles: (selector) => {
+		return createSelector([selector], (selected) => {
+			const keys = Object.keys(selected)
+			return keys.map((key) => {
+				return {
+					src: key,
+					content: selected[key]
+				}
+			})
+		})
+	}
+}

package/index.js

@@ -0,0 +1,322 @@
+// funkophile/index.js
+
+const chokidar = require('chokidar');
+const createSelector = require('reselect').createSelector;
+const createStore = require('redux').createStore;
+const fse = require("fs-extra")
+const glob = require("glob-promise");
+const path = require("path")
+const Promise = require("bluebird")
+
+Promise.config({
+	cancellation: true
+});
+
+const funkophileConfig = require(process.argv[2])
+const mode = process.argv[3]
+const keyToWatch = process.argv[4]
+
+const INITIALIZE = 'INITIALIZE';
+const UPSERT = 'UPSERT';
+const REMOVE = 'REMOVE';
+
+const previousState = {}
+let outputPromise = Promise.resolve();
+
+const logger = {
+	watchError: (path) => console.log("\u001b[7m ! \u001b[0m" + path),
+	watchReady: (path) => console.log("\u001b[7m\u001b[36m  <  \u001b[0m" + path),
+	watchAdd: (path) => console.log("\u001b[7m\u001b[34m  +  \u001b[0m./" + path),
+	watchChange: (path) => console.log("\u001b[7m\u001b[35m  *  \u001b[0m" + path),
+	watchUnlink: (path) => console.log("\u001b[7m\u001b[31m  -  \u001b[0m./" + path),
+
+	stateChange: () => console.log("\u001b[7m\u001b[31m --- Redux state changed --- \u001b[0m"),
+
+	cleaningEmptyfolder: (path) => console.log("\u001b[31m\u001b[7m XXX! \u001b[0m" + path),
+
+	readingFile: (path) => console.log("\u001b[31m <-- \u001b[0m" + path),
+	removedFile: (path) => console.log("\u001b[31m\u001b[7m ??? \u001b[0m./" + path),
+
+	writingString: (path) => console.log("\u001b[32m --> \u001b[0m" + path),
+	writingFunction: (path) => console.log("\u001b[33m ... \u001b[0m" + path),
+	writingPromise: (path) => console.log("\u001b[33m ... \u001b[0m" + path),
+	writingError: (path, message) => console.log("\u001b[31m !!! \u001b[0m" + path + " " + message),
+
+	waiting: () => console.log("\u001b[7m Funkophile is done for now but waiting on changes...\u001b[0m "),
+	done: () => console.log("\u001b[7m Funkophile is done!\u001b[0m ")
+
+}
+
+function cleanEmptyFoldersRecursively(folder) {
+	var isDir = fs.statSync(folder).isDirectory();
+	if (!isDir) {
+		return;
+	}
+	var files = fs.readdirSync(folder);
+	if (files.length > 0) {
+		files.forEach(function(file) {
+			var fullPath = path.join(folder, file);
+		});
+
+		// re-evaluate files; after deleting subfolder
+		// we may have parent folder empty now
+		files = fs.readdirSync(folder);
+	}
+
+	if (files.length == 0) {
+		logger.cleaningEmptyfolder(folder)
+
+		fs.rmdirSync(folder);
+		return;
+	}
+}
+
+const dispatchUpsert = (store, key, file, encodings) => {
+	logger.readingFile(file)
+	store.dispatch({
+		type: UPSERT,
+		payload: {
+			key: key,
+			src: file,
+			contents: fse.readFileSync(file, Object.keys(encodings).find((e) => encodings[e].includes(file.split('.')[2])))
+		}
+	});
+
+	// const filetype = file.split('.')[2]
+	// const encoding = Object.keys(encodings).find((e) => encodings[e].includes(filetype))
+	// const relativeFilePath = './' + file;
+	// console.log("\u001b[31m <-- \u001b[0m" + file)
+	// fse.readFile(file, encoding).then((contents) => {
+	//   store.dispatch({
+	//     type: UPSERT,
+	//     payload: {
+	//       key: key,
+	//       src: file,
+	//       contents: contents
+	//     }
+	//   });
+	// });
+
+
+};
+
+function omit(key, obj) {
+	const {
+		[key]: omitted, ...rest
+	} = obj;
+	return rest;
+}
+
+const store = createStore((state = {
+	initialLoad: true,
+	...funkophileConfig.initialState,
+	timestamp: Date.now()
+}, action) => {
+	// console.log("\u001b[7m\u001b[35m ||| Redux recieved action \u001b[0m", action.type)
+	if (!action.type.includes('@@redux')) {
+
+		if (action.type === INITIALIZE) {
+			return {
+				...state,
+				initialLoad: false,
+				timestamp: Date.now()
+			}
+		} else if (action.type === UPSERT) {
+			return {
+				...state,
+				[action.payload.key]: {
+					...state[action.payload.key],
+					...{
+						[action.payload.src]: action.payload.contents
+					}
+				},
+				timestamp: Date.now()
+			}
+		} else if (action.type === REMOVE) {
+			return {
+				...state,
+				[action.payload.key]: omit(action.payload.file, state[action.payload.key]),
+				timestamp: Date.now()
+			}
+		} else {
+			console.error("Redux was asked to handle an unknown action type: " + action.type)
+			process.exit(-1)
+		}
+		return state
+	}
+})
+
+const finalSelector = funkophileConfig.outputs(Object.keys(funkophileConfig.inputs).reduce((mm, inputKey) => {
+	return {
+		...mm,
+		[inputKey]: createSelector([(x) => x], (root) => root[inputKey])
+	}
+}, {}))
+
+
+// Wait for all the file watchers to check in
+Promise.all(
+	Object.keys(funkophileConfig.inputs)
+	// ['FUNKYBUNDLE']
+.map((inputRuleKey) => {
+	const path = `./${funkophileConfig.options.inFolder}/${funkophileConfig.inputs[inputRuleKey] || ''}`
+	return new Promise((fulfill, reject) => {
+		if (mode === "build") {
+			glob(path, {}).then((files) => {
+				files.forEach((file) => {
+					dispatchUpsert(store, inputRuleKey, file, funkophileConfig.encodings);
+				})
+			}).then(() => {
+				fulfill()
+			})
+		} else if (mode === "watch") {
+
+			chokidar.watch(path, {})
+				.on('error', error => {
+					logger.watchError(path)
+				})
+				.on('ready', () => {
+					logger.watchReady(path)
+					fulfill()
+				})
+				.on('add', path => {
+					logger.watchAdd(path)
+					dispatchUpsert(store, inputRuleKey, './' + path, funkophileConfig.encodings);
+				})
+				.on('change', path => {
+					logger.watchChange(path)
+					dispatchUpsert(store, inputRuleKey, './' + path, funkophileConfig.encodings);
+				})
+				.on('unlink', path => {
+					logger.watchUnlink(path)
+					store.dispatch({
+							type: REMOVE,
+							payload: {
+								key: inputRuleKey,
+								file: './' + path
+							}
+						})
+				})
+        .on('unlinkDir', path => {
+          logger.watchUnlink(path)
+        })
+        // .on('raw', (event, path, details) => { // internal
+        //   log('Raw event info:', event, path, details);
+        // })
+
+		} else {
+			console.error(`The 3rd argument should be 'watch' or 'build', not "${mode}"`)
+			process.exit(-1)
+		}
+
+	});
+})).then(function() {
+
+	// listen for changes to the store
+	store.subscribe(() => {
+		logger.stateChange()
+		const outputs = finalSelector(store.getState())
+
+		if (outputPromise.isPending()) {
+			console.log('cancelling previous write!')
+			outputPromise.cancel()
+		}
+
+		outputPromise = Promise.all(
+			Array.from(new Set(Object.keys(previousState).concat(Object.keys(outputs))))
+			.map((key) => {
+
+				return new Promise((fulfill, reject) => {
+					if (!outputs[key]) {
+
+						const file = funkophileConfig.options.outFolder + "/" + key
+						logger.removedFile(file)
+
+						try {
+							fse.unlinkSync('./' + file)
+							cleanEmptyFoldersRecursively('./' + file.substring(0, file.lastIndexOf("/")))
+						} catch (ex) {
+							// console.error('inner', ex.message);
+							// throw ex;
+						} finally {
+							// console.log('finally');
+							return;
+						}
+						delete previousState[key]
+						fulfill()
+					} else {
+						if (outputs[key] !== previousState[key]) {
+							previousState[key] = outputs[key]
+
+							const relativeFilePath = './' + funkophileConfig.options.outFolder + "/" + key;
+							const contents = outputs[key];
+
+							if (typeof contents === "function") {
+								logger.writingFunction(relativeFilePath)
+								contents((err, res) => {
+									fse.outputFile(relativeFilePath, res, fulfill);
+									logger.writingString(relativeFilePath);
+								})
+
+							} else if (typeof contents === 'string') {
+								fse.outputFile(relativeFilePath, contents, fulfill);
+								logger.writingString(relativeFilePath);
+
+							} else if (Buffer.isBuffer(contents)) {
+								fse.outputFile(relativeFilePath, contents, fulfill);
+								logger.writingString(relativeFilePath);
+
+							} else if (Array.isArray(contents)) {
+								fse.outputFile(relativeFilePath, JSON.stringify(contents), fulfill);
+								logger.writingString(relativeFilePath);
+
+							} else if (typeof contents.then === 'function') {
+								logger.writingPromise(relativeFilePath)
+								Promise.resolve(contents).then(function(value) {
+
+									if (value instanceof Error) {
+										logger.writingError(relativeFilePath, value.message)
+									} else {
+										fse.outputFile(relativeFilePath, value, fulfill);
+										logger.writingString(relativeFilePath);
+									}
+
+								}, function(value) {
+									// not called
+								});
+
+							} else {
+								console.log("I don't recognize what this is but I will try to write it to a file: " + relativeFilePath, contents)
+								fse.outputFile(relativeFilePath, contents, callback);
+								logger.writingString(relativeFilePath);
+							}
+						} else {
+							fulfill()
+						}
+					}
+				});
+
+			})
+		).then(() => {
+			cleanEmptyFoldersRecursively(funkophileConfig.options.outFolder);
+
+			if (mode === "build") {
+				logger.done()
+			} else if (mode === "watch") {
+				logger.waiting()
+			} else {
+				console.error(`The 3rd argument should be 'watch' or 'build', not "${mode}"`)
+				process.exit(-1)
+			}
+
+		})
+	})
+
+	// lastly, turn the store `on`.
+	// This is to prevent unecessary recomputations when initialy adding files to redux
+	store.dispatch({
+		type: INITIALIZE,
+		payload: true
+	});
+
+})

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "funkophile",
+  "version": "0.0.1",
+  "main": "index.js",
+  "repository": "git@github.com:adamwong246/funkophile.git",
+  "author": "adam wong <adamwong246@gmail.com>",
+  "license": "MIT"
+}