sibilant 0.0.1 → 0.0.2

data/js/sibilant/lib/cli.js

@@ -0,0 +1,153 @@
+var sibilant = require("./sibilant"),
+    path = require("path"),
+    options = require("../lib/options"),
+    fs = require("fs"),
+    vm = require("vm"),
+    context = vm.createContext();
+var createContext = (function() {
+  context.initialized__QUERY = true;
+  (module)["filename"] = (process.cwd() + "/exec");
+  (context)["module"] = module;
+  (context)["require"] = require;
+  return (function() {
+    for (var key in global) (function() {
+      return (context)[key] = (global)[key];
+    })();
+  })();
+});
+
+var runInSandbox = (function(js, inputPath) {
+  // js:required inputPath:optional
+  if (arguments.length < 2) // if inputPath is missing
+    var inputPath = undefined;
+  
+  (function() {
+    if ((!context.initialized__QUERY)) {
+      return createContext();
+    }
+  })();
+  (function() {
+    if (typeof(inputPath) !== 'undefined') {
+      (process.argv)[1] = inputPath;
+      (context)["__dirname"] = path.dirname(inputPath);
+      return (module)["filename"] = inputPath;
+    }
+  })();
+  return vm.runInContext(js, context, "sibilant");
+});
+
+var cli = {
+  v: "version",
+  h: "help",
+  unhandled: "help",
+  f: "file",
+  o: "output",
+  x: "execute",
+  e: "eval",
+  i: "input",
+  afterBreak: false,
+  execute: false,
+  unlabeled: "file"
+};
+cli.version = (function() {
+  return console.log(sibilant.versionString());
+});
+
+cli.repl = (function(args) {
+  // args:required
+  return require("../lib/repl");
+});
+
+var readStdin = (function(fn) {
+  // fn:required
+  var stdin = process.stdin,
+      data = "";
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  stdin.on("data", (function(chunk) {
+    // chunk:required
+    return data = (data + chunk);
+  }));
+  return stdin.on("end", (function() {
+    return fn(data);
+  }));
+});
+
+cli.eval = (function(args, options) {
+  // args:required options:required
+  (options)["execute"] = true;
+  return cli.input(args, options);
+});
+
+cli.input = (function(args, options) {
+  // args:required options:required
+  var process = (function(sibilantCode) {
+    // sibilantCode:required
+    var jsCode = sibilant.translateAll(sibilantCode);
+    return (function() {
+      if (options.execute) {
+        return runInSandbox(jsCode);
+      } else {
+        return console.log(jsCode);
+      }
+    })();
+  });
+  ;
+  return (function() {
+    if (((args).length === 0)) {
+      return readStdin(process);
+    } else {
+      return process((args)[0]);
+    }
+  })();
+});
+
+cli.help = (function(args, options) {
+  // args:required options:required
+  return fs.readFile((__dirname + "/../cli-help"), { encoding: "utf8" }, (function(err, data) {
+    // err:required data:required
+    (function() {
+      if (err) {
+        throw new Error (err);
+      }
+    })();
+    return console.log(data);
+  }));
+});
+
+var cliOptions = options(cli);
+var args = (cliOptions.afterBreak || [  ]);
+args.unshift((process.argv)[1], "FILENAME");
+
+(process)["argv"] = args;
+(process)["ARGV"] = args;
+(function() {
+  if (((Object.keys(cliOptions)).length === 0)) {
+    return cli.repl();
+  }
+})()
+var outputDir = (function() {
+  if (cliOptions.output) {
+    return (cliOptions.output)[0];
+  }
+})();
+(cliOptions.file || [  ]).forEach((function(inputFile) {
+  // inputFile:required
+  var inputPath = path.join(process.cwd(), inputFile),
+      translated = sibilant.translateFile(inputPath);
+  return (function() {
+    if (outputDir) {
+      var inputBasename = path.basename(inputPath, ".sibilant"),
+          outputPath = (path.join(outputDir, inputBasename) + ".js");
+      return fs.writeFile(outputPath, translated);
+    } else {
+      return (function() {
+        if (cliOptions.execute) {
+          return runInSandbox(translated, inputPath);
+        } else {
+          return console.log(translated);
+        }
+      })();
+    }
+  })();
+}))

