charged

#!/usr/bin/env node

/**
 * Charged (https://github.com/chjj/charged)
 * Copyright (c) 2012, Christopher Jeffrey (MIT License)
 * Usage: $ charged my-site
 *        $ charged my-site my-key -c 'ls /stats'
 *        $ charged my-site my-key ls /stats
 *        $ echo 'ls /stats' | charged my-site my-key
 *        $ echo 'ls /stats' | charged --config ~/charged.json
 *        $ charged --cfg ./config.json ls /customers/foo/subscriptions
 */

/**
 * Modules
 */

var util = require('util')
  , readline = require('readline')
  , resolve = require('path').resolve
  , spawn = require('child_process').spawn
  , fs = require('fs')
  , isatty = require('tty').isatty
  , charged = require('../');

/**
 * Shell
 */

var shell = charged.shell = exports;

/**
 * Builtins
 */

shell.cwd = '/';

shell.toplevel = [
  './',
  'coupons/',
  'components/',
  'customers/',
  'events/',
  'products/',
  'product_families/',
  'stats/',
  'statements/',
  'subscriptions/',
  'transactions/',
  'webhooks/'
];

shell.reduced = [
  'id',
  'reference',
  'handle',
  'name'
];

shell.builtin = {
  'cd': function(path, callback) {
    shell.cwd = resolve('/', shell.cwd, path);
    return callback();
  },
  'pwd': function(callback) {
    return callback(null, shell.cwd);
  },
  'list': function(path, callback) {
    if (!callback) {
      callback = path;
      path = null;
    }

    path = resolve('/', shell.cwd, path);

    shell._collectGarbage();

    if (shell.cache[path]) {
      return callback(null, shell.cache[path]);
    }

    return this.cat(path, function(err, results) {
      if (err) return callback(err);

      if (!Array.isArray(results)) {
        return callback(null, results);
      }

      var out = []
        , keys
        , type;

      if (results.length) {
        keys = Object.keys(results[0]);
        if (keys.length === 1) {
          type = keys[0];
        }
      }

      if (type) {
        results = results.map(function(obj) {
          return obj[type];
        }).filter(Boolean);
      }

      shell.reduced.forEach(function(prop) {
        results.forEach(function(obj) {
          if (obj[prop] && !~out.indexOf(obj[prop])) {
            out.push(obj[prop]);
          }
        });
      });

      out = out.join('\n');

      shell._collectGarbage();
      shell.cache[path] = out;

      return callback(null, out);
    });
  },
  'ls': function(path, callback) {
    return this.list.apply(this, arguments);
  },
  'll': function(path, callback) {
    return this.cat.apply(this, arguments);
  },
  'cat': function(path, callback) {
    if (!callback) {
      callback = path;
      path = null;
    }

    if (!path) {
      path = '';
    }

    if (resolve('/', shell.cwd, path) === '/') {
      return callback(null, shell.toplevel.join('\n'));
    }

    return shell.request('get', path, callback);
  },
  'less': function(path, callback) {
    if (!callback) {
      callback = path;
      path = null;
    }

    return shell.spawn(path, 'less', ['-R'], callback);
  },
  'rm': function(path, callback) {
    if (!callback) {
      return callback(new Error('Argument required.'));
    }

    return shell.request('delete', path, callback);
  },
  'mv': function(path, options, callback) {
    if (!callback) {
      return callback(new Error('Argument required.'));
    }

    if (typeof path === 'object') {
      var opt = path;
      path = options;
      options = opt;
    }

    return shell.request('put', path, options, callback);
  },
  'mk': function(path, options, callback) {
    if (!callback) {
      return callback(new Error('Argument required.'));
    }

    return shell.request('post', path, options, callback);
  },
  'echo': function() {
    var args = Array.prototype.slice.call(arguments)
      , callback = args.pop()
      , options
      , path
      , op;

    op = args[args.length-2];
    if (op === '>' || op === '>>') {
      path = args.pop();
      args.pop();
      options = args.pop();
      return op === '>'
        ? this.mk(path, options, callback)
        : this.mv(path, options, callback);
    }

    print(args.join(' '));

    return callback();
  },
  'setopt': function(key, value, callback) {
    if (!key || !value || !callback) {
      return callback(new Error('Argument required.'));
    }

    shell.chargify[toCamel(key)] = value;

    return callback();
  },
  'getopt': function(key, callback) {
    return callback(null, shell.chargify[toCamel(key)]);
  },
  'help': function(cmd, callback) {
    if (!callback) {
      callback = cmd;
      cmd = null;
    }

    if (cmd) {
      if (cmd === 'all') {
        Object.keys(shell.info).forEach(function(cmd) {
          shell.builtin.help(cmd, function() {});
          error('');
        });
        return callback();
      }
      if (!shell.info[cmd]) {
        error('No information for command: `' + cmd + '`.');
        return callback();
      }
      error(cmd);
      error(shell.info[cmd]);
      return callback();
    }

    shell.help();

    error('');

    var out = []
      , i = 0;

    shell.commands.forEach(function(cmd, j) {
      if (i + cmd.length > 80) {
        i = 0;
        out.push('\n');
      } else if (j) {
        i++;
        out.push(' ');
      }
      i += cmd.length;
      out.push(cmd);
    });

    error(out.join(''));

    return callback();
  },
  'clear': function(callback) {
    var ps = spawn('/bin/sh',
      ['-c', 'tput clear && tput cud $(tput lines)'],
      { customFds: [0, 1, 2] });

    ps.on('exit', function() {
      return callback();
    });
  },
  'exit': function(callback) {
    return process.exit(0);
  }
};

