spider-src 0.1.5

data/lib/spider-src/support/spider/lib/spider.js

@@ -0,0 +1,217 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var parser = module.require("./parser"),
+      escodegen = require("escodegen"),
+      ast = module.require("./ast"),
+      traceur = require("traceur"),
+      chalk = require("chalk"),
+      transfer = require("multi-stage-sourcemap").transfer;
+  exports.compile = function(options) {
+    var result = {
+      errors: [],
+      result: null,
+      sourceMap: null
+    };
+    options.fileName = options.fileName == null ? "tmp" : options.fileName;
+    var outFileNameWithoutExtension = options.fileName.substring(0, options.fileName.lastIndexOf("."));
+    var outFileName = outFileNameWithoutExtension + ".js";
+    var mapFileName = outFileNameWithoutExtension + ".map";
+    resetVariableNames();
+    ast.Node.setErrorManager(new ErrorManager(result.errors));
+    var parsed;
+    try {
+      parsed = parser.parse(options.text);
+    } catch (e) {
+      result.errors.push(getParsingError(e));
+    }
+    if (!parsed) {
+      return result;
+    }
+    var tree = parsed.codegen();
+    if (options.target !== "ES5") {
+      tree = wrapCode(tree, options.useStrict == null ? true : options.useStrict, options.iifi == null ? true : options.iifi);
+    }
+    var output = escodegen.generate(tree, {
+      sourceMap: options.generateSourceMap ? options.fileName : null,
+      sourceMapWithCode: options.generateSourceMap,
+      format: {quotes: "double"}
+    });
+    if (options.generateSourceMap) {
+      result.result = output.code;
+      result.sourceMap = output.map.toString();
+    } else {
+      result.result = output;
+    }
+    if (options.target === "ES5") {
+      var traceurCompiler = new traceur.NodeCompiler({
+        sourceMaps: options.generateSourceMap,
+        asyncFunctions: true
+      });
+      result.result = traceurCompiler.compile(result.result, options.fileName, outFileName);
+      if (options.generateSourceMap) {
+        result.sourceMap = transfer({
+          toSourceMap: result.sourceMap,
+          fromSourceMap: traceurCompiler.getSourceMap().toString()
+        });
+      }
+    } else {
+      if (options.generateSourceMap) {
+        result.result = result.result + "\n\n//# sourceMappingURL=" + mapFileName;
+      }
+    }
+    if (options.verbose) {
+      console.log(JSON.stringify(parsed, null, 4));
+      console.log(result.result);
+    }
+    return result;
+  };
+  exports.formatErrors = function(fileName, content, errors) {
+    var output = [];
+    var maxCol = 0;
+    var maxLine = 0;
+    output.push(chalk.white(fileName), "\n");
+    var lines = content.split("\n");
+    var tabCharacter = "__SPIDER_TAB";
+    var errorIndex = 0;
+    for (var $__0 = errors[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var error = $__1.value;
+      {
+        var line = error.loc.start.line;
+        var column = error.loc.start.column + 1;
+        var lineCharCount = line.toString().length;
+        var columnCharCount = column.toString().length;
+        maxCol = Math.max(maxCol, columnCharCount);
+        maxLine = Math.max(maxCol, lineCharCount);
+        output.push(tabCharacter);
+        output.push(chalk.gray("line", line));
+        output.push(tabCharacter, lineCharCount);
+        output.push(chalk.gray("col", column));
+        output.push(tabCharacter, columnCharCount);
+        output.push(chalk.red(error.message), "\n");
+        if (typeof error.loc !== "undefined" && error.loc !== null ? error.loc.start : void 0) {
+          var start = error.loc.start;
+          var end = error.loc.end;
+          if (0 < start.line <= lines.length) {
+            output.push(tabCharacter, tabCharacter, tabCharacter);
+            output.push(chalk.green(lines[start.line - 1].replace(/(\r\n|\n|\r)/gm, ""), "\n", tabCharacter, tabCharacter));
+            output.push(chalk.red(generateErrorColumnString(start.column, end ? end.column - 1 : 0)));
+          }
+        }
+        output.push("\n");
+        errorIndex++;
+      }
+    }
+    var str = output.join("");
+    var tabLength = Math.max(maxLine, maxCol);
+    for (var i = 1; i <= tabLength; i++) {
+      var regex = new RegExp(tabCharacter + i, "g");
+      str = str.replace(regex, generateSpace(Math.max(2 + tabLength - i, 2)));
+    }
+    return str.replace(new RegExp(tabCharacter, "g"), generateSpace(2));
+  };
+  function ErrorManager(errors) {
+    this.errors = errors;
+  }
+  ErrorManager.prototype.error = function(e) {
+    this.errors.push(e);
+  };
+  function getParsingError(e) {
+    var message;
+    if (e.expected) {
+      if (e.found) {
+        message = "unexpected " + e.found;
+      } else {
+        message = "unexpected end of input";
+      }
+    } else {
+      message = e.message;
+    }
+    return {
+      type: "SyntaxError",
+      message: message,
+      loc: {start: {
+          line: e.line,
+          column: e.column - 1
+        }}
+    };
+  }
+  function resetVariableNames() {
+    ast.NullPropagatingExpression.resetVariableNames();
+    ast.NullCoalescingExpression.resetVariableNames();
+    ast.NullCheckCallExpression.resetVariableNames();
+    ast.ExistentialExpression.resetVariableNames();
+    ast.FunctionExpression.resetVariableNames();
+    ast.ForOfStatement.resetVariableNames();
+    ast.ForInExpression.resetVariableNames();
+    ast.FallthroughStatement.resetVariableNames();
+    ast.SwitchStatement.resetVariableNames();
+  }
+  function wrapCode(tree) {
+    var useStrict = arguments[1] !== (void 0) ? arguments[1] : false;
+    var iifi = arguments[2] !== (void 0) ? arguments[2] : false;
+    if (!!iifi || !!useStrict) {
+      var body = [];
+      if (useStrict) {
+        body.push({
+          "type": "ExpressionStatement",
+          "expression": {
+            "type": "Literal",
+            "value": "use strict"
+          }
+        });
+      }
+      if (iifi) {
+        body.push({
+          "type": "ExpressionStatement",
+          "expression": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "FunctionExpression",
+              "id": null,
+              "params": [],
+              "defaults": [],
+              "body": {
+                "type": "BlockStatement",
+                "body": tree.body
+              },
+              "rest": null,
+              "generator": false,
+              "expression": false
+            },
+            "arguments": []
+          }
+        });
+      }
+      tree = {
+        "type": "Program",
+        "body": body
+      };
+    }
+    return tree;
+  }
+  function generateSpace(len) {
+    var chars = [];
+    for (var i = 0; i < len; i++) {
+      chars.push(" ");
+    }
+    return chars.join("");
+  }
+  function generateErrorColumnString(errorStartIndex, errorEndIndex) {
+    var chars = [];
+    var i = 0;
+    if (!errorEndIndex) {
+      errorEndIndex = errorStartIndex;
+    }
+    for (; i < errorStartIndex; i++) {
+      chars.push(" ");
+    }
+    for (i = errorStartIndex; i <= errorEndIndex; i++) {
+      chars.push("^");
+    }
+    return chars.join("");
+  }
+  return {};
+});
+
+//# sourceMappingURL=spider.map

