spider-src 0.1.5

data/lib/spider-src/support/spider/README.md

@@ -0,0 +1,50 @@
+Spider  
+===
+
+[![NPM Version](http://img.shields.io/npm/v/spider-script.svg?style=flat)](https://www.npmjs.org/package/spider-script) [![Build Status](https://img.shields.io/travis/alongubkin/spider.svg?style=flat)](http://travis-ci.org/alongubkin/spider) [![Dependencies](http://img.shields.io/david/alongubkin/spider.svg?style=flat)](https://david-dm.org/alongubkin/spider) [![Test Coverage](http://img.shields.io/coveralls/alongubkin/spider.svg?style=flat)](https://coveralls.io/r/alongubkin/spider)
+
+The Next-Gen Programming Language for the Web. 
+
+> **Note:** Spider is still work in progress. Make sure to star the project if you are interested!
+
+[Documentation](http://spiderlang.org/)
+
+### Installation
+
+    npm install -g spider-script
+    
+### Usage
+
+Execute a script:
+
+    spider /path/to/script.spider
+    
+Compile a script:
+
+    spider -c /path/to/script.spider
+
+### Join the Community
+
+* Website: http://spiderlang.org 
+* IRC: [#spiderlang](http://webchat.freenode.net/?channels=spiderlang) on Freenode
+* IRC Logs: [#spiderlang](https://botbot.me/freenode/spiderlang/) on BotBot
+* Q/A: [spiderlang](http://stackoverflow.com/questions/tagged/spiderlang) tag in StackOverflow
+* [Google Group](http://groups.google.com/d/forum/spiderlang?hl=en)
+
+### Contributing
+
+We need your help! 
+
+You can browse the [contributing-getting-started](https://github.com/alongubkin/spider/labels/contributing-getting-started) tag to find good issues to get started with.
+
+ 1. [Fork](https://github.com/alongubkin/spider/fork) the project
+ 2. Clone your forked repo: `git clone git@github.com:githubuser/spider.git`
+ 3. Create your feature/bugfix branch: `git checkout -b new-operator`
+ 4. Commit your changes to your new branch: `git commit -am 'Add a new operator'`
+ 5. Push to the branch: `git push origin new-operator`
+ 6. Create a new Pull Request!
+
+Resources:
+
+ * [PEG.js](http://pegjs.majda.cz/) (Used for parsing)
+ * [Esprima Parser](http://esprima.org/demo/parse.html#]) (Good way to learn the SpiderMonkey AST)

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

@@ -0,0 +1,119 @@
+#! /usr/bin/env node
+
+"use strict";
+
+var fs = require("fs"),
+    path = require("path"),
+    vm = require("vm"),
+    traceur = require("traceur"),
+    nomnom = require("nomnom"),
+    chalk = require("chalk"),
+    spider = require("./lib/spider");
+
+var opts = nomnom
+  .option("files", {
+    position: 0,
+    help: "files to compile",
+    list: true
+  })
+  .option("compile", {
+    abbr: "c",
+    flag: true,
+    help: "compile to JavaScript and save as .js files"
+  })
+  .option("verbose", {
+    abbr: "v",
+    flag: true,
+    help: "verbose mode"
+  })
+  .option("disable-source-map", {
+    flag: true,
+    help: "disable source map files (.map) generation"
+  })
+  .option("target", {
+    choices: ["ES6", "ES5"],
+    default: "ES5",
+    help: "target"
+  })
+  .option("version", {
+    flag: true,
+    help: "display the version number",
+    callback: function () {
+      return "version " + require("./package.json").version;
+    }
+  })
+  .parse();
+
+if (!opts.files) {
+  console.log(nomnom.getUsage());
+  process.exit(0);
+}
+
+var generateSourceMap = !opts['disable-source-map'] && opts.compile;
+var problems = 0;
+
+opts.files.forEach(function (fileName, fileIndex) {
+  var baseName = path.basename(fileName);
+
+  fs.readFile(baseName, "utf-8", function (error, content) {
+    var compilerOutput = spider.compile({
+      text: content,
+      fileName: baseName,
+      target: opts.target,
+      generateSourceMap: generateSourceMap
+    });
+    
+    if (compilerOutput.errors.length > 0) {
+      console.log(spider.formatErrors(baseName, content, compilerOutput.errors));
+      problems += compilerOutput.errors.length;
+      
+      if (problems > 0 && 
+          fileIndex === opts.files.length - 1)  {
+        console.log(chalk.red(problems + (problems === 1 ? " problem" : " problems")));
+      }      
+    } else {
+      if (opts.compile) {
+        var outFileNameWithoutExtension = fileName.substring(0, 
+          fileName.lastIndexOf('.'));    
+          
+        writeFile(outFileNameWithoutExtension + ".js", 
+          compilerOutput.result);
+            
+        if (generateSourceMap) {
+          writeFile(outFileNameWithoutExtension + ".map", 
+            compilerOutput.result);
+        }
+      } else {
+        var sandbox = {};
+        for (var key in global) {
+          sandbox[key] = global[key];
+        }
+        var Module, _module, _require;
+        Module = require('module');
+        sandbox.module = _module = new Module(outFileNameWithoutExtension || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module, true);
+        };
+        _module.filename = sandbox.__filename;
+        Object.getOwnPropertyNames(require).forEach(function(r){
+          if (r !== 'paths' && r !== 'arguments' && r !== 'caller') {
+            _require[r] = require[r];
+          }            
+        })
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+        vm.runInNewContext(compilerOutput.result, sandbox);
+      }
+    }
+  });
+});
+
+function writeFile(fileName, content) {
+  fs.writeFile(fileName, content, function (error) {
+    if (error) {
+      return console.log(error);
+    }
+  });
+}

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

@@ -0,0 +1,179 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function CaseClause(tests, body) {
+    Node.call(this);
+    this.type = "CaseClause";
+    this.body = body;
+    this.body.parent = this;
+    this.tests = tests;
+    if (typeof this.tests !== "undefined" && this.tests !== null) {
+      for (var $__0 = this.tests[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__1; !($__1 = $__0.next()).done; ) {
+        var test = $__1.value;
+        {
+          test.parent = this;
+        }
+      }
+    }
+  }
+  CaseClause.prototype = Object.create(Node);
+  CaseClause.prototype.codegen = function(branchFallthrough) {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (!(typeof this.tests !== "undefined" && this.tests !== null) && !branchFallthrough) {
+      return this.body.codegen();
+    }
+    this.type = "IfStatement";
+    this.switchCase = true;
+    var rangeError = false;
+    if (typeof this.tests !== "undefined" && this.tests !== null) {
+      for (var $__2 = this.tests[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__3; !($__3 = $__2.next()).done; ) {
+        var test = $__3.value;
+        {
+          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": "<" + (test.operator === ".." ? "=" : ""),
+                "left": this.parent.discriminant,
+                "right": test.to
+              };
+            }
+            if (!!fromCheck && !!toCheck) {
+              equalsToDiscriminant = {
+                "type": "LogicalExpression",
+                "operator": "&&",
+                "left": fromCheck,
+                "right": toCheck
+              };
+            } else {
+              if (!!fromCheck || !!toCheck) {
+                equalsToDiscriminant = typeof fromCheck === "undefined" || fromCheck == null ? toCheck : fromCheck;
+              } 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
+                }
+              };
+              var i = 0;
+              for (var $__0 = test.elements[$traceurRuntime.toProperty(Symbol.iterator)](),
+                  $__1; !($__1 = $__0.next()).done; ) {
+                var element = $__1.value;
+                {
+                  if (typeof element !== "undefined" && element !== null) {
+                    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
+                      }
+                    };
+                  }
+                  i++;
+                }
+              }
+            } 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 (!(typeof this.tests !== "undefined" && this.tests !== null)) {
+        this.test = fallthroughTest;
+      } else {
+        this.test = {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": fallthroughTest,
+          "right": this.test
+        };
+      }
+    }
+    this.alternate = null;
+    return this;
+  };
+  exports.CaseClause = CaseClause;
+  return {};
+});
+
+//# sourceMappingURL=CaseClause.map

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

@@ -0,0 +1,26 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function CatchClause(param, body) {
+    Node.call(this);
+    this.type = "CatchClause";
+    this.param = param;
+    this.param.parent = this;
+    this.body = body;
+    this.body.parent = this;
+  }
+  CatchClause.prototype = Object.create(Node);
+  CatchClause.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.param = this.param.codegen(false);
+    this.defineIdentifier(this.param);
+    this.body = this.body.codegen();
+    return this;
+  };
+  exports.CatchClause = CatchClause;
+  return {};
+});
+
+//# sourceMappingURL=CatchClause.map

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

@@ -0,0 +1,19 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function ExportBatchSpecifier() {
+    Node.call(this);
+    this.type = "ExportBatchSpecifier";
+  }
+  ExportBatchSpecifier.prototype = Object.create(Node);
+  ExportBatchSpecifier.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    return this;
+  };
+  exports.ExportBatchSpecifier = ExportBatchSpecifier;
+  return {};
+});
+
+//# sourceMappingURL=ExportBatchSpecifier.map

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

