guard-mthaml 0.1.0

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

@@ -0,0 +1,37 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Throw extends yy_Base
+{
+  public $children = array('expression');
+
+  function constructor($expression)
+  {
+    $this->expression = $expression;
+
+    return $this;
+  }
+
+  function compile_node($options = array())
+  {
+    return $this->tab.'throw '.$this->expression->compile($options).';';
+  }
+
+  function is_statement($options = NULL)
+  {
+    return TRUE;
+  }
+
+  function jumps()
+  {
+    return FALSE;
+  }
+
+  function make_return($res = NULL)
+  {
+    return $this;
+  }
+}
+
+?>

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

@@ -0,0 +1,79 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Try extends yy_Base
+{
+  public $children = array('attempt', 'recovery', 'ensure');
+
+  function constructor($attempt = NULL, $error = NULL, $recovery = NULL, $ensure = NULL)
+  {
+    $this->attempt = $attempt;
+    $this->error = $error;
+    $this->recovery = $recovery;
+    $this->ensure = $ensure;
+
+    return $this;
+  }
+
+  function compile_node($options = array())
+  {
+    $options['indent'] .= TAB;
+    $error_part = $this->error ? ' ('.$this->error->compile($options).') ' : ' ';
+    $try_part = $this->attempt->compile($options, LEVEL_TOP);
+    $catch_part = '';
+
+    if ($this->recovery)
+    {
+      if (in_array($this->error, Lexer::$STRICT_PROSCRIBED))
+      {
+        throw new SyntaxError('catch variable may not be "'.$this->error->value.'"');
+      }
+
+      if ( ! $options['scope']->check($this->error->value))
+      {
+        $options['scope']->add($this->error->value, 'param');
+      }
+
+      $catch_part = " catch{$error_part}{\n".$this->recovery->compile($options, LEVEL_TOP)."\n{$this->tab}}";
+    }
+    else if ( ! ($this->ensure || $this->recovery))
+    {
+      $catch_part = ' catch (_error) {}';
+    }
+
+    $ensure_part = isset($this->ensure) && $this->ensure ? " finally {\n".$this->ensure->compile($options, LEVEL_TOP)."\n{$this->tab}}" : '';
+
+    return
+      "{$this->tab}try {\n"
+    . $try_part."\n"
+    . "{$this->tab}}{$catch_part}{$ensure_part}";
+  }
+
+  function is_statement($options = NULL)
+  {
+    return TRUE;
+  }
+
+  function jumps($options = array())
+  {
+    return $this->attempt->jumps($options) || (isset($this->recovery) && $this->recovery->jumps($options));
+  }
+
+  function make_return($res = NULL)
+  {
+    if ($this->attempt)
+    {
+      $this->attempt = $this->attempt->make_return($res);
+    }
+
+    if ($this->recovery)
+    {
+      $this->recovery = $this->recovery->make_return($res);
+    }
+
+    return $this;
+  }
+}
+
+?>

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