data/js/sibilant/lib/options.js

@@ -0,0 +1,232 @@
+var bulkMap = (function(arr, fn) {
+  // arr:required fn:required
+  var index = 0,
+      groupSize = fn.length,
+      retArr = [  ];
+  (function() {
+    var __returnValue__ = undefined;
+    while ((index < arr.length)) {
+      __returnValue__ = (function() {
+        retArr.push(fn.apply(undefined, arr.slice(index, (index + groupSize))));
+        return index += groupSize;
+      })();
+    };
+    return __returnValue__;
+  })();
+  return retArr;
+});
+
+var inject = (function(start, items, fn) {
+  // start:required items:required fn:required
+  var value = start;
+  (function() {
+    if ((items) && (items).constructor.name === "Array") {
+      return items.forEach((function(item, index) {
+        // item:required index:required
+        return value = fn(value, item, index);
+      }));
+    }
+  })();
+  return value;
+});
+
+var map = (function(items, fn) {
+  // items:required fn:required
+  return inject([  ], items, (function(collector, item, index) {
+    // collector:required item:required index:required
+    collector.push(fn(item, index));
+    return collector;
+  }));
+});
+
+var select = (function(items, fn) {
+  // items:required fn:required
+  return inject([  ], items, (function(collector, item, index) {
+    // collector:required item:required index:required
+    (function() {
+      if (fn(item, index)) {
+        return collector.push(item);
+      }
+    })();
+    return collector;
+  }));
+});
+
+var detect = (function(items, fn) {
+  // items:required fn:required
+  var returnItem = undefined,
+      index = 0,
+      items = items;
+  return (function() {
+    var __returnValue__ = undefined;
+    while ((!((items.length === index) || returnItem))) {
+      __returnValue__ = (function() {
+        (function() {
+          if (fn((items)[index], index)) {
+            return returnItem = (items)[index];
+          }
+        })();
+        return ((index)++);
+      })();
+    };
+    return __returnValue__;
+  })();
+});
+
+var reject = (function(items, fn) {
+  // items:required fn:required
+  var args = [ items, fn ];
+  return select(items, (function() {
+    return (!fn.apply(undefined, arguments));
+  }));
+});
+
+var compact = (function(arr) {
+  // arr:required
+  return select(arr, (function(item) {
+    // item:required
+    return (!!(item));
+  }));
+});
+
+var flatten = (function(items) {
+  // items:rest
+  var items = Array.prototype.slice.call(arguments, 0);
+  
+  return inject([  ], items, (function(collector, item) {
+    // collector:required item:required
+    return collector.concat((function() {
+      if ((item) && (item).constructor.name === "Array") {
+        return flatten.apply(undefined, item);
+      } else {
+        return item;
+      }
+    })());
+  }));
+});
+
+
+var extractOptions = (function(config, args) {
+  // config:required args:optional
+  if (arguments.length < 2) // if args is missing
+    var args = undefined;
+  
+  var args = (args || process.argv.slice(2)),
+      defaultLabel = "unlabeled",
+      currentLabel = defaultLabel,
+      afterBreak = false,
+      config = (config || {  }),
+      unlabeled = [  ];
+  var label__QUERY = (function(item) {
+    // item:required
+    return (typeof(item) === "string" && /^-/.test(item));
+  });
+  ;
+  var synonymLookup = (function(item) {
+    // item:required
+    var configEntry = (config)[item];
+    return (function() {
+      if (typeof(configEntry) === "string") {
+        return synonymLookup(configEntry);
+      } else {
+        return item;
+      }
+    })();
+  });
+  ;
+  var takesArgs__QUERY = (function(item) {
+    // item:required
+    return (false !== (config)[labelFor(item)]);
+  });
+  ;
+  defaultLabel = synonymLookup(defaultLabel);
+  currentLabel = defaultLabel;
+  var labelFor = (function(item) {
+    // item:required
+    return synonymLookup(item.replace(/^-+/, ""));
+  });
+  ;
+  var addValue = (function(hash, key, value) {
+    // hash:required key:required value:required
+    var currentValue = (hash)[key];
+    (function() {
+      if (typeof(currentValue) === 'undefined') {
+        currentValue = [  ];
+        return (hash)[key] = currentValue;
+      }
+    })();
+    return (function() {
+      if ((true !== value)) {
+        return currentValue.push(value);
+      }
+    })();
+  });
+  ;
+  var resetLabel = (function() {
+    return currentLabel = defaultLabel;
+  });
+  ;
+  return inject({  }, args, (function(returnHash, item, index) {
+    // returnHash:required item:required index:required
+    (function() {
+      if (("--" === item)) {
+        return afterBreak = true;
+      } else {
+        return (function() {
+          if (afterBreak) {
+            return addValue(returnHash, "afterBreak", item);
+          } else {
+            return (function() {
+              if (label__QUERY(item)) {
+                currentLabel = labelFor(item);
+                addValue(returnHash, currentLabel, true);
+                return (function() {
+                  if ((!takesArgs__QUERY(item))) {
+                    return resetLabel();
+                  }
+                })();
+              } else {
+                addValue(returnHash, currentLabel, item);
+                return resetLabel();
+              }
+            })();
+          }
+        })();
+      }
+    })();
+    return returnHash;
+  }));
+});
+
+var processOptions = (function(config) {
+  // config:optional
+  if (arguments.length < 1) // if config is missing
+    var config = undefined;
+  
+  var options = extractOptions(config);
+  (function() {
+    if (config) {
+      var handlePair = (function(key, value) {
+        // key:required value:required
+        var handle = (config)[key];
+        (function() {
+          if (typeof(handle) === "string") {
+            return handlePair(handle, value);
+          }
+        })();
+        return (function() {
+          if (typeof(handle) === 'function') {
+            return handle(value, options);
+          }
+        })();
+      });
+      return Object.keys(options).forEach((function(key) {
+        // key:required
+        return handlePair(key, (options)[key]);
+      }));
+    }
+  })();
+  return options;
+});
+
+(module)["exports"] = processOptions;

