vendor/sabberworm/php-css-parser/lib/Sabberworm/CSS/Rule/Rule.php

   1 <?php
   2
   3 namespace Sabberworm\CSS\Rule;
   4
   5 use Sabberworm\CSS\Renderable;
   6 use Sabberworm\CSS\Value\RuleValueList;
   7 use Sabberworm\CSS\Value\Value;
   8 use Sabberworm\CSS\Comment\Commentable;
   9
  10 /**
  11  * RuleSets contains Rule objects which always have a key and a value.
  12  * In CSS, Rules are expressed as follows: “key: value[0][0] value[0][1], value[1][0] value[1][1];”
  13  */
  14 class Rule implements Renderable, Commentable {
  15
  16         private $sRule;
  17         private $mValue;
  18         private $bIsImportant;
  19         private $aIeHack;
  20         protected $iLineNo;
  21         protected $aComments;
  22
  23         public function __construct($sRule, $iLineNo = 0) {
  24                 $this->sRule = $sRule;
  25                 $this->mValue = null;
  26                 $this->bIsImportant = false;
  27                 $this->aIeHack = array();
  28                 $this->iLineNo = $iLineNo;
  29                 $this->aComments = array();
  30         }
  31
  32         /**
  33          * @return int
  34          */
  35         public function getLineNo() {
  36                 return $this->iLineNo;
  37         }
  38
  39         public function setRule($sRule) {
  40                 $this->sRule = $sRule;
  41         }
  42
  43         public function getRule() {
  44                 return $this->sRule;
  45         }
  46
  47         public function getValue() {
  48                 return $this->mValue;
  49         }
  50
  51         public function setValue($mValue) {
  52                 $this->mValue = $mValue;
  53         }
  54
  55         /**
  56          *      @deprecated Old-Style 2-dimensional array given. Retained for (some) backwards-compatibility. Use setValue() instead and wrapp the value inside a RuleValueList if necessary.
  57          */
  58         public function setValues($aSpaceSeparatedValues) {
  59                 $oSpaceSeparatedList = null;
  60                 if (count($aSpaceSeparatedValues) > 1) {
  61                         $oSpaceSeparatedList = new RuleValueList(' ', $this->iLineNo);
  62                 }
  63                 foreach ($aSpaceSeparatedValues as $aCommaSeparatedValues) {
  64                         $oCommaSeparatedList = null;
  65                         if (count($aCommaSeparatedValues) > 1) {
  66                                 $oCommaSeparatedList = new RuleValueList(',', $this->iLineNo);
  67                         }
  68                         foreach ($aCommaSeparatedValues as $mValue) {
  69                                 if (!$oSpaceSeparatedList && !$oCommaSeparatedList) {
  70                                         $this->mValue = $mValue;
  71                                         return $mValue;
  72                                 }
  73                                 if ($oCommaSeparatedList) {
  74                                         $oCommaSeparatedList->addListComponent($mValue);
  75                                 } else {
  76                                         $oSpaceSeparatedList->addListComponent($mValue);
  77                                 }
  78                         }
  79                         if (!$oSpaceSeparatedList) {
  80                                 $this->mValue = $oCommaSeparatedList;
  81                                 return $oCommaSeparatedList;
  82                         } else {
  83                                 $oSpaceSeparatedList->addListComponent($oCommaSeparatedList);
  84                         }
  85                 }
  86                 $this->mValue = $oSpaceSeparatedList;
  87                 return $oSpaceSeparatedList;
  88         }
  89
  90         /**
  91          *      @deprecated Old-Style 2-dimensional array returned. Retained for (some) backwards-compatibility. Use getValue() instead and check for the existance of a (nested set of) ValueList object(s).
  92          */
  93         public function getValues() {
  94                 if (!$this->mValue instanceof RuleValueList) {
  95                         return array(array($this->mValue));
  96                 }
  97                 if ($this->mValue->getListSeparator() === ',') {
  98                         return array($this->mValue->getListComponents());
  99                 }
 100                 $aResult = array();
 101                 foreach ($this->mValue->getListComponents() as $mValue) {
 102                         if (!$mValue instanceof RuleValueList || $mValue->getListSeparator() !== ',') {
 103                                 $aResult[] = array($mValue);
 104                                 continue;
 105                         }
 106                         if ($this->mValue->getListSeparator() === ' ' || count($aResult) === 0) {
 107                                 $aResult[] = array();
 108                         }
 109                         foreach ($mValue->getListComponents() as $mValue) {
 110                                 $aResult[count($aResult) - 1][] = $mValue;
 111                         }
 112                 }
 113                 return $aResult;
 114         }
 115
 116         /**
 117          * Adds a value to the existing value. Value will be appended if a RuleValueList exists of the given type. Otherwise, the existing value will be wrapped by one.
 118          */
 119         public function addValue($mValue, $sType = ' ') {
 120                 if (!is_array($mValue)) {
 121                         $mValue = array($mValue);
 122                 }
 123                 if (!$this->mValue instanceof RuleValueList || $this->mValue->getListSeparator() !== $sType) {
 124                         $mCurrentValue = $this->mValue;
 125                         $this->mValue = new RuleValueList($sType, $this->iLineNo);
 126                         if ($mCurrentValue) {
 127                                 $this->mValue->addListComponent($mCurrentValue);
 128                         }
 129                 }
 130                 foreach ($mValue as $mValueItem) {
 131                         $this->mValue->addListComponent($mValueItem);
 132                 }
 133         }
 134
 135         public function addIeHack($iModifier) {
 136                 $this->aIeHack[] = $iModifier;
 137         }
 138
 139         public function setIeHack(array $aModifiers) {
 140                 $this->aIeHack = $aModifiers;
 141         }
 142
 143         public function getIeHack() {
 144                 return $this->aIeHack;
 145         }
 146
 147         public function setIsImportant($bIsImportant) {
 148                 $this->bIsImportant = $bIsImportant;
 149         }
 150
 151         public function getIsImportant() {
 152                 return $this->bIsImportant;
 153         }
 154
 155         public function __toString() {
 156                 return $this->render(new \Sabberworm\CSS\OutputFormat());
 157         }
 158
 159         public function render(\Sabberworm\CSS\OutputFormat $oOutputFormat) {
 160                 $sResult = "{$this->sRule}:{$oOutputFormat->spaceAfterRuleName()}";
 161                 if ($this->mValue instanceof Value) { //Can also be a ValueList
 162                         $sResult .= $this->mValue->render($oOutputFormat);
 163                 } else {
 164                         $sResult .= $this->mValue;
 165                 }
 166                 if (!empty($this->aIeHack)) {
 167                         $sResult .= ' \\' . implode('\\', $this->aIeHack);
 168                 }
 169                 if ($this->bIsImportant) {
 170                         $sResult .= ' !important';
 171                 }
 172                 $sResult .= ';';
 173                 return $sResult;
 174         }
 175
 176         /**
 177          * @param array $aComments Array of comments.
 178          */
 179         public function addComments(array $aComments) {
 180                 $this->aComments = array_merge($this->aComments, $aComments);
 181         }
 182
 183         /**
 184          * @return array
 185          */
 186         public function getComments() {
 187                 return $this->aComments;
 188         }
 189
 190         /**
 191          * @param array $aComments Array containing Comment objects.
 192          */
 193         public function setComments(array $aComments) {
 194                 $this->aComments = $aComments;
 195         }
 196
 197 }