spider-src 0.1.5

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

@@ -0,0 +1,291 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn Range(start, operator, to) 
+  extends Node {
+  
+  this.type = 'Range';
+  this.operator = operator;
+  
+  this.start = start;
+  
+  if this.start? {
+    this.start.parent = this;
+  }
+  
+  this.to = to;
+  
+  if this.to? {
+    this.to.parent = this;
+  }
+}
+
+Range.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var isNumber = (n) -> !::isNaN(::parseFloat(n)) && ::isFinite(n);
+  var isNumeric = isNumber(this.start.value) && isNumber(this.to.value);
+                  
+  this.start = this.start.codegen();
+  this.to = this.to.codegen();
+  
+  var updateOperator, testOperator;
+  
+  if isNumeric {
+    updateOperator = '++' if this.start.value < this.to.value else '--';
+    testOperator = '<' if this.start.value < this.to.value else '>';
+    
+    if this.operator ==  '..' {
+      testOperator += '=';
+    }
+  }
+  
+  if isNumeric && ::Math.abs(this.to.value - this.start.value) <= 20 {
+    this.type = 'ArrayExpression';
+    this.elements = [];
+    
+    var test = (i) -> {
+      switch testOperator {
+        case '>': {
+          return i > this.to.value;
+        },
+        
+        case '<': {
+          return i < this.to.value;
+        },
+        
+        case '>=': {
+          return i >= this.to.value;
+        },
+        
+        case '<=': {
+          return i <= this.to.value;
+        }
+      }
+    };
+    
+    for var i = this.start.value; 
+        test.call(this, i);
+        i++ if updateOperator == '++' else i-- {
+      this.elements.push({
+        "type": "Literal",
+        "value": i
+      });
+    }
+  } else {
+    var testExpression, updateExpression;
+    
+    var declarations = [{
+      "type": "VariableDeclarator",
+      "id": {
+        "type": "Identifier",
+        "name": "_results"
+      },
+      "init": {
+        "type": "ArrayExpression",
+        "elements": []
+      }
+    }];
+    
+    if isNumeric {
+      testExpression = {
+        "type": "BinaryExpression",
+        "operator": testOperator,
+        "left": {
+          "type": "Identifier",
+          "name": "_i"
+        },
+        "right": this.to
+      };
+      
+      updateExpression = {
+        "type": "UpdateExpression",
+        "operator": updateOperator,
+        "argument": {
+          "type": "Identifier",
+          "name": "_i"
+        },
+        "prefix": false
+      };
+    } else {
+      if this.start.hasCallExpression() {
+        var startId = {
+          "type": "Identifier",
+          "name": "_start"
+        };
+          
+        declarations.push({
+          "type": "VariableDeclarator",
+          "id": startId,
+          "init": this.start
+        });
+        
+        this.start = startId;
+      }
+      
+      if this.to.hasCallExpression() {
+        var endId = {
+          "type": "Identifier",
+          "name": "_end"
+        };
+          
+        declarations.push({
+          "type": "VariableDeclarator",
+          "id": endId,
+          "init": this.to
+        });
+        
+        this.to = endId;
+      }    
+      
+      testExpression = {
+        "type": "ConditionalExpression",
+        "test": {
+          "type": "BinaryExpression",
+          "operator": "<=",
+          "left": this.start,
+          "right": this.to
+        },
+        "consequent": {
+          "type": "BinaryExpression",
+          "operator": "<" + ('=' if this.operator == '..' else ''),
+          "left": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "right": this.to
+        },
+        "alternate": {
+          "type": "BinaryExpression",
+          "operator": ">" + ('=' if this.operator == '..' else ''),
+          "left": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "right": this.to
+        } 
+      };
+      
+      updateExpression = {
+        "type": "ConditionalExpression",
+        "test":  {
+          "type": "BinaryExpression",
+          "operator": "<=",
+          "left": this.start,
+          "right": this.to
+        },
+        "consequent": {
+          "type": "UpdateExpression",
+          "operator": "++",
+          "argument": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "prefix": false
+        },
+        "alternate": {
+          "type": "UpdateExpression",
+          "operator": "--",
+          "argument": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "prefix": false
+        }
+      };
+    }
+    
+    this.type = 'CallExpression';
+    
+    this.callee = {
+      "type": "MemberExpression",
+      "computed": false,
+      "object": {
+        "type": "FunctionExpression",
+        "id": null,
+        "params": [],
+        "defaults": [],
+        "body": {
+          "type": "BlockStatement",
+          "body": [
+            {
+              "type": "VariableDeclaration",
+              "declarations": declarations,
+              "kind": "let"
+            },
+            {
+              "type": "ForStatement",
+              "init": {
+                "type": "VariableDeclaration",
+                "declarations": [{
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "_i"
+                  },
+                  "init": this.start
+                }],
+                "kind": "let"
+              },
+              "test": testExpression,
+              "update": updateExpression,
+              "body": {
+                "type": "BlockStatement",
+                "body": [{
+                  "type": "ExpressionStatement",
+                  "expression": {
+                    "type": "CallExpression",
+                    "callee": {
+                      "type": "MemberExpression",
+                      "computed": false,
+                      "object": {
+                        "type": "Identifier",
+                        "name": "_results"
+                      },
+                      "property": {
+                        "type": "Identifier",
+                        "name": "push"
+                      }
+                    },
+                    "arguments": [{
+                      "type": "Identifier",
+                      "name": "_i"
+                    }]
+                  }
+                }]
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "_results"
+              }
+            }
+          ]
+        },
+        "rest": null,
+        "generator": false,
+        "expression": false
+      },
+      "property": {
+        "type": "Identifier",
+        "name": "apply"
+      }
+    };
+  
+    ::Object.defineProperty(this, 'arguments', { 
+      value: [{ "type": "ThisExpression" }], 
+      enumerable: true 
+    });
+  }
+  
+  return this;
+};
+
+Range.prototype.hasCallExpression = () -> true;
+
+exports.Range = Range;

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