@@ -0,0 +1,210 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Value extends yy_Base
+{
+  public $children = array('base', 'properties');
+
+  function constructor($base = NULL, $props = NULL, $tag = NULL)
+  {
+    if ( ! $props && $base instanceof yy_Value)
+    {
+      return $base;
+    }
+
+    $this->base = $base;
+    $this->properties = $props ? $props : array();
+
+    if ($tag)
+    {
+      $this->{$tag} = TRUE;
+    }
+
+    return $this;
+  }
+
+  function add($prop)
+  {
+    $this->properties = array_merge($this->properties, is_object($prop) ? array($prop) : (array) $prop);
+
+    return $this;
+  }
+
+  function assigns($name)
+  {
+    return ! count($this->properties) && $this->base->assigns($name);
+  }
+
+  function cache_reference($options)
+  {
+    $name = last($this->properties);
+
+    if (count($this->properties) < 2 && ! $this->base->is_complex() && ! ($name && $name->is_complex()))
+    {
+      return array($this, $this);
+    }
+
+    $base = yy('Value', $this->base, array_slice($this->properties, 0, -1));
+    $bref = NULL;
+
+    if ($base->is_complex())
+    {
+      $bref = yy('Literal', $options['scope']->free_variable('base'));
+      $base = yy('Value', yy('Parens', yy('Assign', $bref, $base)));
+    }
+
+    if ( ! $name)
+    {
+      return array($base, $bref);
+    }
+
+    if ($name->is_complex())
+    {
+      $nref = yy('Literal', $options['scope']->free_variable('name'));
+      $name = yy('Index', yy('Assign', $nref, $name->index));
+      $nref = yy('Index', $nref);
+    }
+
+    $base->add($name);
+
+    return array($base, yy('Value', isset($bref) ? $bref : $base->base, array(isset($nref) ? $nref : $name)));
+  }
+
+  function compile_node($options)
+  {
+    $this->base->front = $this->front;
+    $props = $this->properties;
+
+    $code = $this->base->compile($options, count($props) ? LEVEL_ACCESS : NULL);
+
+    if ( (($this->base instanceof yy_Parens) || count($props)) && preg_match(SIMPLENUM, $code))
+    {
+      $code = $code.'.';
+    }
+
+    foreach ($props as $prop)
+    {
+      $code .= $prop->compile($options);
+    }
+
+    return $code;
+  }
+
+  function has_properties()
+  {
+    return !! count($this->properties);
+  }
+
+  function is_array()
+  {
+    return ! count($this->properties) && $this->base instanceof yy_Arr;
+  }
+
+  function is_assignable()
+  {
+    return $this->has_properties() || $this->base->is_assignable();
+  }
+
+  function is_atomic()
+  {
+    foreach (array_merge($this->properties, array($this->base)) as $node)
+    {
+      if ((isset($node->soak) && $node->soak) || $node instanceof yy_Call)
+      {
+        return FALSE;
+      }
+    }
+
+    return TRUE;
+  }
+
+  function is_complex()
+  {
+    return $this->has_properties() || $this->base->is_complex();
+  }
+
+  function is_object($only_generated = FALSE)
+  {
+    if (count($this->properties))
+    {
+      return FALSE;
+    }
+
+    return ($this->base instanceof yy_Obj) && ( ! $only_generated || $this->base->generated);
+  }
+
+  function is_simple_number()
+  {
+    return ($this->base instanceof yy_Literal) && preg_match(SIMPLENUM, ''.$this->base->value);
+  }
+
+  function is_splice()
+  {
+    return last($this->properties) instanceof yy_Slice;
+  }
+
+  function is_string()
+  {
+    return ($this->base instanceof yy_Literal) && preg_match(IS_STRING, ''.$this->base->value);
+  }
+
+  function is_statement($options = NULL)
+  {
+    return ! count($this->properties) && $this->base->is_statement($options);
+  }
+
+  function jumps($options = array())
+  {
+    return ! count($this->properties) && $this->base->jumps($options);
+  }
+
+  function unfold_soak($options = NULL)
+  {
+    if (isset($this->unfolded_soak))
+    {
+      return $this->unfolded_soak;
+    }
+
+    if (($ifn = $this->base->unfold_soak($options)))
+    {
+      $ifn->body->properties = array_merge($ifn->body->properties, $this->properties);
+      $result = $ifn;
+    }
+    else
+    {
+      foreach ($this->properties as $i => $prop)
+      {
+        if (isset($prop->soak) && $prop->soak)
+        {
+          $prop->soak = FALSE;
+
+          $fst = yy('Value', $this->base, array_slice($this->properties, 0, $i));
+          $snd = yy('Value', $this->base, array_slice($this->properties, $i));
+
+          if ($fst->is_complex())
+          {
+            $ref = yy('Literal', $options['scope']->free_variable('ref'));
+            $fst = yy('Parens', yy('Assign', $ref, $fst));
+            $snd->base = $ref;
+          }
+
+          $result = yy('If', yy('Existence', $fst), $snd, array('soak' => TRUE));
+
+          break;
+        }
+      }
+    }
+
+    $this->unfolded_soak = isset($result) ? $result : FALSE;
+
+    return $this->unfolded_soak;
+  }
+
+  function unwrap()
+  {
+    return count($this->properties) ? $this : $this->base;
+  }
+}
+
+?>

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