data/lib/spider-src/support/spider/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "spider-script",
+  "version": "0.1.5",
+  "main": "spider-script.js",
+  "description": "The Next-Gen Programming Language for the Web",
+  "homepage": "http://spiderlang.org",
+  "bugs": "https://github.com/alongubkin/spider/issues",
+  "author": {
+    "name": "Alon Gubkin",
+    "email": "alon.gubkin@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alongubkin/spider"
+  },
+  "license": "Apache",
+  "files": [
+    "lib",
+    "cli.js",
+    "spider-script.js"
+  ],
+  "keywords": [
+    "spider",
+    ""
+  ],
+  "devDependencies": {
+    "coveralls": "~2.11.2",
+    "grunt-contrib-clean": "~0.6.0",
+    "grunt-contrib-copy": "~0.7.0",
+    "grunt-contrib-nodeunit": "^0.3.3",
+    "grunt-contrib-watch": "^0.6.1",
+    "grunt-eslint": "~2.0.0",
+    "grunt-mocha-cli": "^1.9.0",
+    "grunt-mocha-istanbul": "~2.2.0",
+    "grunt-peg": "~1.5.0",
+    "grunt-spider-script": "0.0.9",
+    "istanbul": "~0.3.2",
+    "load-grunt-tasks": "^0.4.0",
+    "mocha": "~2.0.1",
+    "mocha-lcov-reporter": "0.0.1",
+    "shelljs-nodecli": "~0.1.1",
+    "should": "~4.1.0",
+    "time-grunt": "^0.3.1",
+    "grunt": "~0.4.5"
+  },
+  "scripts": {
+    "test": "grunt"
+  },
+  "bin": {
+    "spider": "cli.js"
+  },
+  "preferGlobal": "true",
+  "dependencies": {
+    "escodegen": "estools/escodegen#21a9331",
+    "pegjs": "~0.8.0",
+    "nomnom": "~1.8.1",
+    "chalk": "~0.5.1",
+    "traceur": "0.0.74",
+    "multi-stage-sourcemap": "~0.2.1"
+  }
+}

