Add basic functionality

Author: kepikoi

.gitignore

@@ -0,0 +1,4 @@
+.idea/
+node_modules/
+test.lua
+test.p8

8pack.js

@@ -0,0 +1,67 @@
+const assert = require('assert'),
+    argv = require('minimist')(process.argv.slice(2)),
+    fs = require('fs'),
+    path = require('path'),
+    {VERSIONS, getVersion} = require('./bin/versions'),
+    removeFileExt = require('./bin/helpers.js'),
+    writeOutput = (path, src) => {
+        fs.writeFileSync(path, src);
+        console.log('writing ' + path);
+    }
+;
+
+if (!argv._.length || argv.h || argv.help) {
+    //show man page
+    console.log(require('./bin/help'));
+    process.exit(0)
+}
+
+assert(argv._.length <= 2, 'too many arguments');
+
+const input = path.resolve(argv._[0]);  //use input path from arguments
+assert.ok(input, 'missing mandatory argument "input"'); //throw when missing input
+assert.doesNotThrow(() => fs.existsSync(input), `couldn't locate input file under ${input}`);
+
+const output = argv._[1]; //use output from arguments
+if (output) {
+    assert.doesNotThrow(() => fs.existsSync(output), `couldn't locate output file under ${output}`);
+}
+
+const watch = argv.w || argv.watch;
+const template = argv.t || argv.template;
+
+//read from input path
+const fileInputPath = path.resolve(input);
+console.log('reading ' + fileInputPath);
+
+//inject input to inject path
+const fileInjectPath = !!output ? path.resolve(output): getVersion(template); //use specified file from output argument or template
+
+//output the result to output path
+const fileOutputPath = output ? path.resolve(output) : fileInputPath + '.p8'; //create a new file when not specified the output
+console.log(`using ${fileOutputPath} as output`);
+
+
+const luaSource = fs.readFileSync(fileInputPath, 'utf8'); //contents of input file
+const picoSource = fs.readFileSync(fileInjectPath, 'utf8'); //contents of output file
+
+const src = [
+    picoSource.slice(0, picoSource.indexOf('__lua__') + 7),
+    luaSource,
+    picoSource.slice(picoSource.indexOf('__gfx__')),
+].join('\n');
+
+if (watch) {
+    console.log('watching for file changes on ' + fileInputPath);
+    fs.watch(fileInputPath, {encoding: 'buffer'}, (eventType, filename) => {
+        if (filename && eventType === 'change') {
+            console.log("changes detected on " + filename.toString())
+            writeOutput(fileOutputPath, src);
+        }
+    });
+}
+else {
+    writeOutput(fileOutputPath, src);
+    console.log('done');
+    process.exit(0)
+}

bin/help.js

@@ -0,0 +1,36 @@
+const chalk = require('chalk');
+const {VERSIONS} = require('./versions');
+
+const help = () =>
+`
+${chalk.bold('Summary')}: Utility that injects Lua source into a PICO-8 project. 
+May also watch for file changes and create projects from scratch.
+
+${chalk.bold('Usage')}: node 8pack.js [input] [output] [parameters]
+
+${chalk.bold('Parameters')}:
+
+${chalk.blue('-t, --template')}     use pico8 template file as output.
+${chalk.blue('-w, --watch')}        watch input for changes
+${chalk.blue('-h, --help ')}        show this page
+ 
+${chalk.bold('Template Versions')}:
+ 
+ ${Object.entries(VERSIONS).reduce(([pk,pv],[nk,nv]) => `* ${pk} => ${pv}\n * ${nk} => ${nv}`)} 
+
+${chalk.bold('Examples')}:
+
+node 8pack foo.lua
+create foo.p8 from foo.lua using newest PICO-8 template
+
+node 8pack foo.lua bar.p8  
+inject foo.lua source into bar.p8. May overwrite bar.p8 if already exists.
+
+node 8pack /somepath/foo.lua -w  
+watch foo.lua for changes and write to /somepath/foo.bar
+
+node 8pack foo.lua bar.p8 -v
+create bar.p8 from foo.lua source using newest PICO-8 template and write to bar.p8
+`;
+
+module.exports = help();

bin/helpers.js

@@ -0,0 +1,9 @@
+/**
+ * removes last suffix after dot
+ * @param {String} name - filename
+ */
+const removeFileExt = name => name.split('.').filter((f, i, a) => i !== a.length - 1).join('.');
+
+module.exports = {
+    removeFileExt
+};

bin/versions.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+const VERSIONS = {
+    NEWEST: '0.1.10c.p8',
+    '0.1.10c.p8': '0.1.10c.p8'
+};
+
+
+module.exports = {
+    VERSIONS,
+    /**
+     * get filepath pico8 template for version name
+     * @param {String|Boolean} version - pico8 project template version. Provide "true" for newest template.
+     * @return {String} path - of the template file
+     */
+    getVersion: version => {
+        const _version =
+            typeof version === 'boolean' ?
+                VERSIONS.NEWEST :
+                version === undefined ?
+                    VERSIONS.NEWEST :
+                    version; //use newest version if  the template argument is supplied without value
+        assert(Object.keys(VERSIONS).find(v => v === _version), `version ${_version} does not exist`);
+        const filePath = path.resolve('./templates', _version);
+        assert.doesNotThrow(() => fs.existsSync(filePath), `couldn't locate template for version ${_version} allthough it should exist`);
+        return filePath;
+    }
+};

package-lock.json

@@ -0,0 +1,20 @@
+{
+  "name": "pico8-packer",
+  "version": "0.0.0",
+  "description": "",
+  "main": "8pack.js",
+  "start": "8pack.js",
+  "man": "./src/8pack.man",
+  "scripts": {
+    "test": "./node_modules/.bin/jasmine-node spec"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^2.0.1",
+    "minimist": "^1.2.0"
+  },
+  "devDependencies": {
+    "jasmine-node": "^1.14.5"
+  }
+}

package.json

@@ -0,0 +1,16 @@
+describe('CLI Tests',()=>{
+    it('should show the man page on no arguments',()=>{
+
+    });
+    it('should show the man page on -h argument',()=>{
+
+    });
+    it('compile using the -i argument',()=>{
+
+    });
+});
+
+async function spawnWithArgs(){
+
+
+};