Object.keys(shell.builtin).forEach(function(name) {
  charged.prototype[name] = shell.builtin[name];
});

/**
 * Request
 */

shell.request = function(method, path, options, callback) {
  var parts;

  if (!callback) {
    callback = options;
    options = null;
  }

  path = resolve('/', shell.cwd, path);
  path = path.replace(/^\.?\/+|\/+$/g, '');

  parts = path.split('/');

  if (options) {
    var format = charged.resources.indexOf(parts[0].slice(0, -1));
    if (~format || parts[0] === 'product_families') {
      format = format !== -1
        ? charged.resources[format]
        : 'product_family';
    }
  }

  if (parts[0] === 'customers') {
    if (parts[1] && !/^\d+$/.test(parts[1])) {
      if (method !== 'get' || parts[2]) {
        // We need this because /customers/lookup/subscriptions?reference=foo
        // doesn't work.
        return shell.chargify.getCustomerByRef(parts[1], function(err, customer) {
          if (err) return callback(err);
          parts[1] = customer.id + '';
          return request();
        });
      }
      parts[1] = 'lookup?reference=' + parts[1];
    }
  } else if (parts[0] === 'products') {
    if (parts[1] && !/^\d+$/.test(parts[1])) {
      if (parts[2]) {
        // NOTE: This may not be necessary.
        return shell.chargify.getProductByHandle(parts[1], function(err, product) {
          if (err) return callback(err);
          parts[1] = product.id + '';
          return request();
        });
      }
      parts.splice(1, 0, 'handle');
    }
  } else if (parts[0] === 'product_families') {
    if (parts[1] && !/^\d+$/.test(parts[1])) {
      return shell.chargify.getFamilyByHandle(parts[1], function(err, family) {
        if (err) return callback(err);
        parts[1] = family.id + '';
        return request();
      });
    }
  } else if (parts[0] === 'coupons') {
    if (parts[1] && !/^\d+$/.test(parts[1])) {
      return shell.chargify.getCouponByCode(parts[1], function(err, coupon) {
        if (err) return callback(err);
        parts[1] = coupon.id + '';
        return request();
      });
    }
  } else if (parts[0] === 'webhooks') {
    if (method === 'get') {
      if (parts[1]) {
        if (/^\d+$/.test(parts[1]) && !parts[2]) {
          return shell.chargify.getWebhook(parts[1], callback);
        }
      }
      // } else {
      //   return shell.chargify.getWebhooks({ per_page: 200 }, callback);
      // }
    }
  } else if (parts[0] === 'components') {
    // Add a components directory.
    if (method === 'get') {
      if (parts[1]) {
        return !/^\d+$/.test(parts[1])
          ? shell.chargify.getComponentByName(parts[1], callback)
          : shell.chargify.getComponent(parts[1], callback);
      } else {
        return shell.chargify.getComponents(callback);
      }
    }
  }

  function request() {
    path = '/' + parts.join('/');
    if (shell.options.debug2) {
      print([method, path, options, callback, format]);
    }
    return options
      ? shell.chargify[method](path, callback, format)
      : shell.chargify[method](path, options, callback, format);
  }

  return request();
};