data/lib/spider-src/support/spider/spider-script.js

@@ -0,0 +1,6 @@
+require("traceur");
+
+var spider = require("./lib/spider");
+for (var prop in spider) {
+	exports[prop] = spider[prop];
+}

data/lib/spider-src/support/spider/src/ast/CaseClause.spider

@@ -0,0 +1,179 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn CaseClause(tests, body) 
+  extends Node {
+  
+  this.type = 'CaseClause';
+  
+  this.body = body;
+  this.body.parent = this;
+  
+  this.tests = tests;
+  if this.tests? {
+    for test in this.tests {
+      test.parent = this;
+    }
+  }
+}
+
+CaseClause.prototype.codegen = (branchFallthrough) -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if !this.tests? and !branchFallthrough {
+    return this.body.codegen();
+  }
+  
+  this.type = "IfStatement";
+  this.switchCase = true;
+  
+  var rangeError = false;
+  
+  if this.tests? {
+    for test in this.tests {
+      var equalsToDiscriminant;
+      
+      if test.type == "Range" {
+        var fromCheck;
+        if test.start {
+          fromCheck = {
+            "type": "BinaryExpression",
+            "operator": ">=",
+            "left": this.parent.discriminant,
+            "right": test.start
+          };
+        }
+        
+        var toCheck;
+        if test.to {
+          toCheck = {
+            "type": "BinaryExpression",
+            "operator": "<" + ("=" if test.operator == ".." else ""),
+            "left": this.parent.discriminant,
+            "right": test.to
+          };
+        }
+        
+        if fromCheck && toCheck {
+          equalsToDiscriminant = {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": fromCheck,
+            "right": toCheck
+          };
+        } else if fromCheck || toCheck {
+          equalsToDiscriminant = fromCheck ?? toCheck;
+        } else {
+          rangeError = test;
+          break;
+        }
+      } else if test.type == "ArrayExpression" {
+        test = test.codegen();
+        
+        equalsToDiscriminant = {
+          "type": "BinaryExpression",
+          "operator": ">=",
+          "left": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": this.parent.discriminant,
+            "property": {
+              "type": "Identifier",
+              "name": "length"
+            }
+          },
+          "right": {
+            "type": "Literal",
+            "value": test.elements.length
+          }
+        };
+        
+        for element, i in test.elements {
+          if element? {
+            equalsToDiscriminant = {
+              "type": "LogicalExpression",
+              "operator": "&&",
+              "left": equalsToDiscriminant,
+              "right": {
+                "type": "BinaryExpression",
+                "operator": "===",
+                "left": {
+                  "type": "MemberExpression",
+                  "computed": true,
+                  "object": this.parent.discriminant,
+                  "property": {
+                    "type": "Literal",
+                    "value": i
+                  }
+                },
+                "right": element
+              }
+            };
+          }
+        }
+      } else {
+        equalsToDiscriminant = {
+          "type": "BinaryExpression",
+          "operator": "===",
+          "left": this.parent.discriminant,
+          "right": test.codegen()
+        };
+      }
+      
+      if !this.test {
+        this.test = equalsToDiscriminant;
+      } else {
+        this.test = {
+          "type": "LogicalExpression",
+          "operator": "||",
+          "left": this.test,
+          "right": equalsToDiscriminant
+        };
+      }
+    }
+  }
+  
+  if rangeError {
+    Node.getErrorManager().error({
+      type: "EmptyRange",
+      message: "empty range in case clause is disallowed.",
+      loc: rangeError.loc
+    });
+    
+    return null;
+  }
+  
+  this.consequent = this.body.codegen();
+  
+  if branchFallthrough {
+    var fallthroughTest = {
+      "type": "BinaryExpression",
+      "left": this.parent.fallthroughId,
+      "operator": "<",
+      "right": {
+        "type": "Literal",
+        "value": 2
+      }
+    };
+    
+    if !this.tests? {
+      this.test = fallthroughTest;
+    } else {
+      this.test = {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": fallthroughTest,
+        "right": this.test
+      };
+    }
+  } 
+
+  this.alternate = null;
+  
+  return this;
+};
+
+exports.CaseClause = CaseClause;

