[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  class Less_Tree_Mixin_Definition extends Less_Tree_Ruleset{
   4      public $name;
   5      public $selectors;
   6      public $params;
   7      public $arity        = 0;
   8      public $rules;
   9      public $lookups        = array();
  10      public $required    = 0;
  11      public $frames        = array();
  12      public $condition;
  13      public $variadic;
  14      public $type        = 'MixinDefinition';
  15  
  16  
  17      // less.js : /lib/less/tree/mixin.js : tree.mixin.Definition
  18  	public function __construct($name, $params, $rules, $condition, $variadic = false, $frames = array() ){
  19          $this->name = $name;
  20          $this->selectors = array(new Less_Tree_Selector(array( new Less_Tree_Element(null, $name))));
  21  
  22          $this->params = $params;
  23          $this->condition = $condition;
  24          $this->variadic = $variadic;
  25          $this->rules = $rules;
  26  
  27          if( $params ){
  28              $this->arity = count($params);
  29              foreach( $params as $p ){
  30                  if (! isset($p['name']) || ($p['name'] && !isset($p['value']))) {
  31                      $this->required++;
  32                  }
  33              }
  34          }
  35  
  36          $this->frames = $frames;
  37          $this->SetRulesetIndex();
  38      }
  39  
  40  
  41  
  42      //function accept( $visitor ){
  43      //    $this->params = $visitor->visit($this->params);
  44      //    $this->rules = $visitor->visit($this->rules);
  45      //    $this->condition = $visitor->visit($this->condition);
  46      //}
  47  
  48  
  49  	public function toCSS(){
  50          return '';
  51      }
  52  
  53      // less.js : /lib/less/tree/mixin.js : tree.mixin.Definition.evalParams
  54  	public function compileParams($env, $mixinFrames, $args = array() , &$evaldArguments = array() ){
  55          $frame = new Less_Tree_Ruleset(null, array());
  56          $params = $this->params;
  57          $mixinEnv = null;
  58          $argsLength = 0;
  59  
  60          if( $args ){
  61              $argsLength = count($args);
  62              for($i = 0; $i < $argsLength; $i++ ){
  63                  $arg = $args[$i];
  64  
  65                  if( $arg && $arg['name'] ){
  66                      $isNamedFound = false;
  67  
  68                      foreach($params as $j => $param){
  69                          if( !isset($evaldArguments[$j]) && $arg['name'] === $params[$j]['name']) {
  70                              $evaldArguments[$j] = $arg['value']->compile($env);
  71                              array_unshift($frame->rules, new Less_Tree_Rule( $arg['name'], $arg['value']->compile($env) ) );
  72                              $isNamedFound = true;
  73                              break;
  74                          }
  75                      }
  76                      if ($isNamedFound) {
  77                          array_splice($args, $i, 1);
  78                          $i--;
  79                          $argsLength--;
  80                          continue;
  81                      } else {
  82                          throw new Less_Exception_Compiler("Named argument for " . $this->name .' '.$args[$i]['name'] . ' not found');
  83                      }
  84                  }
  85              }
  86          }
  87  
  88          $argIndex = 0;
  89          foreach($params as $i => $param){
  90  
  91              if ( isset($evaldArguments[$i]) ){ continue; }
  92  
  93              $arg = null;
  94              if( isset($args[$argIndex]) ){
  95                  $arg = $args[$argIndex];
  96              }
  97  
  98              if (isset($param['name']) && $param['name']) {
  99  
 100                  if( isset($param['variadic']) ){
 101                      $varargs = array();
 102                      for ($j = $argIndex; $j < $argsLength; $j++) {
 103                          $varargs[] = $args[$j]['value']->compile($env);
 104                      }
 105                      $expression = new Less_Tree_Expression($varargs);
 106                      array_unshift($frame->rules, new Less_Tree_Rule($param['name'], $expression->compile($env)));
 107                  }else{
 108                      $val = ($arg && $arg['value']) ? $arg['value'] : false;
 109  
 110                      if ($val) {
 111                          $val = $val->compile($env);
 112                      } else if ( isset($param['value']) ) {
 113  
 114                          if( !$mixinEnv ){
 115                              $mixinEnv = new Less_Environment();
 116                              $mixinEnv->frames = array_merge( array($frame), $mixinFrames);
 117                          }
 118  
 119                          $val = $param['value']->compile($mixinEnv);
 120                          $frame->resetCache();
 121                      } else {
 122                          throw new Less_Exception_Compiler("Wrong number of arguments for " . $this->name . " (" . $argsLength . ' for ' . $this->arity . ")");
 123                      }
 124  
 125                      array_unshift($frame->rules, new Less_Tree_Rule($param['name'], $val));
 126                      $evaldArguments[$i] = $val;
 127                  }
 128              }
 129  
 130              if ( isset($param['variadic']) && $args) {
 131                  for ($j = $argIndex; $j < $argsLength; $j++) {
 132                      $evaldArguments[$j] = $args[$j]['value']->compile($env);
 133                  }
 134              }
 135              $argIndex++;
 136          }
 137  
 138          ksort($evaldArguments);
 139          $evaldArguments = array_values($evaldArguments);
 140  
 141          return $frame;
 142      }
 143  
 144  	public function compile($env) {
 145          if( $this->frames ){
 146              return new Less_Tree_Mixin_Definition($this->name, $this->params, $this->rules, $this->condition, $this->variadic, $this->frames );
 147          }
 148          return new Less_Tree_Mixin_Definition($this->name, $this->params, $this->rules, $this->condition, $this->variadic, $env->frames );
 149      }
 150  
 151  	public function evalCall($env, $args = NULL, $important = NULL) {
 152  
 153          Less_Environment::$mixin_stack++;
 154  
 155          $_arguments = array();
 156  
 157          if( $this->frames ){
 158              $mixinFrames = array_merge($this->frames, $env->frames);
 159          }else{
 160              $mixinFrames = $env->frames;
 161          }
 162  
 163          $frame = $this->compileParams($env, $mixinFrames, $args, $_arguments);
 164  
 165          $ex = new Less_Tree_Expression($_arguments);
 166          array_unshift($frame->rules, new Less_Tree_Rule('@arguments', $ex->compile($env)));
 167  
 168  
 169          $ruleset = new Less_Tree_Ruleset(null, $this->rules);
 170          $ruleset->originalRuleset = $this->ruleset_id;
 171  
 172  
 173          $ruleSetEnv = new Less_Environment();
 174          $ruleSetEnv->frames = array_merge( array($this, $frame), $mixinFrames );
 175          $ruleset = $ruleset->compile( $ruleSetEnv );
 176  
 177          if( $important ){
 178              $ruleset = $ruleset->makeImportant();
 179          }
 180  
 181          Less_Environment::$mixin_stack--;
 182  
 183          return $ruleset;
 184      }
 185  
 186  
 187  	public function matchCondition($args, $env) {
 188  
 189          if( !$this->condition ){
 190              return true;
 191          }
 192  
 193          // set array to prevent error on array_merge
 194          if(!is_array($this->frames)) {
 195               $this->frames = array();
 196          }
 197  
 198          $frame = $this->compileParams($env, array_merge($this->frames,$env->frames), $args );
 199  
 200          $compile_env = new Less_Environment();
 201          $compile_env->frames = array_merge(
 202                  array($frame)        // the parameter variables
 203                  , $this->frames        // the parent namespace/mixin frames
 204                  , $env->frames        // the current environment frames
 205              );
 206  
 207          $compile_env->functions = $env->functions;
 208  
 209          return (bool)$this->condition->compile($compile_env);
 210      }
 211  
 212  	public function matchArgs($args, $env = NULL){
 213          $argsLength = count($args);
 214  
 215          if( !$this->variadic ){
 216              if( $argsLength < $this->required ){
 217                  return false;
 218              }
 219              if( $argsLength > count($this->params) ){
 220                  return false;
 221              }
 222          }else{
 223              if( $argsLength < ($this->required - 1)){
 224                  return false;
 225              }
 226          }
 227  
 228          $len = min($argsLength, $this->arity);
 229  
 230          for( $i = 0; $i < $len; $i++ ){
 231              if( !isset($this->params[$i]['name']) && !isset($this->params[$i]['variadic']) ){
 232                  if( $args[$i]['value']->compile($env)->toCSS() != $this->params[$i]['value']->compile($env)->toCSS() ){
 233                      return false;
 234                  }
 235              }
 236          }
 237  
 238          return true;
 239      }
 240  
 241  }