/**
 * Execute Process
 */

shell.spawn = function(path, name, args, callback) {
  return shell.chargify.cat(path, function(err, results) {
    if (err) results = err.message;

    results = inspect(results);

    var tmp = process.env.HOME
      + '/.charged-tmp~'
      + Date.now();

    fs.writeFile(tmp, results, function(err) {
      if (err) return callback(err);

      process.stdin.pause();

      var ps = spawn(name, args.concat(tmp), {
        cwd: process.cwd(),
        env: process.env,
        setsid: false,
        customFds: [0, 1, 2]
      });

      ps.on('exit', function() {
        process.stdin.resume();
        fs.unlink(tmp, function() {
          return callback();
        });
      });
    });
  });
};

/**
 * Commands
 */

shell.info = {
  'help':   ['Syntax: help [command].',
             'Lookup info about a command.'].join('\n'),
  'cd':     ['Syntax: cd [target].',
             'Change working directory.'].join('\n'),
  'pwd':    ['Syntax: pwd.',
             'Print working directory.'].join('\n'),
  'ls':     ['Syntax: ls [target].',
             'List contents of resource.'].join('\n'),
  'cat':    ['Syntax: cat [target].',
             'Show contents of resource.'].join('\n'),
  'rm':     ['Syntax: rm [target].',
             'Remove resource.'].join('\n'),
  'mv':     ['Syntax: mv [data] [target].',
             'Update target with data.'].join('\n'),
  'mk':     ['Syntax: mk [target] [data].',
             'Create target with data.'].join('\n'),
  'clear':  ['Syntax: clear.',
             'Clear terminal screen.'].join('\n'),
  'getopt': ['Syntax: getopt [key].',
             'Show option.'].join('\n'),
  'setopt': ['Syntax: setopt [key] [value].',
             'Set option to value.'].join('\n'),
  'exit':   ['Syntax: exit.',
             'Exit.'].join('\n')
};

shell.ignore = [
  'request',
  'get',
  'post',
  'put',
  'delete'
];

shell.returned = [
  'hostedPage',
  'signupPage'
];

shell.commands = Object.keys(charged.prototype).filter(function(name) {
  return name[0] !== '_'
      && typeof charged.prototype[name] === 'function'
      && !~shell.ignore.indexOf(name);
}).map(toDash);

/**
 * Execute Command
 */

shell.exec = function(args, callback) {
  var args = args.trim().split(/\s+/)
    , cmd = args.shift();

  if (!cmd) {
    return callback();
  }

  if (!~shell.commands.indexOf(cmd)) {
    error('No such command: `' + cmd + '`. Type `help` for commands.');
    return callback();
  }

  cmd = toCamel(cmd);

  args.forEach(function(arg, i) {
    if (!arg) return;

    try {
      if (arg[0] === '{' || arg[0] === '[') {
        arg = 'return (' + arg + ');';
        arg = new Function('', arg).call(null);
      }
    } catch (e) {
      ;
    }

    args[i] = arg;
  });

  if (shell.options.debug) {
    console.log(cmd, args);
    return callback();
  }

  if (~shell.returned.indexOf(cmd)) {
    try {
      print(shell.chargify[cmd].apply(shell.chargify, args));
    } catch (e) {
      error(e.message);
    }
    return callback();
  }

  args.push(function(err, results) {
    if (err) {
      error(err.message);
      return callback();
    }
    if (results) print(results);
    return callback();
  });

  return shell.chargify[cmd].apply(shell.chargify, args);
};

/**
 * Cache
 */

shell.cache = {};

shell._collectGarbage = function() {
  if (shell._timeout) {
    clearTimeout(shell._timeout);
  }
  shell._timeout = setTimeout(function() {
    shell.cache = {};
  }, 20 * 1000);
};

/**
 * Completions
 */

