AnonymousFox

/home/develito/www/libraries-new/vendor/leafo/lessphp/lessify.inc.php

<?php
/**
 * lessify
 * Convert a css file into a less file
 * http://leafo.net/lessphp
 * Copyright 2010, leaf corcoran <leafot@gmail.com>
 *
 * WARNING: THIS DOES NOT WORK ANYMORE. NEEDS TO BE UPDATED FOR
 * LATEST VERSION OF LESSPHP.
 *
 */

require "lessc.inc.php";

//
// check if the merge during mixin is overwriting values. should or should it not?
//

//
// 1. split apart class tags
//

class easyparse {
	var $buffer;
	var $count;

function __construct($str) {
		$this->count = 0;
		$this->buffer = trim($str);
	}

function seek($where = null) {
		if ($where === null) return $this->count;
		else $this->count = $where;
		return true;
	}

function preg_quote($what) {
		return preg_quote($what, '/');
	}

function match($regex, &$out, $eatWhitespace = true) {
		$r = '/'.$regex.($eatWhitespace ? '\s*' : '').'/Ais';
		if (preg_match($r, $this->buffer, $out, null, $this->count)) {
			$this->count += strlen($out[0]);
			return true;
		}
		return false;
	}

function literal($what, $eatWhitespace = true) {
		// this is here mainly prevent notice from { } string accessor
		if ($this->count >= strlen($this->buffer)) return false;

// shortcut on single letter
		if (!$eatWhitespace and strlen($what) == 1) {
			if ($this->buffer{$this->count} == $what) {
				$this->count++;
				return true;
			}
			else return false;
		}

return $this->match($this->preg_quote($what), $m, $eatWhitespace);
	}

}

class tagparse extends easyparse {
	static private $combinators = null;
	static private $match_opts = null;

function parse() {
		if (empty(self::$combinators)) {
			self::$combinators = '('.implode('|', array_map(array($this, 'preg_quote'),
				array('+', '>', '~'))).')';
			self::$match_opts = '('.implode('|', array_map(array($this, 'preg_quote'),
				array('=', '~=', '|=', '$=', '*='))).')';
		}

// crush whitespace
		$this->buffer = preg_replace('/\s+/', ' ', $this->buffer).' ';

$tags = array();
		while ($this->tag($t)) $tags[] = $t;

return $tags;
	}

static function compileString($string) {
		list(, $delim, $str) = $string;
		$str = str_replace($delim, "\\".$delim, $str);
		$str = str_replace("\n", "\\\n", $str);
		return $delim.$str.$delim;
	}

static function compilePaths($paths) {
		return implode(', ', array_map(array('self', 'compilePath'), $paths));
	}

// array of tags
	static function compilePath($path) {
		return implode(' ', array_map(array('self', 'compileTag'), $path));
	}

static function compileTag($tag) {
		ob_start();
		if (isset($tag['comb'])) echo $tag['comb']." ";
		if (isset($tag['front'])) echo $tag['front'];
		if (isset($tag['attr'])) {
			echo '['.$tag['attr'];
			if (isset($tag['op'])) {
				echo $tag['op'].$tag['op_value'];
			}
			echo ']';
		}
		return ob_get_clean();
	}

function string(&$out) {
		$s = $this->seek();

if ($this->literal('"')) {
			$delim = '"';
		} elseif ($this->literal("'")) {
			$delim = "'";
		} else {
			return false;
		}

while (true) {
			// step through letters looking for either end or escape
			$buff = "";
			$escapeNext = false;
			$finished = false;
			for ($i = $this->count; $i < strlen($this->buffer); $i++) {
				$char = $this->buffer[$i];
				switch ($char) {
				case $delim:
					if ($escapeNext) {
						$buff .= $char;
						$escapeNext = false;
						break;
					}
					$finished = true;
					break 2;
				case "\\":
					if ($escapeNext) {
						$buff .= $char;
						$escapeNext = false;
					} else {
						$escapeNext = true;
					}
					break;
				case "\n":
					if (!$escapeNext) {
						break 3;
					}

$buff .= $char;
					$escapeNext = false;
					break;
				default:
					if ($escapeNext) {
						$buff .= "\\";
						$escapeNext = false;
					}
					$buff .= $char;
				}
			}
			if (!$finished) break;
			$out = array('string', $delim, $buff);
			$this->seek($i+1);
			return true;
		}

$this->seek($s);
		return false;
	}

function tag(&$out) {
		$s = $this->seek();
		$tag = array();
		if ($this->combinator($op)) $tag['comb'] = $op;

if (!$this->match('(.*?)( |$|\[|'.self::$combinators.')', $match)) {
			$this->seek($s);
			return false;
		}

if (!empty($match[3])) {
			// give back combinator
			$this->count-=strlen($match[3]);
		}

if (!empty($match[1])) $tag['front'] = $match[1];

if ($match[2] == '[') {
			if ($this->ident($i)) {
				$tag['attr'] = $i;

if ($this->match(self::$match_opts, $m) && $this->value($v)) {
					$tag['op'] = $m[1];
					$tag['op_value'] = $v;
				}

if ($this->literal(']')) {
					$out = $tag;
					return true;
				}
			}
		} elseif (isset($tag['front'])) {
			$out = $tag;
			return true;
		}

$this->seek($s);
		return false;
	}

function value(&$out) {
		if ($this->string($str)) {
			$out = $this->compileString($str);
			return true;
		} elseif ($this->ident($id)) {
			$out = $id;
			return true;
		}
		return false;
	}

function combinator(&$op) {
		if ($this->match(self::$combinators, $m)) {
			$op = $m[1];
			return true;
		}
		return false;
	}
}