data/js/sibilant/lib/repl.js

@@ -0,0 +1,78 @@
+var input = process.openStdin(),
+    output = process.stdout,
+    vm = require("vm"),
+    readline = require("readline").createInterface(input, output),
+    sibilant = require("./sibilant"),
+    context = undefined,
+    cmdBuffer = "",
+    util = require("util");
+var createContext = (function() {
+  var context = vm.createContext();
+  (module)["filename"] = (process.cwd() + "/exec");
+  (context)["module"] = module;
+  (context)["require"] = require;
+  (function() {
+    for (var key in global) (function() {
+      return (context)[key] = (global)[key];
+    })();
+  })();
+  return context;
+});
+
+context = createContext();
+var displayPrompt = (function() {
+  readline.setPrompt(((function() {
+    if ((cmdBuffer.length > 10)) {
+      return ("..." + cmdBuffer.slice(-10));
+    } else {
+      return (function() {
+        if ((cmdBuffer.length > 0)) {
+          return cmdBuffer;
+        } else {
+          return "sibilant";
+        }
+      })();
+    }
+  })() + "> "));
+  return readline.prompt();
+});
+
+readline.on("line", (function(cmd) {
+  // cmd:required
+  var jsLine = "";
+  (function() {
+    try {
+      cmdBuffer = (cmdBuffer + cmd);
+      sibilant.tokenize(cmdBuffer).forEach((function(stmt) {
+        // stmt:required
+        return jsLine = (jsLine + sibilant.translate(stmt, "statement"));
+      }));
+      var result = vm.runInContext(jsLine, context, "sibilant-repl");
+      (readline.history)[0] = cmdBuffer;
+      (function() {
+        if (typeof(result) !== 'undefined') {
+          return output.write(("result: " + util.inspect(result) + "\n"));
+        }
+      })();
+      (context)["_"] = result;
+      return cmdBuffer = "";
+    } catch (e) {
+      return (function() {
+        if (e.message.match(/unexpected EOF/)) {
+          cmdBuffer = (cmdBuffer + " ");
+          return readline.history.shift();
+        } else {
+          (readline.history)[0] = cmdBuffer;
+          output.write((e.stack + "\n"));
+          return cmdBuffer = "";
+        }
+      })();
+    }
+  })();
+  return displayPrompt();
+}));
+
+readline.on("close", input.destroy);
+
+displayPrompt();
+