guard-mthaml 0.1.0

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

@@ -0,0 +1,292 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Op extends yy_Base
+{
+  static $CONVERSIONS = array(
+    '==' => '===',
+    '!=' => '!==',
+    'of' => 'in'
+  );
+
+  static $INVERSIONS = array(
+    '!==' => '===',
+    '===' => '!=='
+  );
+
+  public $children = array('first', 'second');
+
+  public $operator = NULL;
+
+  public $invert = TRUE;
+
+  function constructor($op, $first, $second = NULL, $flip = NULL)
+  {
+    if ($op === 'in')
+    {
+      return yy('In', $first, $second);
+    }
+
+    if ($op === 'do')
+    {
+      return $this->generate_do($first);
+    }
+
+    if ($op === 'new')
+    {
+      if ($first instanceof yy_Call && ! (isset($first->do) && $first->do) && ! (isset($first->is_new) && $first->is_new))
+      {
+        return $first->new_instance();
+      }
+
+      if ($first instanceof yy_Code && $first->bound || (isset($first->do) && $first->do))
+      {
+        $first = yy('Parens', $first);
+      }
+    }
+
+    $this->operator = isset(self::$CONVERSIONS[$op]) ? self::$CONVERSIONS[$op] : $op;
+    $this->first = $first;
+    $this->second = $second;
+    $this->flip = !! $flip;
+
+    return $this;
+  }
+
+  function compile_chain($options)
+  {
+    $tmp = $this->first->second->cache($options);
+
+    $this->first->second = $tmp[0];
+    $shared = $tmp[1];
+
+    $fst = $this->first->compile($options, LEVEL_OP);
+
+    $code = "{$fst} ".($this->invert ? '&&' : '||').' '.$shared->compile($options).' '
+      .$this->operator.' '.$this->second->compile($options, LEVEL_OP);
+
+    return "({$code})";
+  }
+
+  function compile_existence($options)
+  {
+    if ($this->first->is_complex() && $options['level'] > LEVEL_TOP)
+    {
+      $ref = yy('Literal', $options['scope']->free_variable('ref'));
+      $fst = yy('Parens', yy('Assign', $ref, $this->first));
+    }
+    else
+    {
+      $fst = $this->first;
+      $ref = $fst;
+    }
+
+    $tmp = yy('If', yy('Existence', $fst), $ref, array('type' => 'if'));
+    $tmp->add_else($this->second);
+
+    return $tmp->compile($options);
+  }
+
+  function compile_node($options, $level = NULL)
+  {
+    $is_chain = $this->is_chainable() && $this->first->is_chainable();
+
+    if ( ! $is_chain)
+    {
+      $this->first->front = $this->front;
+    }
+
+    $tmp = $this->first->unwrap_all();
+    $tmp = isset($tmp->value) ? $tmp->value : NULL;
+
+    if ($this->operator === 'delete' && $options['scope']->check($tmp))
+    {
+      throw new SyntaxError('delete operand may not be argument or var');
+    }
+
+    if (in_array($this->operator, array('--', '++')) && in_array($tmp, Lexer::$STRICT_PROSCRIBED))
+    {
+      throw new SyntaxError('prefix increment/decrement may not have eval or arguments operand');
+    }
+
+    if ($this->is_unary())
+    {
+      return $this->compile_unary($options);
+    }
+
+    if ($is_chain)
+    {
+      return $this->compile_chain($options);
+    }
+
+    if ($this->operator === '?')
+    {
+      return $this->compile_existence($options);
+    }
+
+    $this->first->front = $this->front;
+
+    $code = $this->first->compile($options, LEVEL_OP).' '.$this->operator.' '
+      .$this->second->compile($options, LEVEL_OP);
+
+    return $options['level'] <= LEVEL_OP ? $code : "({$code})";
+  }
+
+  function compile_unary($options)
+  {
+    if ($options['level'] >= LEVEL_ACCESS)
+    {
+      return yy('Parens', $this)->compile($options);
+    }
+
+    $parts = array($op = $this->operator);
+    $plus_minus = in_array($op, array('+', '-'), TRUE);
+
+    if (in_array($op, array('new', 'typeof', 'delete'), TRUE) ||
+        $plus_minus &&
+        $this->first instanceof yy_Op && $this->first->operator === $op)
+    {
+      $parts[] = ' ';
+    }
+
+    if (($plus_minus && $this->first instanceof yy_Op) || ($op === 'new' && $this->first->is_statement($options)))
+    {
+      $this->first = yy('Parens', $this->first);
+    }
+
+    $parts[] = $this->first->compile($options, LEVEL_OP);
+
+    if ($this->flip)
+    {
+      $parts = array_reverse($parts);
+    }
+
+    return implode('', $parts);
+  }
+
+  function is_chainable()
+  {
+    return in_array($this->operator, array('<', '>', '>=', '<=', '===', '!=='), TRUE);
+  }
+
+  function is_complex()
+  {
+    return ! ($this->is_unary() && in_array($this->operator, array('+', '-'))) || $this->first->is_complex();
+  }
+
+  function invert()
+  {
+    if ($this->is_chainable() && $this->first->is_chainable())
+    {
+      $all_invertable = TRUE;
+      $curr = $this;
+
+      while ($curr && (isset($curr->operator) && $curr->operator))
+      {
+        if ($all_invertable)
+        {
+          $all_invertable = isset(self::$INVERSIONS[$curr->operator]);
+        }
+
+        $curr = $curr->first;
+      }
+
+      if ( ! $all_invertable)
+      {
+        return yy('Parens', $this)->invert();
+      }
+
+      $curr = $this;
+
+      while ($curr && (isset($curr->operator) && $curr->operator))
+      {
+        $curr->invert = ! $curr->invert;
+        $curr->operator = self::$INVERSIONS[$curr->operator];
+        $curr = $curr->first;
+      }
+
+      return $this;
+    }
+    else if (isset(self::$INVERSIONS[$this->operator]) && ($op = self::$INVERSIONS[$this->operator]))
+    {
+      $this->operator = $op;
+
+      if ($this->first->unwrap() instanceof yy_Op)
+      {
+        $this->first->invert();
+      }
+
+      return $this;
+    }
+    else if ($this->second)
+    {
+      return yy('Parens', $this)->invert();
+    }
+    else if ($this->operator === '!' && (($fst = $this->first->unwrap()) instanceof yy_Op) &&
+      in_array($fst->operator, array('!', 'in', 'instanceof'), TRUE))
+    {
+      return $fst;
+    }
+    else
+    {
+      return yy('Op', '!', $this);
+    }
+  }
+
+  function generate_do($exp)
+  {
+    $passed_params = array();
+    $func = $exp;
+
+    if ($exp instanceof yy_Assign && ($ref = $exp->value->unwrap()) instanceof yy_Code)
+    {
+      $func = $ref;
+    }
+
+    foreach ((isset($func->params) && $func->params ? $func->params : array()) as $param)
+    {
+      if (isset($param->value) && $param->value)
+      {
+        $passed_params[] = $param->value;
+        unset($param->value);
+      }
+      else
+      {
+        $passed_params[] = $param;
+      }
+    }
+
+    $call = yy('Call', $exp, $passed_params);
+    $call->do = TRUE;
+
+    return $call;
+  }
+
+  function is_simple_number()
+  {
+    return FALSE;
+  }
+
+  function is_unary()
+  {
+    return ! (isset($this->second) && $this->second);
+  }
+
+  function unfold_soak($options = NULL)
+  {
+    if (in_array($this->operator, array('++', '--', 'delete'), TRUE))
+    {
+      return unfold_soak($options, $this, 'first');
+    }
+
+    return NULL;
+  }
+
+  function to_string($idt = '', $name = __CLASS__)
+  {
+    return parent::to_string($idt, $name.' '.$this->operator);
+  }
+}
+
+?>

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