shell.list = function(path, callback) {
  if (!callback) {
    callback = path;
    path = null;
  }

  return shell.chargify.list(path, function(err, results) {
    if (err) return callback(err);

    if (typeof results !== 'string') {
      results = '';
    }

    results = results.trim().split(/\n+/);

    return callback(null, results);
  });
};

shell.complete = function(line, callback) {
  var parts = line.replace(/^\s+/, '').split(/\s+/)
    , cmd = parts[0]
    , out = [];

  if (parts.length === 1) {
    var i = shell.commands.length;

    while (i--) {
      if (shell.commands[i].indexOf(cmd) === 0) {
        if (cmd !== shell.commands[i]) {
          out.push(shell.commands[i]);
        }
      }
    }
  } else if (parts.length === 2) {
    if (shell.builtin[cmd]) {
      var i = shell.toplevel.length
        , start = /^(\.?\/+|)/.exec(parts[1])[1]
        , path = parts[1].substring(start.length)
        , last;

      if (resolve('/', shell.cwd, start) === '/' && !~path.indexOf('/')) {
        while (i--) {
          if (shell.toplevel[i].indexOf(path) === 0) {
            if (path !== shell.toplevel[i]) {
              out.push(cmd + ' ' + start + shell.toplevel[i]);
            }
          }
        }
      } else {
        path = path.split('/');
        last = path.pop();
        path = start + path.join('/');
        if (path) path += '/';

        return shell.list(path, function(err, results) {
          if (err) return done();

          i = results.length;
          while (i--) {
            if (results[i].indexOf(last) === 0) {
              out.push(cmd + ' ' + path + results[i] + '/');
            }
          }

          return done();
        });
      }
    }
  }

  function done() {
    return callback(null, [out, line]);
  }

  return done();
};

/**
 * Help
 */

shell.help = function() {
  error('Charged (https://github.com/chjj/charged)');
  error('Copyright (c) 2012, Christopher Jeffrey (MIT License)');
  error('Usage: $ charged [subdomain] [api-key]\n'
      + '                 [--subdomain subdomain] [--key key]\n'
      + '                 [--site-key key] [--family family]\n'
      + '                 [--config conf] [--debug] [--raw]\n'
      + '                 [--command cmd] [--help]\n'
      + '                 [--opt.foo val] [cmd]');
};

/**
 * Charged
 */

shell.__defineGetter__('chargify', function() {
  if (shell._chargify) return shell._chargify;

  if (!shell.options.subdomain || !shell.options.apiKey) {
    if (isatty(1)) shell.help();
    return process.exit(1);
  }

  shell._chargify = charged(shell.options);

  return shell._chargify;
});

/**
 * Read Command
 */

shell.readCommand = function() {
  function exec(cmd) {
    shell.exec(cmd, function() {
      return process.exit(0);
    });
  }

  if (shell.options.command) {
    return exec(shell.options.command);
  }

  return getStdin(function(err, cmd) {
    return err
      ? process.exit(1)
      : exec(cmd);
  });
};

/**
 * Interactive
 */

shell.interactive = function() {
  shell.rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    completer: shell.complete
  });

  return shell.askSubdomain(function() {
    return shell.askApiKey(function() {
      return shell.prompt();
    });
  });
};

shell.askSubdomain = function(callback) {
  if (shell.options.subdomain) return callback();
  shell.rl.question('Subdomain: ', function(result) {
    shell.options.subdomain = result.trim();
    if (!shell.options.subdomain) {
      return shell.askSubdomain(callback);
    }
    return callback();
  });
};

shell.askApiKey = function(callback) {
  if (shell.options.apiKey) return callback();
  shell.rl.question('API Key: ', function(result) {
    shell.options.apiKey = result.trim();
    if (!shell.options.apiKey) {
      return shell.askApiKey(callback);
    }
    return callback();
  });
};

shell.askSiteKey = function(callback) {
  if (shell.options.siteKey) return callback();
  shell.rl.question('Shared Site Key (optional): ', function(result) {
    shell.options.siteKey = result.trim();
    return callback();
  });
};

shell.askFamily = function(callback) {
  if (shell.options.defaultFamily) return callback();
  shell.rl.question('Default Family (optional): ', function(result) {
    shell.options.defaultFamily = result.trim();
    return callback();
  });
};

