servnest/lessphp/lib/Less/Tree/Dimension.php

<?php

/**
 * Dimension
 *
 * @package Less
 * @subpackage tree
 */
class Less_Tree_Dimension extends Less_Tree {

	public $value;
	public $unit;
	public $type = 'Dimension';

	public function __construct( $value, $unit = null ) {
		$this->value = floatval( $value );

		if ( $unit && ( $unit instanceof Less_Tree_Unit ) ) {
			$this->unit = $unit;
		} elseif ( $unit ) {
			$this->unit = new Less_Tree_Unit( array( $unit ) );
		} else {
			$this->unit = new Less_Tree_Unit();
		}
	}

	public function accept( $visitor ) {
		$this->unit = $visitor->visitObj( $this->unit );
	}

	public function compile() {
		return $this;
	}

	public function toColor() {
		return new Less_Tree_Color( array( $this->value, $this->value, $this->value ) );
	}

	/**
	 * @see Less_Tree::genCSS
	 */
	public function genCSS( $output ) {
		if ( Less_Parser::$options['strictUnits'] && !$this->unit->isSingular() ) {
			throw new Less_Exception_Compiler( "Multiple units in dimension. Correct the units or use the unit function. Bad unit: ".$this->unit->toString() );
		}

		$value = Less_Functions::fround( $this->value );
		$strValue = (string)$value;

		if ( $value !== 0 && $value < 0.000001 && $value > -0.000001 ) {
			// would be output 1e-6 etc.
			$strValue = number_format( $strValue, 10 );
			$strValue = preg_replace( '/\.?0+$/', '', $strValue );
		}

		if ( Less_Parser::$options['compress'] ) {
			// Zero values doesn't need a unit
			if ( $value === 0 && $this->unit->isLength() ) {
				$output->add( $strValue );
				return $strValue;
			}

			// Float values doesn't need a leading zero
			if ( $value > 0 && $value < 1 && $strValue[0] === '0' ) {
				$strValue = substr( $strValue, 1 );
			}
		}

		$output->add( $strValue );
		$this->unit->genCSS( $output );
	}

	public function __toString() {
		return $this->toCSS();
	}

	// In an operation between two Dimensions,
	// we default to the first Dimension's unit,
	// so `1px + 2em` will yield `3px`.

	/**
	 * @param string $op
	 */
	public function operate( $op, $other ) {
		$value = Less_Functions::operate( $op, $this->value, $other->value );
		$unit = clone $this->unit;

		if ( $op === '+' || $op === '-' ) {

			if ( !$unit->numerator && !$unit->denominator ) {
				$unit->numerator = $other->unit->numerator;
				$unit->denominator = $other->unit->denominator;
			} elseif ( !$other->unit->numerator && !$other->unit->denominator ) {
				// do nothing
			} else {
				$other = $other->convertTo( $this->unit->usedUnits() );

				if ( Less_Parser::$options['strictUnits'] && $other->unit->toString() !== $unit->toCSS() ) {
					throw new Less_Exception_Compiler( "Incompatible units. Change the units or use the unit function. Bad units: '" . $unit->toString() . "' and " . $other->unit->toString() . "'." );
				}

				$value = Less_Functions::operate( $op, $this->value, $other->value );
			}
		} elseif ( $op === '*' ) {
			$unit->numerator = array_merge( $unit->numerator, $other->unit->numerator );
			$unit->denominator = array_merge( $unit->denominator, $other->unit->denominator );
			sort( $unit->numerator );
			sort( $unit->denominator );
			$unit->cancel();
		} elseif ( $op === '/' ) {
			$unit->numerator = array_merge( $unit->numerator, $other->unit->denominator );
			$unit->denominator = array_merge( $unit->denominator, $other->unit->numerator );
			sort( $unit->numerator );
			sort( $unit->denominator );
			$unit->cancel();
		}
		return new Less_Tree_Dimension( $value, $unit );
	}

	public function compare( $other ) {
		if ( $other instanceof Less_Tree_Dimension ) {

			if ( $this->unit->isEmpty() || $other->unit->isEmpty() ) {
				$a = $this;
				$b = $other;
			} else {
				$a = $this->unify();
				$b = $other->unify();
				if ( $a->unit->compare( $b->unit ) !== 0 ) {
					return -1;
				}
			}
			$aValue = $a->value;
			$bValue = $b->value;

			if ( $bValue > $aValue ) {
				return -1;
			} elseif ( $bValue < $aValue ) {
				return 1;
			} else {
				return 0;
			}
		} else {
			return -1;
		}
	}

	public function unify() {
		return $this->convertTo( array( 'length' => 'px', 'duration' => 's', 'angle' => 'rad' ) );
	}

	public function convertTo( $conversions ) {
		$value = $this->value;
		$unit = clone $this->unit;

		if ( is_string( $conversions ) ) {
			$derivedConversions = array();
			foreach ( Less_Tree_UnitConversions::$groups as $i ) {
				if ( isset( Less_Tree_UnitConversions::${$i}[$conversions] ) ) {
					$derivedConversions = array( $i => $conversions );
				}
			}
			$conversions = $derivedConversions;
		}

		foreach ( $conversions as $groupName => $targetUnit ) {
			$group = Less_Tree_UnitConversions::${$groupName};

			// numerator
			foreach ( $unit->numerator as $i => $atomicUnit ) {
				$atomicUnit = $unit->numerator[$i];
				if ( !isset( $group[$atomicUnit] ) ) {
					continue;
				}

				$value = $value * ( $group[$atomicUnit] / $group[$targetUnit] );

				$unit->numerator[$i] = $targetUnit;
			}

			// denominator
			foreach ( $unit->denominator as $i => $atomicUnit ) {
				$atomicUnit = $unit->denominator[$i];
				if ( !isset( $group[$atomicUnit] ) ) {
					continue;
				}

				$value = $value / ( $group[$atomicUnit] / $group[$targetUnit] );

				$unit->denominator[$i] = $targetUnit;
			}
		}

		$unit->cancel();

		return new Less_Tree_Dimension( $value, $unit );
	}
}