transformator/lib/transformator.js

event-based server for jade-lang, minify and transformers

// Generated by CoffeeScript 1.9.1
(function() {
  var Sync, apply, cbor, compile, e, host, jade, minify, mod_minify, net, pack, port, server, transformers,
    slice = [].slice;

  apply = function(func) {
    return function() {
      var obj, rest;
      obj = arguments[0], rest = 2 <= arguments.length ? slice.call(arguments, 1) : [];
      return func.apply(obj, rest);
    };
  };

  jade = require('jade');

  net = require('net');

  cbor = require('cbor');

  mod_minify = require('minify');

  Sync = require('sync');

  transformers = require('transformers');

  pack = function(obj) {
    return cbor.Encoder.encode(obj);
  };

  minify = function(ext, input) {
    var fn;
    fn = function(ext, input, cb) {
      var _cb;
      _cb = function(error, data) {
        if (error) {
          throw "minify: " + error;
        }
        return cb(null, data);
      };
      return mod_minify({
        ext: "." + ext,
        data: "" + input
      }, _cb, _cb);
    };
    return fn.sync(null, ext, input);
  };

  transformers['jade'] = {
    outputFormat: 'html',
    sync: true
  };

  transformers['minify_js'] = {
    outputFormat: 'js',
    sync: true
  };

  transformers['minify_css'] = {
    outputFormat: 'css',
    sync: true
  };

  transformers['minify_html'] = {
    outputFormat: 'html',
    sync: true
  };

  compile = function(obj) {
    var a, b, byfmt, data, e, engine, engines, fmt, fn, i, input, len, list, ref, transformer;
    engine = obj[0], input = obj[1], data = obj[2];
    switch ("" + engine) {
      case 'jade':
        try {
          fn = jade.compile("" + input);
        } catch (_error) {
          e = _error;
          throw "jade: " + e;
        }
        return fn(data);
      case 'minify_js':
        return minify('js', input);
      case 'minify_css':
        return minify('css', input);
      case 'minify_html':
        return minify('html', input);
      case 'list':
        byfmt = {};
        for (a in transformers) {
          b = transformers[a];
          if (!b.sync) {
            continue;
          }
          fmt = b.outputFormat;
          if (byfmt[fmt] == null) {
            byfmt[fmt] = [];
          }
          byfmt[fmt].push(a);
        }
        list = [];
        for (fmt in byfmt) {
          engines = byfmt[fmt];
          list.push("[ " + fmt + " ]");
          ref = engines.sort();
          for (i = 0, len = ref.length; i < len; i++) {
            engine = ref[i];
            list.push("\t" + engine);
          }
        }
        return list.join("\n");
      default:
        transformer = transformers[engine];
        if (transformer == null) {
          throw 'unknown engine';
        }
        if (!transformer.sync) {
          throw 'unsupported engine';
        }
        try {
          data = transformer.renderSync("" + input);
        } catch (_error) {
          e = _error;
          throw engine + ": " + e;
        }
        return data;
    }
    return null;
  };

  server = net.createServer(apply(function() {
    var sink;
    this.on('end', function() {});
    sink = new cbor.Decoder();
    sink.on('error', function(err) {
      this.end;
      return console.error(err);
    });
    sink.on('complete', (function(_this) {
      return function(obj) {
        return Sync(function() {
          var answer, buf, e, result;
          answer = {
            error: 'Could not process input for unknown reason'
          };
          try {
            result = compile(obj);
            if (result != null) {
              answer = {
                result: "" + result
              };
            }
          } catch (_error) {
            e = _error;
            answer = {
              error: "In compile(...): " + e
            };
          }
          try {
            buf = pack(answer);
          } catch (_error) {
            e = _error;
            console.error(answer);
            buf = pack({
              error: "In pack(...): " + e
            });
          }
          _this.write(buf);
          return _this.end;
        });
      };
    })(this));
    return this.pipe(sink);
  }));

  server.on('error', function(e) {
    return console.error("error: " + e);
  });

  process.argv.shift();

  process.argv.shift();

  port = process.argv.pop() || 12345;

  host = process.argv.pop() || 'localhost';

  if (!parseInt(port)) {
    host = void 0;
  }

  try {
    server.listen(port, host, function() {
      return console.log("server bound at " + (host || 'unix') + ":" + port);
    });
  } catch (_error) {
    e = _error;
    console.error("error: " + e);
  }

}).call(this);