Merge pull request #11 from thetnaingtn/support-npm

Release as npm package

Author: thetnaingtn

.gitignore

@@ -1,5 +1,8 @@
 # Mac
 .DS_Store
 
-#goreleaser
+# node
+node_modules
+
+# goreleaser
 dist/

.goreleaser.yml

@@ -1,5 +1,6 @@
 builds:
   - main: ./cmd/forky
+    binary: forky
     goos:
       - darwin
       - linux

package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "forkyy",
+  "version": "0.5.2",
+  "description": "Synchronize your forks with ease",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "node postinstall.js install",
+    "preuninstall": "node postinstall.js uninstall"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thetnaingtn/forky.git"
+  },
+  "keywords": [],
+  "author": "thetnaingtn",
+  "license": "ISC",
+  "goBinary":{
+    "name":"forky",
+    "path":"./bin"
+  },
+  "files": [
+    "dist",
+    "postinstall.js"
+  ],
+  "bugs": {
+    "url": "https://github.com/thetnaingtn/forky/issues"
+  },
+  "homepage": "https://github.com/thetnaingtn/forky#readme",
+  "dependencies": {
+    "mkdirp": "^1.0.4"
+  }
+}

package.json

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+"use strict";
+// Thanks to author of https://github.com/sanathkr/go-npm, we were able to modify his code to work with private packages
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var path = require('path'),
+    mkdirp = require('mkdirp'),
+    fs = require('fs');
+
+// Mapping from Node's `process.arch` to Golang's `$GOARCH`
+var ARCH_MAPPING = {
+    "ia32": "386",
+    "x64": "amd64",
+    "arm": "arm",
+    "arm64":"arm64"
+};
+
+// Mapping between Node's `process.platform` to Golang's
+var PLATFORM_MAPPING = {
+    "darwin": "darwin",
+    "linux": "linux",
+    "win32": "windows",
+    "freebsd": "freebsd"
+};
+
+async function getInstallationPath() {
+
+    // `npm bin` will output the path where binary files should be installed
+
+    const value = await execShellCommand("npm bin -g");
+
+
+        var dir = null;
+        if (!value || value.length === 0) {
+
+            // We couldn't infer path from `npm bin`. Let's try to get it from
+            // Environment variables set by NPM when it runs.
+            // npm_config_prefix points to NPM's installation directory where `bin` folder is available
+            // Ex: /Users/foo/.nvm/versions/node/v4.3.0
+            var env = process.env;
+            if (env && env.npm_config_prefix) {
+                dir = path.join(env.npm_config_prefix, "bin");
+            }
+        } else {
+            dir = value.trim();
+        }
+
+        await mkdirp(dir);
+        return dir;
+}
+
+async function verifyAndPlaceBinary(binName, binPath, callback) {
+    if (!fs.existsSync(path.join(binPath, binName))) return callback('Downloaded binary does not contain the binary specified in configuration - ' + binName);
+
+    // Get installation path for executables under node
+    const installationPath=  await getInstallationPath();
+    // Copy the executable to the path
+    fs.rename(path.join(binPath, binName), path.join(installationPath, binName),(err)=>{
+        if(!err){
+            console.info("Installed cli successfully");
+            callback(null);
+        }else{
+            callback(err);
+        }
+    });
+}
+
+function validateConfiguration(packageJson) {
+
+    if (!packageJson.version) {
+        return "'version' property must be specified";
+    }
+
+    if (!packageJson.goBinary || _typeof(packageJson.goBinary) !== "object") {
+        return "'goBinary' property must be defined and be an object";
+    }
+
+    if (!packageJson.goBinary.name) {
+        return "'name' property is necessary";
+    }
+
+    if (!packageJson.goBinary.path) {
+        return "'path' property is necessary";
+    }
+}
+
+function parsePackageJson() {
+    if (!(process.arch in ARCH_MAPPING)) {
+        console.error("Installation is not supported for this architecture: " + process.arch);
+        return;
+    }
+
+    if (!(process.platform in PLATFORM_MAPPING)) {
+        console.error("Installation is not supported for this platform: " + process.platform);
+        return;
+    }
+
+    var packageJsonPath = path.join(".", "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error("Unable to find package.json. " + "Please run this script at root of the package you want to be installed");
+        return;
+    }
+
+    var packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+    var error = validateConfiguration(packageJson);
+    if (error && error.length > 0) {
+        console.error("Invalid package.json: " + error);
+        return;
+    }
+
+    // We have validated the config. It exists in all its glory
+    var binName = packageJson.goBinary.name;
+    var binPath = packageJson.goBinary.path;
+    var version = packageJson.version;
+    if (version[0] === 'v') version = version.substr(1); // strip the 'v' if necessary v0.0.1 => 0.0.1
+
+    // Binary name on Windows has .exe suffix
+    if (process.platform === "win32") {
+        binName += ".exe";
+    }
+
+
+    return {
+        binName: binName,
+        binPath: binPath,
+        version: version
+    };
+}
+
+/**
+ * Reads the configuration from application's package.json,
+ * validates properties, copied the binary from the package and stores at
+ * ./bin in the package's root. NPM already has support to install binary files
+ * specific locations when invoked with "npm install -g"
+ *
+ *  See: https://docs.npmjs.com/files/package.json#bin
+ */
+var INVALID_INPUT = "Invalid inputs";
+async function install(callback) {
+
+    var opts = parsePackageJson();
+    if (!opts) return callback(INVALID_INPUT);
+    mkdirp.sync(opts.binPath);
+    console.info(`Copying the relevant binary for your platform ${process.platform}`);
+    const src= `./dist/forky_${process.platform}_${ARCH_MAPPING[process.arch]}${ARCH_MAPPING[process.arch] === 'amd64' ?  '_v1' : ''}/${opts.binName}`;
+    await execShellCommand(`cp ${src} ${opts.binPath}/${opts.binName}`);
+    await verifyAndPlaceBinary(opts.binName, opts.binPath, callback);
+}
+
+async function uninstall(callback) {
+    var opts = parsePackageJson();
+        try {
+            const installationPath = await getInstallationPath();
+            fs.unlink(path.join(installationPath, opts.binName),(err)=>{
+                if(err){
+                    return callback(err);
+                }
+            });
+        } catch (ex) {
+            // Ignore errors when deleting the file.
+        }
+    console.info("Uninstalled cli successfully");
+    return callback(null);
+}
+
+// Parse command line arguments and call the right method
+var actions = {
+    "install": install,
+    "uninstall": uninstall
+};
+/**
+ * Executes a shell command and return it as a Promise.
+ * @param cmd {string}
+ * @return {Promise<string>}
+ */
+function execShellCommand(cmd) {
+    const exec = require('child_process').exec;
+    return new Promise((resolve, reject) => {
+        exec(cmd, (error, stdout, stderr) => {
+            if (error) {
+                console.warn(error);
+            }
+            resolve(stdout? stdout : stderr);
+        });
+    });
+}
+
+var argv = process.argv;
+if (argv && argv.length > 2) {
+    var cmd = process.argv[2];
+    if (!actions[cmd]) {
+        console.log("Invalid command. `install` and `uninstall` are the only supported commands");
+        process.exit(1);
+    }
+
+    actions[cmd](function (err) {
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        } else {
+            process.exit(0);
+        }
+    });
+}