@@ -0,0 +1,33 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn VariableDeclarator(id, init) 
+  extends Node {
+  
+  this.type = 'VariableDeclarator';
+  
+  this.id = id;
+  this.id.parent = this;
+  
+  this.init = init;
+  
+  if this.init? {
+    this.init.parent = this;
+  }
+}
+
+VariableDeclarator.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.init? {
+    this.init = this.init.codegen();
+  }
+  
+  this.id = this.id.codegen();
+  return this;
+};
+
+exports.VariableDeclarator = VariableDeclarator;

data/lib/spider-src/support/spider/src/ast/expressions/ArrayExpression.spider

@@ -0,0 +1,32 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ArrayExpression(elements) 
+  extends Node {
+
+  this.type = 'ArrayExpression';
+  this.elements = elements;
+  
+  for element in this.elements {
+    if element? {
+      element.parent = this;
+    }
+  }
+}
+
+ArrayExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  for element, i in this.elements {
+    this.elements[i] = element?.codegen();
+  }
+  
+  return this;
+};
+
+ArrayExpression.prototype.hasCallExpression = () -> true;
+
+exports.ArrayExpression = ArrayExpression;

data/lib/spider-src/support/spider/src/ast/expressions/ArrayPattern.spider

@@ -0,0 +1,37 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ArrayPattern(elements) 
+  extends Node {
+
+  this.type = 'ArrayPattern';
+  this.elements = elements;
+  
+  for element in this.elements {
+    if element? {
+      element.parent = this;
+    }
+  }
+}
+
+ArrayPattern.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var context = this.getContext().node;
+  for element, i in this.elements {
+    this.elements[i] = element?.codegen(false);
+    
+    if element? and element.type == "Identifier" {
+      context.defineIdentifier(element);
+    }
+  }
+  
+  return this;
+};
+
+ArrayPattern.prototype.hasCallExpression = () -> true;
+
+exports.ArrayPattern = ArrayPattern;

data/lib/spider-src/support/spider/src/ast/expressions/AssignmentExpression.spider

@@ -0,0 +1,34 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn AssignmentExpression(left, operator, right) 
+  extends Node {
+
+  this.type = 'AssignmentExpression';
+  this.operator = operator;
+  
+  this.left = left;
+  this.left.parent = this;
+  
+  this.right = right;
+  this.right.parent = this;
+}
+
+AssignmentExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.left = this.left.codegen();
+  this.right = this.right.codegen();
+  
+  return this;
+};
+
+AssignmentExpression.prototype.hasCallExpression = () -> {
+  return this.left?.hasCallExpression() ||
+         this.right?.hasCallExpression();
+};
+
+exports.AssignmentExpression = AssignmentExpression;

data/lib/spider-src/support/spider/src/ast/expressions/BinaryExpression.spider