data/lib/spider-src/support/spider/src/ast/CatchClause.spider

@@ -0,0 +1,30 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn CatchClause(param, body) 
+  extends Node {
+  
+  this.type = 'CatchClause';
+  
+  this.param = param;
+  this.param.parent = this;
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+CatchClause.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.param = this.param.codegen(false);
+  this.defineIdentifier(this.param);
+  
+  this.body = this.body.codegen();
+  
+  return this;
+};
+
+exports.CatchClause = CatchClause;

data/lib/spider-src/support/spider/src/ast/ExportBatchSpecifier.spider

@@ -0,0 +1,19 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn ExportBatchSpecifier()
+  extends Node {
+  
+  this.type = "ExportBatchSpecifier";
+}
+
+ExportBatchSpecifier.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+exports.ExportBatchSpecifier = ExportBatchSpecifier;

data/lib/spider-src/support/spider/src/ast/ExportSpecifier.spider

@@ -0,0 +1,37 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn ExportSpecifier(id, alias)
+  extends Node {
+  
+  this.type = "ExportSpecifier";
+  
+  this.id = id;
+  this.id.parent = this;
+  
+  if alias? {
+    this.alias = alias;
+    this.alias.parent = this;
+  }  
+}
+
+ExportSpecifier.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.id = this.id.codegen(false);
+  
+  ::Object.defineProperty(this, 'name', { 
+    value: {
+      "type": "Identifier",
+      "name": this.alias.name
+    } if this.alias? else null, 
+    enumerable: true 
+  });
+  
+  return this;
+};
+
+exports.ExportSpecifier = ExportSpecifier;

data/lib/spider-src/support/spider/src/ast/ImportDefaultSpecifier.spider

@@ -0,0 +1,25 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn ImportDefaultSpecifier(id)
+  extends Node {
+  
+  this.type = "ImportDefaultSpecifier";
+  
+  this.id = id;
+  this.id.parent = this;
+}
+
+ImportDefaultSpecifier.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.id = this.id.codegen(false);
+  this.getContext().node.defineIdentifier(this.id);
+  
+  return this;
+};
+
+exports.ImportDefaultSpecifier = ImportDefaultSpecifier;

data/lib/spider-src/support/spider/src/ast/ImportNamespaceSpecifier.spider

@@ -0,0 +1,25 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn ImportNamespaceSpecifier(id)
+  extends Node {
+  
+  this.type = "ImportNamespaceSpecifier";
+  
+  this.id = id;
+  this.id.parent = this;
+}
+
+ImportNamespaceSpecifier.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.id = this.id.codegen(false);
+  this.getContext().node.defineIdentifier(this.id);
+  
+  return this;
+};
+
+exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;

data/lib/spider-src/support/spider/src/ast/ImportSpecifier.spider

@@ -0,0 +1,44 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn ImportSpecifier(id, alias)
+  extends Node {
+  
+  this.type = "ImportSpecifier";
+  
+  if id? {
+    this.id = id;
+    this.id.parent = this;
+  }
+  
+  if alias? {
+    this.alias = alias;
+    this.alias.parent = this;
+  }
+}
+
+ImportSpecifier.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.id? {
+    this.id = this.id.codegen(false);
+  } else {
+    this.type = "ImportNamespaceSpecifier";
+  }
+  
+  ::Object.defineProperty(this, 'name', { 
+    value: {
+      "type": "Identifier",
+      "name": this.alias.name
+    } if this.alias? else null, 
+    enumerable: true 
+  });
+  
+  this.getContext().node.defineIdentifier(this.alias ?? this.id);
+  return this;
+};
+
+exports.ImportSpecifier = ImportSpecifier;