@@ -0,0 +1,119 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Param extends yy_Base
+{
+  public $children = array('name', 'value');
+
+  function constructor($name, $value = NULL, $splat = NULL)
+  {
+    $this->name = $name;
+    $this->value = $value;
+    $this->splat = $splat;
+
+    $name = $this->name->unwrap_all();
+    $name = isset($name->value) ? $name->value : NULL;
+
+    if (in_array($name, Lexer::$STRICT_PROSCRIBED))
+    {
+      throw new SyntaxError("parameter name \"$name\" is not allowed");
+    }
+
+    return $this;
+  }
+
+  function as_reference($options)
+  {
+    if (isset($this->reference) && $this->reference)
+    {
+      return $this->reference;
+    }
+
+    $node = $this->name;
+
+    if (isset($node->this) && $node->this)
+    {
+      $node = $node->properties[0]->name;
+
+      if (isset($this->value->reserved) && $this->value->reserved)
+      {
+        $node = yy('Literal', $options['scope']->free_variable($node->value));
+      }
+    }
+    else if ($node->is_complex())
+    {
+      $node = yy('Literal', $options['scope']->free_variable('arg'));
+    }
+
+    $node = yy('Value', $node);
+
+    if ($this->splat)
+    {
+      $node = yy('Splat', $node);
+    }
+
+    return ($this->reference = $node);
+  }
+
+  function compile($options, $level = NULL)
+  {
+    return $this->name->compile($options, LEVEL_LIST);
+  }
+
+  function is_complex()
+  {
+    return $this->name->is_complex();
+  }
+
+  function names($name = NULL)
+  {
+    if ($name === NULL)
+    {
+      $name = $this->name;
+    }
+
+    $at_param = function($obj)
+    {
+      $value = $obj->properties[0]->name;
+
+      return isset($value->reserved) && $value->reserved ? array() : array($value);
+    };
+
+    if ($name instanceof yy_Literal)
+    {
+      return array($name->value);
+    }
+
+    if ($name instanceof yy_Value)
+    {
+      return $at_param($name);
+    }
+
+    $names = array();
+
+    foreach ($name->objects as $obj)
+    {
+      if ($obj instanceof yy_Assign)
+      {
+        $names[] = $obj->variable->base->value;
+      }
+      else if ($obj->is_array() || $obj->is_object())
+      {
+        $names = array_merge($names, (array) $this->names($obj->base));
+      }
+      else if (isset($obj->this) && $obj->this)
+      {
+        $names = array_merge($names, (array) $at_param($obj));
+      }
+      else
+      {
+        $names[] = $obj->base->value;
+      }
+    }
+
+    return $names;
+  }
+}
+
+?>

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

@@ -0,0 +1,45 @@
+<?php
+
+namespace CoffeeScript;
+
+class yy_Parens extends yy_Base
+{
+  public $children = array('body');
+
+  function constructor($body)
+  {
+    $this->body = $body;
+
+    return $this;
+  }
+
+  function compile_node($options = array())
+  {
+    $expr = $this->body->unwrap();
+
+    if ($expr instanceof yy_Value && $expr->is_atomic())
+    {
+      $expr->front = $this->front;
+      return $expr->compile($options);
+    }
+
+    $code = $expr->compile($options, LEVEL_PAREN);
+
+    $bare = $options['level'] < LEVEL_OP && ($expr instanceof yy_Op || $expr instanceof yy_Call ||
+      ($expr instanceof yy_For && $expr->returns));
+
+    return $bare ? $code : "({$code})";
+  }
+
+  function is_complex()
+  {
+    return $this->body->is_complex();
+  }
+
+  function unwrap()
+  {
+    return $this->body;
+  }
+}
+
+?>