class nodecounter {
	var $count = 0;
	var $children = array();

var $name;
	var $child_blocks;
	var $the_block;

function __construct($name) {
		$this->name = $name;
	}

function dump($stack = null) {
		if (is_null($stack)) $stack = array();
		$stack[] = $this->getName();
		echo implode(' -> ', $stack)." ($this->count)\n";
		foreach ($this->children as $child) {
			$child->dump($stack);
		}
	}

static function compileProperties($c, $block) {
		foreach($block as $name => $value) {
			if ($c->isProperty($name, $value)) {
				echo $c->compileProperty($name, $value)."\n";
			}
		}
	}

function compile($c, $path = null) {
		if (is_null($path)) $path = array();
		$path[] = $this->name;

$isVisible = !is_null($this->the_block) || !is_null($this->child_blocks);

if ($isVisible) {
			echo $c->indent(implode(' ', $path).' {');
			$c->indentLevel++;
			$path = array();

if ($this->the_block) {
				$this->compileProperties($c, $this->the_block);
			}

if ($this->child_blocks) {
				foreach ($this->child_blocks as $block) {
					echo $c->indent(tagparse::compilePaths($block['__tags']).' {');
					$c->indentLevel++;
					$this->compileProperties($c, $block);
					$c->indentLevel--;
					echo $c->indent('}');
				}
			}
		}

// compile child nodes
		foreach($this->children as $node) {
			$node->compile($c, $path);
		}

if ($isVisible) {
			$c->indentLevel--;
			echo $c->indent('}');
		}

}

function getName() {
		if (is_null($this->name)) return "[root]";
		else return $this->name;
	}

function getNode($name) {
		if (!isset($this->children[$name])) {
			$this->children[$name] = new nodecounter($name);
		}

return $this->children[$name];
	}

function findNode($path) {
		$current = $this;
		for ($i = 0; $i < count($path); $i++) {
			$t = tagparse::compileTag($path[$i]);
			$current = $current->getNode($t);
		}

return $current;
	}

function addBlock($path, $block) {
		$node = $this->findNode($path);
		if (!is_null($node->the_block)) throw new exception("can this happen?");

unset($block['__tags']);
		$node->the_block = $block;
	}

function addToNode($path, $block) {
		$node = $this->findNode($path);
		$node->child_blocks[] = $block;
	}
}

/**
 * create a less file from a css file by combining blocks where appropriate
 */
class lessify extends lessc {
	public function dump() {
		print_r($this->env);
	}

public function parse($str = null) {
		$this->prepareParser($str ? $str : $this->buffer);
		while (false !== $this->parseChunk());

$root = new nodecounter(null);

// attempt to preserve some of the block order
		$order = array();

$visitedTags = array();
		foreach (end($this->env) as $name => $block) {
			if (!$this->isBlock($name, $block)) continue;
			if (isset($visitedTags[$name])) continue;

foreach ($block['__tags'] as $t) {
				$visitedTags[$t] = true;
			}

// skip those with more than 1
			if (count($block['__tags']) == 1) {
				$p = new tagparse(end($block['__tags']));
				$path = $p->parse();
				$root->addBlock($path, $block);
				$order[] = array('compressed', $path, $block);
				continue;
			} else {
				$common = null;
				$paths = array();
				foreach ($block['__tags'] as $rawtag) {
					$p = new tagparse($rawtag);
					$paths[] = $path = $p->parse();
					if (is_null($common)) $common = $path;
					else {
						$new_common = array();
						foreach ($path as $tag) {
							$head = array_shift($common);
							if ($tag == $head) {
								$new_common[] = $head;
							} else break;
						}
						$common = $new_common;
						if (empty($common)) {
							// nothing in common
							break;
						}
					}
				}

if (!empty($common)) {
					$new_paths = array();
					foreach ($paths as $p) $new_paths[] = array_slice($p, count($common));
					$block['__tags'] = $new_paths;
					$root->addToNode($common, $block);
					$order[] = array('compressed', $common, $block);
					continue;
				}

}

$order[] = array('none', $block['__tags'], $block);
		}

$compressed = $root->children;
		foreach ($order as $item) {
			list($type, $tags, $block) = $item;
			if ($type == 'compressed') {
				$top = tagparse::compileTag(reset($tags));
				if (isset($compressed[$top])) {
					$compressed[$top]->compile($this);
					unset($compressed[$top]);
				}
			} else {
				echo $this->indent(implode(', ', $tags).' {');
				$this->indentLevel++;
				nodecounter::compileProperties($this, $block);
				$this->indentLevel--;
				echo $this->indent('}');
			}
		}
	}
}