guard-mthaml 0.1.0

data/vendor/coffeescript/coffeescript/src/CoffeeScript/yy/Call.php

@@ -0,0 +1,283 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Call extends yy_Base
+{
+  public $children = array('variable', 'args');
+
+  private $is_new;
+  private $is_super;
+
+  function constructor($variable = NULL, $args = array(), $soak = FALSE)
+  {
+    $this->args = $args;
+    $this->is_new = FALSE;
+    $this->is_super = $variable === 'super';
+    $this->variable = $this->is_super() ? NULL : $variable;
+    $this->soak = $soak;
+
+    return $this;
+  }
+
+  function compile_node($options)
+  {
+    if ($this->variable)
+    {
+      $this->variable->front = $this->front;
+    }
+
+    if (($code = yy_Splat::compile_splatted_array($options, $this->args, TRUE)))
+    {
+      return $this->compile_splat($options, $code);
+    }
+
+    $args = $this->filter_implicit_objects($this->args);
+    $tmp = array();
+
+    foreach ($args as $arg)
+    {
+      $tmp[] = $arg->compile($options, LEVEL_LIST);
+    }
+
+    $args = implode(', ', $tmp);
+
+    if ($this->is_super())
+    {
+      return $this->super_reference($options).'.call(this'.($args ? ', '.$args : '').')';
+    }
+    else
+    {
+      return ($this->is_new() ? 'new ' : '').$this->variable->compile($options, LEVEL_ACCESS)."({$args})";
+    }
+  }
+
+  function compile_super($args, $options)
+  {
+    return $this->super_reference($options).'.call(this'.(count($args) ? ', ' : '').$args.')';
+  }
+
+  function compile_splat($options, $splat_args)
+  {
+    if ($this->is_super())
+    {
+      return $this->super_reference($options).'.apply(this, '.$splat_args.')';
+    }
+
+    if ($this->is_new())
+    {
+      $idt = $this->tab.TAB;
+
+      return
+        "(function(func, args, ctor) {\n"
+      . "{$idt}ctor.prototype = func.prototype;\n"
+      . "{$idt}var child = new ctor, result = func.apply(child, args), t = typeof result;\n"
+      . "{$idt}return t == \"object\" || t == \"function\" ? result || child : child;\n"
+      . "{$this->tab}})(".$this->variable->compile($options, LEVEL_LIST).", $splat_args, function(){})";
+    }
+
+    $base = yy('Value', $this->variable);
+
+    if (($name = array_pop($base->properties)) && $base->is_complex())
+    {
+      $ref = $options['scope']->free_variable('ref');
+      $fun = "($ref = ".$base->compile($options, LEVEL_LIST).')'.$name->compile($options).'';
+    }
+    else
+    {
+      $fun = $base->compile($options, LEVEL_ACCESS);
+      $fun = preg_match(SIMPLENUM, $fun) ? "($fun)" : $fun;
+
+      if ($name)
+      {
+        $ref = $fun;
+        $fun .= $name->compile($options);
+      }
+      else
+      {
+        $ref = NULL;
+      }
+    }
+
+    $ref = $ref === NULL ? 'null' : $ref;
+
+    return "{$fun}.apply({$ref}, {$splat_args})";
+  }
+
+  function is_new($set = NULL)
+  {
+    if ($set !== NULL)
+    {
+      $this->is_new = !! $set;
+    }
+
+    return $this->is_new;
+  }
+
+  function is_super()
+  {
+    return $this->is_super;
+  }
+
+  function filter_implicit_objects($list)
+  {
+    $nodes = array();
+
+    foreach ($list as $node)
+    {
+      if ( ! ($node->is_object() && $node->base->generated))
+      {
+        $nodes[] = $node;
+        continue;
+      }
+
+      $obj = NULL;
+
+      foreach ($node->base->properties as $prop)
+      {
+        if (($prop instanceof yy_Assign) || $prop instanceof yy_Comment)
+        {
+          if ( ! $obj)
+          {
+            $nodes[] = ($obj = yy('Obj', array(), TRUE));
+          }
+
+          $obj->properties[] = $prop;
+        }
+        else
+        {
+          $nodes[] = $prop;
+          $obj = NULL;
+        }
+      }
+    }
+
+    return $nodes;
+  }
+
+  function new_instance()
+  {
+    $base = isset($this->variable->base) ? $this->variable->base : $this->variable;
+
+    if (($base instanceof yy_Call) && ! $base->is_new())
+    {
+      $base->new_instance();
+    }
+    else
+    {
+      $this->is_new = TRUE;
+    }
+
+    return $this;
+  }
+
+  function super_reference($options)
+  {
+    $method = $options['scope']->method;
+
+    if ($method === NULL)
+    {
+      throw new SyntaxError('cannot call super outside of a function.');
+    }
+
+    $name = isset($method->name) ? $method->name : NULL;
+
+    if ($name === NULL)
+    {
+      throw new SyntaxError('cannot call super on an anonymous function.');
+    }
+
+    if (isset($method->klass) && $method->klass)
+    {
+      $accesses = array(yy('Access', yy('Literal', '__super__')));
+
+      if (isset($method->static) && $method->static)
+      {
+        $accesses[] = yy('Access', yy('Literal', 'constructor'));
+      }
+
+      $accesses[] = yy('Access', yy('Literal', $name));
+
+      return yy('Value', yy('Literal', $method->klass), $accesses)->compile($options);
+    }
+    else
+    {
+      return $name.'.__super__.constructor';
+    }
+  }
+
+  function unfold_soak($options = NULL)
+  {
+    if ($this->soak)
+    {
+      if ($this->variable)
+      {
+        if ($ifn = unfold_soak($options, $this, 'variable'))
+        {
+          return $ifn;
+        }
+
+        $tmp = yy('Value', $this->variable);
+        list($left, $rite) = $tmp->cache_reference($options);
+      }
+      else
+      {
+        $left = yy('Literal', $this->super_reference($options));
+        $rite = yy('Value', $left);
+      }
+
+      $rite = yy('Call', $rite, $this->args);
+      $rite->is_new($this->is_new());
+      $left = yy('Literal', 'typeof '.$left->compile($options).' === "function"');
+
+      return yy('If', $left, yy('Value', $rite), array('soak' => TRUE));
+    }
+
+    $call = $this;
+    $list = array();
+
+    while (TRUE)
+    {
+      if ($call->variable instanceof yy_Call)
+      {
+        $list[] = $call;
+        $call = $call->variable;
+
+        continue;
+      }
+
+      if ( ! ($call->variable instanceof yy_Value))
+      {
+        break;
+      }
+
+      $list[] = $call;
+
+      if ( ! (($call = $call->variable->base) instanceof yy_Call))
+      {
+        break;
+      }
+    }
+
+    foreach (array_reverse($list) as $call)
+    {
+      if (isset($ifn))
+      {
+        if ($call->variable instanceof yy_Call)
+        {
+          $call->variable = $ifn;
+        }
+        else
+        {
+          $call->variable->base = $ifn;
+        }
+      }
+
+      $ifn = unfold_soak($options, $call, 'variable');
+    }
+
+    return isset($ifn) ? $ifn : NULL;
+  }
+}
+
+?>