@@ -0,0 +1,33 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function ExportSpecifier(id, alias) {
+    Node.call(this);
+    this.type = "ExportSpecifier";
+    this.id = id;
+    this.id.parent = this;
+    if (typeof alias !== "undefined" && alias !== null) {
+      this.alias = alias;
+      this.alias.parent = this;
+    }
+  }
+  ExportSpecifier.prototype = Object.create(Node);
+  ExportSpecifier.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.id = this.id.codegen(false);
+    Object.defineProperty(this, "name", {
+      value: typeof this.alias !== "undefined" && this.alias !== null ? {
+        "type": "Identifier",
+        "name": this.alias.name
+      } : null,
+      enumerable: true
+    });
+    return this;
+  };
+  exports.ExportSpecifier = ExportSpecifier;
+  return {};
+});
+
+//# sourceMappingURL=ExportSpecifier.map

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

@@ -0,0 +1,23 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function ImportDefaultSpecifier(id) {
+    Node.call(this);
+    this.type = "ImportDefaultSpecifier";
+    this.id = id;
+    this.id.parent = this;
+  }
+  ImportDefaultSpecifier.prototype = Object.create(Node);
+  ImportDefaultSpecifier.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.id = this.id.codegen(false);
+    this.getContext().node.defineIdentifier(this.id);
+    return this;
+  };
+  exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+  return {};
+});
+
+//# sourceMappingURL=ImportDefaultSpecifier.map

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