@@ -0,0 +1,112 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_While extends yy_Base
+{
+  public $children = array('condition', 'guard', 'body');
+
+  public $returns = FALSE;
+
+  function constructor()
+  {
+    list($condition, $options) = args(func_get_args(), 0, array(NULL, NULL));
+
+    $this->condition = (isset($options['invert']) && $options['invert']) ? 
+      $condition->invert() : $condition;
+
+    $this->guard = isset($options['guard']) ? $options['guard'] : NULL;
+
+    return $this;
+  }
+
+  function add_body($body)
+  {
+    $this->body = $body;
+    return $this;
+  }
+
+  function compile_node($options)
+  {
+    $options['indent'] .= TAB;
+    $set = '';
+    $body = $this->body;
+
+    if ($body->is_empty())
+    {
+      $body = '';
+    }
+    else
+    {
+      if ($this->returns)
+      {
+        $body->make_return($rvar = $options['scope']->free_variable('results'));
+        $set = "{$this->tab}{$rvar} = [];\n";
+      }
+
+      if ($this->guard)
+      {
+        if (count($body->expressions) > 1)
+        {
+          array_unshift($body->expressions, yy('If', yy('Parens', $this->guard)->invert(), yy('Literal', 'continue')));
+        }
+        else
+        {
+          $body = yy_Block::wrap(array(yy('If', $this->guard, $body)));
+        }
+      }
+
+      $body = "\n".$body->compile($options, LEVEL_TOP)."\n{$this->tab}";
+    }
+
+    $code = $set.$this->tab.'while ('.$this->condition->compile($options, LEVEL_PAREN).") {{$body}}";
+
+    if ($this->returns)
+    {
+      $code .= "\n{$this->tab}return {$rvar};";
+    }
+
+    return $code;
+  }
+
+  function is_statement($options = NULL)
+  {
+    return TRUE;
+  }
+
+  function jumps()
+  {
+    $expressions = isset($this->body->expressions) ? $this->body->expressions : array();
+
+    if ( ! count($expressions))
+    {
+      return FALSE;
+    }
+
+    foreach ($expressions as $node)
+    {
+      if ($node->jumps(array('loop' => TRUE)))
+      {
+        return $node;
+      }
+    }
+
+    return FALSE;
+  }
+
+  function make_return($res = NULL)
+  {
+    if ($res)
+    {
+      return parent::make_return($res);
+    }
+    else
+    {
+      $this->returns = ! $this->jumps(array('loop' => TRUE));
+    }
+
+    return $this;
+  }
+}
+
+?>

data/vendor/coffeescript/coffeescript/tests/cases/arrays.coffee

@@ -0,0 +1,77 @@
+# Array Literals
+# --------------
+
+# * Array Literals
+# * Splats in Array Literals
+
+# TODO: add indexing and method invocation tests: [1][0] is 1, [].toString()
+
+test "trailing commas", ->
+  trailingComma = [1, 2, 3,]
+  ok (trailingComma[0] is 1) and (trailingComma[2] is 3) and (trailingComma.length is 3)
+
+  trailingComma = [
+    1, 2, 3,
+    4, 5, 6
+    7, 8, 9,
+  ]
+  (sum = (sum or 0) + n) for n in trailingComma
+
+  a = [((x) -> x), ((x) -> x * x)]
+  ok a.length is 2
+
+test "incorrect indentation without commas", ->
+  result = [['a']
+   {b: 'c'}]
+  ok result[0][0] is 'a'
+  ok result[1]['b'] is 'c'
+
+
+# Splats in Array Literals
+
+test "array splat expansions with assignments", ->
+  nums = [1, 2, 3]
+  list = [a = 0, nums..., b = 4]
+  eq 0, a
+  eq 4, b
+  arrayEq [0,1,2,3,4], list
+
+
+test "mixed shorthand objects in array lists", ->
+
+  arr = [
+    a:1
+    'b'
+    c:1
+  ]
+  ok arr.length is 3
+  ok arr[2].c is 1
+
+  arr = [b: 1, a: 2, 100]
+  eq arr[1], 100
+
+  arr = [a:0, b:1, (1 + 1)]
+  eq arr[1], 2
+
+  arr = [a:1, 'a', b:1, 'b']
+  eq arr.length, 4
+  eq arr[2].b, 1
+  eq arr[3], 'b'
+
+
+test "array splats with nested arrays", ->
+  nonce = {}
+  a = [nonce]
+  list = [1, 2, a...]
+  eq list[0], 1
+  eq list[2], nonce
+
+  a = [[nonce]]
+  list = [1, 2, a...]
+  arrayEq list, [1, 2, [nonce]]
+
+test "#1274: `[] = a()` compiles to `false` instead of `a()`", ->
+  a = false
+  fn = -> a = true
+  [] = fn()
+  ok a