shell.prompt = function() {
  var wait;

  shell.rl.on('line', function(line) {
    if (wait) return;
    wait = true;
    shell.exec(line, function() {
      wait = false;
      shell.rl.prompt(true);
    });
  });

  shell.rl.on('close', function() {
    return process.exit(0);
  });

  shell.rl.setPrompt('\x1b[1;32;40m[charged]\x1b[m ', 10);

  shell.rl.prompt(true);
};

/**
 * Options
 */

shell.options = parseArg();

/**
 * Main
 */

shell.start = function() {
  return !isatty(0) || shell.options.command || shell.options.raw
    ? shell.readCommand()
    : shell.interactive();
};

/**
 * Helpers
 */

function merge(i, o) {
  Object.keys(o).forEach(function(key) {
    i[key] = o[key];
  });
  return i;
}

function toCamel(str) {
  return str.replace(/-(\w)/g, function(_, ch) {
    return ch.toUpperCase();
  });
}

function toDash(str) {
  return str.replace(/([a-z])([A-Z])/g, function(_, a, b) {
    return a + '-' + b.toLowerCase();
  });
}

function inspect(obj) {
  if (typeof obj !== 'string') {
    obj = util.inspect(obj, false, 4, true);
  }
  return obj;
}

function print(obj) {
  if (!isatty(1)) {
    return process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
  }
  return process.stdout.write(inspect(obj) + '\n');
}

function error() {
  if (!isatty(2)) return;
  return console.error.apply(console, arguments);
}

function getStdin(callback) {
  var stdin = process.stdin
    , buf = '';

  stdin.setEncoding('utf8');

  stdin.on('data', function(data) {
    buf += data;
  });

  stdin.on('error', callback);

  stdin.on('end', function() {
    callback(null, buf);
  });

  try {
    stdin.resume();
  } catch (e) {
    callback(e);
  }
}

/**
 * Parse Arguments
 */

function parseArg() {
  var argv = process.argv.slice(2)
    , cfg
    , opt = {}
    , arg;

  function getarg() {
    var arg = argv.shift();

    if (arg.indexOf('--') === 0) {
      // e.g. --opt
      arg = arg.split('=');
      if (arg.length > 1) {
        // e.g. --opt=val
        argv.unshift(arg.slice(1).join('='));
      }
      arg = arg[0];
    } else if (arg[0] === '-') {
      if (arg.length > 2) {
        // e.g. -abc
        argv = arg.substring(1).split('').map(function(ch) {
          return '-' + ch;
        }).concat(argv);
        arg = argv.shift();
      } else {
        // e.g. -a
      }
    } else {
      // e.g. foo
    }

    return arg;
  }

  while (argv.length) {
    arg = getarg();
    switch (arg) {
      case '--family':
        opt.defaultFamily = argv.shift();
        break;
      case '--site-key':
        opt.siteKey = argv.shift();
        break;
      case '-k':
      case '--key':
      case '--api-key':
        opt.apiKey = argv.shift();
        break;
      case '-s':
      case '--subdomain':
      case '--site':
        opt.subdomain = argv.shift();
        break;
      case '-c':
      case '--command':
        opt.command = argv.shift();
        break;
      case '--cfg':
      case '--conf':
      case '--config':
        cfg = require(resolve(argv.shift()));
        merge(opt, cfg.chargify || cfg);
        break;
      case '--raw':
        opt.raw = true;
        break;
      case '--debug':
        opt.debug = true;
        break;
      case '--debug2':
        opt.debug2 = true;
        break;
      case '-h':
      case '--help':
        shell.help();
        return process.exit(0);
      default:
        if (arg.indexOf('opt.') === 0) {
          opt[toCamel(arg.substring(4))] = argv.shift();
          break;
        }
        if (!opt.subdomain) {
          opt.subdomain = arg;
        } else if (!opt.apiKey) {
          opt.apiKey = arg;
        } else {
          if (!opt.command) {
            opt.command = arg;
          } else {
            opt.command += ' ' + arg;
          }
        }
        break;
    }
  }

  return opt;
}

/**
 * Start
 */

if (!module.parent) {
  shell.start();
}