@@ -0,0 +1,125 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn BinaryExpression(left, operator, right) 
+  extends Node {
+  
+  this.type = 'BinaryExpression';
+  this.operator = operator;
+  
+  this.left = left;
+  this.left.parent = this;
+  
+  this.right = right;
+  this.right.parent = this;
+}
+
+BinaryExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var isRelational = (operator) 
+    -> operator in ['>', '>=', '<', '>='];
+  
+  // If we are dealing with something like a < x < b, 
+  // turn it into: a < x && x < b
+  if isRelational(this.operator) && 
+     isRelational(this.left.operator) {
+    this.type = 'LogicalExpression';
+    this.right = {
+      "type": "BinaryExpression",
+      "operator": this.operator,
+      "left": this.left.right,
+      "right": this.right.codegen()
+    };
+    
+    this.left = this.left.codegen();
+    this.operator = '&&';
+  } else {
+    this.left = this.left.codegen();
+    this.right = this.right.codegen();
+  
+    switch (this.operator) {
+      case '==': {
+        this.operator = '===';
+      },
+        
+      case '!=': {
+        this.operator = '!==';
+      },
+        
+      case '**': {
+        this.type = 'CallExpression';
+        this.callee = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "Identifier",
+            "name": "Math"
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "pow"
+          }
+        };
+        
+        ::Object.defineProperty(this, 'arguments', { 
+          value: [this.left, this.right], 
+          enumerable: true 
+        }); 
+      },
+        
+      case '#': {
+        this.type = 'CallExpression';
+        this.callee = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "Identifier",
+            "name": "Math"
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "floor"
+          }
+        };
+        
+        ::Object.defineProperty(this, 'arguments', { 
+          value: [{
+            "type": "BinaryExpression",
+            "operator": "/",
+            "left": this.left,
+            "right": this.right
+          }], 
+          enumerable: true 
+        }); 
+      },
+      
+      case '%%': {
+        this.operator = '%';
+        this.left = {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "%",
+            "left": this.left,
+            "right": this.right
+          },
+          "right": this.right
+        };    
+      }
+    }
+  }
+  
+  return this;
+};
+
+BinaryExpression.prototype.hasCallExpression = () -> {
+  return this.left?.hasCallExpression() || 
+         this.right?.hasCallExpression();
+};
+
+exports.BinaryExpression = BinaryExpression;

data/lib/spider-src/support/spider/src/ast/expressions/CallExpression.spider

@@ -0,0 +1,149 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+    
+fn CallExpression(callee, args) 
+  extends Node {
+  
+  this.type = 'CallExpression';
+  this.callee = callee;
+  this.callee.parent = this;
+  
+  ::Object.defineProperty(this, 'arguments', { 
+    value: args, 
+    enumerable: true 
+  });
+  
+  for arg in args {
+    arg.parent = this;
+  }
+}
+
+CallExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var calleeType = this.callee.type;  
+  
+  if !this.callee.codeGenerated {
+    this.callee = this.callee.codegen();
+  }
+  
+  var args = this.arguments;
+  var splatPositions = [];
+  
+  for arg, i in args {
+    if args[i].type == "SplatExpression" || args[i].__splat { 
+      splatPositions.push(i);
+    }
+    
+    if !args[i].codeGenerated { 
+      args[i] = arg.codegen();
+    }
+  }
+  
+  if splatPositions.length > 0 {
+    var argsClone = args.slice(0);
+    args.length = 0;
+    args.push({ 
+      "type": "Literal", 
+      "value": null
+    });
+    
+    if argsClone.length == 1 {
+      args.push(argsClone[0].arguments[0]);
+    } else {
+      args.push({ 
+        "type": "CallExpression",
+        "callee": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": argsClone[0] if splatPositions[0] == 0 else {
+            "type": "ArrayExpression",
+            "elements": argsClone[...splatPositions[0]]
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "concat"
+          }
+        },
+        "arguments": argsClone[1 if splatPositions[0] == 0 else splatPositions[0]..]
+          .map((arg, i) -> {
+            if splatPositions.indexOf(i + (1 if splatPositions[0] == 0 else splatPositions[0])) != -1 {
+              return arg;
+            }
+            
+            return {
+              "type": "ArrayExpression",
+              "elements": [arg]
+            };
+          })
+      });
+    }
+  }
+  
+  // If we are null propagating (?.), then turn this 
+  // into a condition and add the null propagating condition.
+  if this.callee.type == 'ConditionalExpression' && 
+     (calleeType == 'NullPropagatingExpression' || calleeType == 'MemberExpression') {
+    var parent = this.parent;
+    
+    var consequent = {
+      type: 'CallExpression',
+      callee: this.callee.consequent,
+      arguments: this.arguments
+    };
+    
+    if splatPositions.length > 0 {
+      this.callee.consequent = {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": this.callee.consequent,
+        "property": {
+          "type": "Identifier",
+          "name": "apply"
+        }
+      };
+    }
+                
+    // If we're inside a statement, then turn this into
+    // a normal if statement.
+    if parent.type == 'ExpressionStatement' {
+      parent.type = 'IfStatement';
+      parent.test = this.callee.test;
+      parent.consequent = {
+        type: 'BlockStatement',
+        body: [
+          {
+            type: 'ExpressionStatement',
+            expression: consequent
+          }
+        ]
+      };
+      parent.alternate = null;
+    } else {
+      // Otherwise, it should be a conditional expression (?:).
+      this.type = 'ConditionalExpression';
+      this.test = this.callee.test;
+      this.consequent = consequent;
+      this.alternate = this.callee.alternate;
+    }
+  } else if splatPositions.length > 0 {
+    this.callee = {
+      "type": "MemberExpression",
+      "computed": false,
+      "object": this.callee,
+      "property": {
+        "type": "Identifier",
+        "name": "apply"
+      }
+    };
+  }
+  
+  return this;
+};
+
+CallExpression.prototype.hasCallExpression = () -> true;
+
+exports.CallExpression = CallExpression;