data/vendor/coffeescript/coffeescript/src/CoffeeScript/yy/Class.php

@@ -0,0 +1,282 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Class extends yy_Base
+{
+  public $children = array('variable', 'parent', 'body');
+
+  function constructor($variable = NULL, $parent = NULL, $body = NULL)
+  {
+    $this->variable = $variable;
+    $this->parent = $parent;
+
+    $this->body = $body === NULL ? yy('Block') : $body;
+    $this->body->class_body = TRUE;
+
+    $this->bound_funcs = array();
+
+    return $this;
+  }
+
+  function add_bound_functions($options)
+  {
+    if ($this->bound_funcs)
+    {
+      foreach ($this->bound_funcs as $bvar)
+      {
+        $lhs = yy('Value', yy('Literal', 'this'), array(yy('Access', $bvar)))->compile($options);
+        $this->ctor->body->unshift(yy('Literal', "{$lhs} = ".utility('bind')."({$lhs}, this)"));
+      }
+    }
+  }
+
+  function add_properties($node, $name, $options)
+  {
+    $props = array_slice($node->base->properties, 0);
+    $exprs = array();
+
+    while ($assign = array_shift($props))
+    {
+      if ($assign instanceof yy_Assign)
+      {
+        $base = $assign->variable->base;
+        $func = $assign->value;
+
+        $assign->context = NULL;
+
+        if ($base->value === 'constructor')
+        {
+          if ($this->ctor)
+          {
+            throw new Error('cannot define more than one constructor in a class');
+          }
+
+          if (isset($func->bound) && $func->bound)
+          {
+            throw new Error('cannot define a constructor as a bound functions');
+          }
+
+          if ($func instanceof yy_Code)
+          {
+            $assign = $this->ctor = $func;
+          }
+          else
+          {
+            $this->external_ctor = $options['scope']->free_variable('class');
+            $assign = yy('Assign', yy('Literal', $this->external_ctor), $func);
+          }
+        }
+        else
+        {
+          if (isset($assign->variable->this) && $assign->variable->this)
+          {
+            $func->static = TRUE;
+
+            if (isset($func->bound) && $func->bound)
+            {
+              $func->context = $name;
+            }
+          }
+          else
+          {
+            $assign->variable = yy('Value', yy('Literal', $name), array( yy('Access', yy('Literal', 'prototype')), yy('Access', $base) ));
+
+            if ($func instanceof yy_Code && isset($func->bound) && $func->bound)
+            {
+              $this->bound_funcs[] = $base;
+              $func->bound = FALSE;
+            }
+          }
+        }
+      }
+
+      $exprs[] = $assign;
+    }
+
+    return compact($exprs);
+  }
+
+  function compile_node($options)
+  {
+    $decl = $this->determine_name();
+
+    $name = $decl ? $decl : '_Class';
+
+    if (isset($name->reserved) && $name->reserved)
+    {
+      $name = '_'.$name;
+    }
+
+    $lname = yy('Literal', $name);
+
+    $this->hoist_directive_prologue();
+    $this->set_context($name);
+    $this->walk_body($name, $options);
+    $this->ensure_constructor($name);
+    $this->body->spaced = TRUE;
+
+    if ( ! ($this->ctor instanceof yy_Code))
+    {
+      array_unshift($this->body->expressions, $this->ctor);
+    }
+
+    if ($decl)
+    {
+      array_unshift($this->body->expressions, yy('Assign', yy('Value', yy('Literal', $name), array(yy('Access', yy('Literal', 'name')))), yy('Literal', "'{$name}'")));
+    }
+
+    $this->body->expressions[] = $lname;
+    $this->body->expressions = array_merge($this->directives, $this->body->expressions);
+
+    $this->add_bound_functions($options);
+
+    $call = yy_Closure::wrap($this->body);
+
+    if ($this->parent)
+    {
+      $this->super_class = yy('Literal', $options['scope']->free_variable('super', FALSE));
+      array_unshift($this->body->expressions, yy('Extends', $lname, $this->super_class));
+      $call->args[] = $this->parent;
+
+      if (isset($call->variable->params))
+      {
+        $params = & $call->variable->params;
+      }
+      else
+      {
+        $params = & $call->variable->base->params;
+      }
+
+      $params[] = yy('Param', $this->super_class);
+    }
+
+    $klass = yy('Parens', $call, TRUE);
+
+    if ($this->variable)
+    {
+      $klass = yy('Assign', $this->variable, $klass);
+    }
+
+    return $klass->compile($options);
+  }
+
+  function determine_name()
+  {
+    if ( ! (isset($this->variable) && $this->variable))
+    {
+      return NULL;
+    }
+
+    if (($tail = last($this->variable->properties)))
+    {
+      $decl = $tail instanceof yy_Access ? $tail->name->value : NULL;
+    }
+    else
+    {
+      $decl = $this->variable->base->value;
+    }
+
+    if (in_array($decl, Lexer::$STRICT_PROSCRIBED, TRUE))
+    {
+      throw new SyntaxError("variable name may not be $decl");
+    }
+
+    $decl = $decl ? (preg_match(IDENTIFIER, $decl) ? $decl : NULL) : NULL;
+
+    return $decl;
+  }
+
+  function ensure_constructor($name)
+  {
+    if ( ! (isset($this->ctor) && $this->ctor))
+    {
+      $this->ctor = yy('Code');
+
+      if ($this->parent)
+      {
+        $this->ctor->body->push(yy('Literal', "{$name}.__super__.constructor.apply(this, arguments)"));
+      }
+
+      if (isset($this->external_ctor) && $this->external_ctor)
+      {
+        $this->ctor->body->push(yy('Literal', "{$this->external_ctor}.apply(this, arguments)"));
+      }
+
+      $this->ctor->body->make_return();
+
+      array_unshift($this->body->expressions, $this->ctor);
+    }
+
+    $this->ctor->ctor = $this->ctor->name = $name;
+
+    $this->ctor->klass = NULL;
+    $this->ctor->no_return = TRUE;
+  }
+
+  function hoist_directive_prologue()
+  {
+    $index = 0;
+    $expressions = $this->body->expressions;
+
+    while (isset($expressions[$index]) && ($node = $expressions[$index]) && ( ($node instanceof yy_Comment) || ($node instanceof yy_Value) && $node->is_string() ))
+    {
+      $index++;
+    }
+
+    $this->directives = array_slice($expressions, 0, $index);
+  }
+
+  function set_context($name)
+  {
+    $this->body->traverse_children(FALSE, function($node) use ($name)
+    {
+      if (isset($node->class_body) && $node->class_body)
+      {
+        return FALSE;
+      }
+
+      if ($node instanceof yy_Literal && ''.$node->value === 'this')
+      {
+        $node->value = $name;
+      }
+      else if ($node instanceof yy_Code)
+      {
+        $node->klass = $name;
+
+        if ($node->bound)
+        {
+          $node->context = $name;
+        }
+      }
+    });
+  }
+
+  function walk_body($name, $options)
+  {
+    $self = $this;
+
+    $this->traverse_children(FALSE, function($child) use ($name, $options, & $self)
+    {
+      if ($child instanceof yy_Class)
+      {
+        return FALSE;
+      }
+
+      if ($child instanceof yy_Block)
+      {
+        foreach (($exps = $child->expressions) as $i => $node)
+        {
+          if ($node instanceof yy_Value && $node->is_object(TRUE))
+          {
+            $exps[$i] = $self->add_properties($node, $name, $options);
+          }
+        }
+
+        $child->expressions = $exps = flatten($exps);
+      }
+    });
+  }
+}
+
+?>