@@ -0,0 +1,23 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function ImportNamespaceSpecifier(id) {
+    Node.call(this);
+    this.type = "ImportNamespaceSpecifier";
+    this.id = id;
+    this.id.parent = this;
+  }
+  ImportNamespaceSpecifier.prototype = Object.create(Node);
+  ImportNamespaceSpecifier.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.id = this.id.codegen(false);
+    this.getContext().node.defineIdentifier(this.id);
+    return this;
+  };
+  exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+  return {};
+});
+
+//# sourceMappingURL=ImportNamespaceSpecifier.map

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

@@ -0,0 +1,40 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function ImportSpecifier(id, alias) {
+    Node.call(this);
+    this.type = "ImportSpecifier";
+    if (typeof id !== "undefined" && id !== null) {
+      this.id = id;
+      this.id.parent = this;
+    }
+    if (typeof alias !== "undefined" && alias !== null) {
+      this.alias = alias;
+      this.alias.parent = this;
+    }
+  }
+  ImportSpecifier.prototype = Object.create(Node);
+  ImportSpecifier.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (typeof this.id !== "undefined" && this.id !== null) {
+      this.id = this.id.codegen(false);
+    } else {
+      this.type = "ImportNamespaceSpecifier";
+    }
+    Object.defineProperty(this, "name", {
+      value: typeof this.alias !== "undefined" && this.alias !== null ? {
+        "type": "Identifier",
+        "name": this.alias.name
+      } : null,
+      enumerable: true
+    });
+    this.getContext().node.defineIdentifier(this.alias == null ? this.id : this.alias);
+    return this;
+  };
+  exports.ImportSpecifier = ImportSpecifier;
+  return {};
+});
+
+//# sourceMappingURL=ImportSpecifier.map

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

@@ -0,0 +1,93 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  function Node() {
+    var self = this;
+    self.codeGenerated = false;
+    self.definedIdentifiers = [];
+    Object.defineProperty(self, "parent", {
+      value: null,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    self.getContext = function() {
+      if (!!(self.type === "Program") || !!(self.type === "BlockStatement")) {
+        return {
+          node: self,
+          position: -1
+        };
+      }
+      if (!(typeof self.parent !== "undefined" && self.parent !== null)) {
+        return null;
+      }
+      var context = self.parent.getContext();
+      if (!(typeof context !== "undefined" && context !== null)) {
+        return null;
+      }
+      if (context.position === -1) {
+        return {
+          node: context.node,
+          position: context.node.body.indexOf(self)
+        };
+      } else {
+        return context;
+      }
+    };
+    self.defineIdentifier = function(identifier) {
+      self.definedIdentifiers.push(identifier);
+    };
+    self.isIdentifierDefined = function(name) {
+      var defined = false;
+      for (var $__0 = self.definedIdentifiers[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__1; !($__1 = $__0.next()).done; ) {
+        var identifier = $__1.value;
+        {
+          if (identifier.name === name) {
+            defined = true;
+          }
+        }
+      }
+      return !!defined || !!(!!self.parent && !!self.parent.isIdentifierDefined(name));
+    };
+    self.getDefinedIdentifier = function(name) {
+      var id;
+      for (var $__0 = self.definedIdentifiers[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__1; !($__1 = $__0.next()).done; ) {
+        var identifier = $__1.value;
+        {
+          if (identifier.name === name) {
+            id = identifier;
+          }
+        }
+      }
+      return typeof id === "undefined" || id == null ? self.parent ? self.parent.getDefinedIdentifier(name) : null : id;
+    };
+    self.blockWrap = function() {
+      if (self.type === "BlockStatement") {
+        return self;
+      }
+      var myParent = self.parent;
+      var blockStatement = module.require("./statements/BlockStatement");
+      var block = new blockStatement.BlockStatement([self]);
+      block.parent = myParent;
+      return block;
+    };
+  }
+  Node.prototype.codegen = function() {
+    if (this.codeGenerated) {
+      return false;
+    }
+    this.codeGenerated = true;
+    return true;
+  };
+  Node.setErrorManager = function(errorManager) {
+    this.errorManager = errorManager;
+  };
+  Node.getErrorManager = function() {
+    return this.errorManager;
+  };
+  exports.Node = Node;
+  return {};
+});
+
+//# sourceMappingURL=Node.map