ppackage 1.0.3

package/.npmignore

@@ -0,0 +1,7 @@
+/npm-debug.log
+/node_modules
+/coverage
+/test
+/disc
+/.git*
+

package/bin/ddocker

@@ -0,0 +1 @@
+cnyks ddocker --ir://run=$*

package/bin/ddocker.cmd

@@ -0,0 +1 @@
+@cnyks ddocker --ir://run=%*

package/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const fs   = require('fs');
+const semver   = require('semver');
+const path = require('path');
+const {spawn} = require('child_process');
+
+const args = require('nyks/process/parseArgs')();
+const passthru = require('nyks/child_process/passthru');
+const wait = require('nyks/child_process/wait');
+
+const Dockerfile = require('./lib/dockerfile');
+
+
+class ddocker {
+
+  async version(version = false, notag = false, nonpm = false) {
+    let target_version = version || args.args.shift();
+
+    if(!nonpm && fs.existsSync('package.json') && process.env['npm_lifecycle_event'] != "version")
+      throw `Please change version using \`npm version ${target_version}\``;
+
+    let dirty = await wait(spawn('git', ["diff", "--quiet"])).catch(err => true);
+    if(dirty && !notag)
+      throw "Working directory not clean, aborting";
+
+
+    const LABEL_VERSION = "org.opencontainers.image.version";
+    let body = this._read();
+    let current = body.labels[LABEL_VERSION] || "0.0.0";
+
+    if(!semver.valid(target_version))
+      target_version = semver.inc(current, target_version);
+
+
+    if(!target_version)
+      throw `Invalid semver range`;
+
+    body.setLabel(LABEL_VERSION, target_version);
+    fs.writeFileSync('Dockerfile', body.toString());
+
+
+    await passthru('git', ['add', 'Dockerfile']);
+    if(!notag) {
+      await passthru('git', ['commit', '-m', `v${target_version}`, 'Dockerfile']);
+      await passthru('git', ['tag', `v${target_version}`]);
+    }
+    return target_version;
+  }
+
+  _read() {
+    let body = fs.readFileSync('Dockerfile', 'utf8');
+    let foo = Dockerfile.parse(body);
+    return foo;
+  }
+}
+
+
+module.exports = ddocker;
+

package/lib/dockerfile.js

@@ -0,0 +1,166 @@
+"use strict";
+
+const fs   = require('fs');
+const semver   = require('semver');
+const path = require('path');
+
+
+const args = require('nyks/process/parseArgs')();
+const passthru  = require('nyks/child_process/passthru');
+const escapeRegExp = require('mout/string/escapeRegExp');
+const splitArgs = require('nyks/process/splitArgs');
+
+const {tokenize} = require('./util');
+
+
+const INSTRUCTION = /^\s*#\s+(.*?)\s*=(.*)\s*/;
+const COMMENTS    = /^\s*#\s?(.*)/;
+const VERBS       = /^\s*(\w+)\s*(.*)/;
+
+class Dockerfile {
+  static parse(body) {
+    let lines = body.trim().split("\n");
+    
+    let out = new Dockerfile();
+
+    let lookingForDirectives = true;
+
+    var remainder = '';
+    var remainder_raw = '';
+    var lineRaw = "";
+
+    for(let line of lines) {
+      let multiline = new RegExp(`(.*)${escapeRegExp(out.escape)}\s*$`);
+
+      if(lookingForDirectives && INSTRUCTION.test(line)) {
+        let [, instruction, value] = INSTRUCTION.exec(line);
+        if(instruction == "escape")
+          out.escape = value;
+        out.raw.push({
+          instruction, value,
+          toString : function() {
+            return `# ${this.instruction}=${this.value}`;
+          }
+        });
+        continue;
+      }
+
+      lookingForDirectives = false
+
+      if(multiline.test(line)) {
+        let raw = multiline.exec(line);
+        remainder     += raw[1];
+        remainder_raw += raw[0] + "\n";
+        continue;
+      } else {
+        lineRaw =  remainder_raw + line ;
+        line = remainder + line;
+        remainder = "";
+        remainder_raw = "";
+      }
+
+      let bloc = out.feedLine(line, lineRaw);
+    }
+    return out;
+  }
+
+  constructor() {
+    this.escape = "\\";
+    this.raw = [];
+  }
+
+  get labels() {
+    let labels = {};
+    for(let entry of this.raw) {
+      if(entry.VERB == "LABEL")
+        for(let k in entry.labels)
+          Object.defineProperty(labels, k, {enumerable : true, value : entry.labels[k]});
+    }
+
+    Object.seal(labels);
+    return labels;
+  }
+
+
+  feedLine(line, raw = undefined) {
+    if(!raw)
+      raw = line;
+
+    let what = {
+      raw,
+      touched : false,
+
+      toString : function() {
+        return this.raw;
+      }
+    }; 
+
+    if(COMMENTS.test(line)) {
+      let [, value] = COMMENTS.exec(line);
+
+
+      Object.defineProperties(what, {
+        type : {value : "COMMENT"},
+        _comment : {value, writable : true},
+        comment : {
+          get : function() {return this._comment },
+          set : function(value) {
+            this._comment = value;
+            this.raw = `# ${this.comment}`;
+          }
+        }
+      });
+    }
+
+    if(VERBS.test(line)) {
+      let [, verb, payload] = VERBS.exec(line);
+
+      Object.defineProperties(what, {
+        type : {value : "VERB"},
+        VERB : {value : verb},
+        payload : {value : payload},
+      });
+
+      if(verb == "LABEL") {
+        Object.defineProperties(what, {
+          labels : {value : tokenize(payload) },
+          toString : {value : function() {
+            if(!this.touched)
+              return this.raw; //preseve indent
+            let out = `${this.VERB}`;
+            for(let k in this.labels)
+              out += ` ${JSON.stringify(k)}=${JSON.stringify(this.labels[k])}`;
+            return out;
+          }}
+        });
+      }
+    }
+
+
+    this.raw.push(what);
+    return what;
+  }
+
+  setLabel(label, value) {
+    //search for existing lavel
+    let existing = this.raw.find(entry => (entry.VERB == "LABEL") && (label in entry.labels));
+    if(existing) {
+      existing.touched = true;
+      existing.labels[label] = value;
+    } else {
+      this.feedLine(`LABEL ${JSON.stringify(label)}=${JSON.stringify(value)}`);
+    }
+  }
+
+  toString() {
+    let body = "";
+    for(let line of this.raw)
+      body += line.toString() + "\n";
+
+    return body;
+  }
+}
+
+
+module.exports = Dockerfile;
+

package/lib/util.js

@@ -0,0 +1,33 @@
+"use strict";
+
+
+const mask = "(\\s+=)|(=)|([^\\s\\\"'=]+)|\\\"([^\\\"]*)\\\"|'([^']*)'";
+
+const tokenize = function(str) {
+  var r = new RegExp(mask, "g");
+  var step, sep, value, eql;
+  let dict = {};
+  let k;
+
+  while((step = r.exec(str || ""))) {
+    sep   = step[1] !== undefined;
+    value = step[3] || step[4] || step[5] || "";
+    eql = step[2] !== undefined;
+
+    if(sep || eql)
+      continue;
+    if(!k) {
+      k = value;
+    } else {
+      dict[k] = value;
+      k = false;
+    }
+  }
+
+  return dict;
+
+};
+
+
+module.exports = {tokenize};
+

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ppackage",
+  "version": "1.0.3",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "ddocker": "./bin/ddocker"
+  },
+  "dependencies": {
+    "mout": "^1.0.0",
+    "nyks": "^6.1.8",
+    "semver": "^5.3.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}