[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  namespace Sabberworm\CSS\RuleSet;
   4  
   5  use Sabberworm\CSS\Parsing\ParserState;
   6  use Sabberworm\CSS\Parsing\OutputException;
   7  use Sabberworm\CSS\Property\Selector;
   8  use Sabberworm\CSS\Rule\Rule;
   9  use Sabberworm\CSS\Value\RuleValueList;
  10  use Sabberworm\CSS\Value\Value;
  11  use Sabberworm\CSS\Value\Size;
  12  use Sabberworm\CSS\Value\Color;
  13  use Sabberworm\CSS\Value\URL;
  14  
  15  /**
  16   * Declaration blocks are the parts of a css file which denote the rules belonging to a selector.
  17   * Declaration blocks usually appear directly inside a Document or another CSSList (mostly a MediaQuery).
  18   */
  19  class DeclarationBlock extends RuleSet {
  20  
  21      private $aSelectors;
  22  
  23  	public function __construct($iLineNo = 0) {
  24          parent::__construct($iLineNo);
  25          $this->aSelectors = array();
  26      }
  27  
  28  	public static function parse(ParserState $oParserState) {
  29          $aComments = array();
  30          $oResult = new DeclarationBlock($oParserState->currentLine());
  31          $oResult->setSelector($oParserState->consumeUntil('{', false, true, $aComments));
  32          $oResult->setComments($aComments);
  33          RuleSet::parseRuleSet($oParserState, $oResult);
  34          return $oResult;
  35      }
  36  
  37  
  38  	public function setSelectors($mSelector) {
  39          if (is_array($mSelector)) {
  40              $this->aSelectors = $mSelector;
  41          } else {
  42              $this->aSelectors = explode(',', $mSelector);
  43          }
  44          foreach ($this->aSelectors as $iKey => $mSelector) {
  45              if (!($mSelector instanceof Selector)) {
  46                  $this->aSelectors[$iKey] = new Selector($mSelector);
  47              }
  48          }
  49      }
  50  
  51      // remove one of the selector of the block
  52  	public function removeSelector($mSelector) {
  53          if($mSelector instanceof Selector) {
  54              $mSelector = $mSelector->getSelector();
  55          }
  56          foreach($this->aSelectors as $iKey => $oSelector) {
  57              if($oSelector->getSelector() === $mSelector) {
  58                  unset($this->aSelectors[$iKey]);
  59                  return true;
  60              }
  61          }
  62          return false;
  63      }
  64  
  65      /**
  66       * @deprecated use getSelectors()
  67       */
  68  	public function getSelector() {
  69          return $this->getSelectors();
  70      }
  71  
  72      /**
  73       * @deprecated use setSelectors()
  74       */
  75  	public function setSelector($mSelector) {
  76          $this->setSelectors($mSelector);
  77      }
  78  
  79      /**
  80       * Get selectors.
  81       *
  82       * @return Selector[] Selectors.
  83       */
  84  	public function getSelectors() {
  85          return $this->aSelectors;
  86      }
  87  
  88      /**
  89       * Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
  90       * */
  91  	public function expandShorthands() {
  92          // border must be expanded before dimensions
  93          $this->expandBorderShorthand();
  94          $this->expandDimensionsShorthand();
  95          $this->expandFontShorthand();
  96          $this->expandBackgroundShorthand();
  97          $this->expandListStyleShorthand();
  98      }
  99  
 100      /**
 101       * Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
 102       * */
 103  	public function createShorthands() {
 104          $this->createBackgroundShorthand();
 105          $this->createDimensionsShorthand();
 106          // border must be shortened after dimensions 
 107          $this->createBorderShorthand();
 108          $this->createFontShorthand();
 109          $this->createListStyleShorthand();
 110      }
 111  
 112      /**
 113       * Split shorthand border declarations (e.g. <tt>border: 1px red;</tt>)
 114       * Additional splitting happens in expandDimensionsShorthand
 115       * Multiple borders are not yet supported as of 3
 116       * */
 117  	public function expandBorderShorthand() {
 118          $aBorderRules = array(
 119              'border', 'border-left', 'border-right', 'border-top', 'border-bottom'
 120          );
 121          $aBorderSizes = array(
 122              'thin', 'medium', 'thick'
 123          );
 124          $aRules = $this->getRulesAssoc();
 125          foreach ($aBorderRules as $sBorderRule) {
 126              if (!isset($aRules[$sBorderRule]))
 127                  continue;
 128              $oRule = $aRules[$sBorderRule];
 129              $mRuleValue = $oRule->getValue();
 130              $aValues = array();
 131              if (!$mRuleValue instanceof RuleValueList) {
 132                  $aValues[] = $mRuleValue;
 133              } else {
 134                  $aValues = $mRuleValue->getListComponents();
 135              }
 136              foreach ($aValues as $mValue) {
 137                  if ($mValue instanceof Value) {
 138                      $mNewValue = clone $mValue;
 139                  } else {
 140                      $mNewValue = $mValue;
 141                  }
 142                  if ($mValue instanceof Size) {
 143                      $sNewRuleName = $sBorderRule . "-width";
 144                  } else if ($mValue instanceof Color) {
 145                      $sNewRuleName = $sBorderRule . "-color";
 146                  } else {
 147                      if (in_array($mValue, $aBorderSizes)) {
 148                          $sNewRuleName = $sBorderRule . "-width";
 149                      } else/* if(in_array($mValue, $aBorderStyles)) */ {
 150                          $sNewRuleName = $sBorderRule . "-style";
 151                      }
 152                  }
 153                  $oNewRule = new Rule($sNewRuleName, $this->iLineNo);
 154                  $oNewRule->setIsImportant($oRule->getIsImportant());
 155                  $oNewRule->addValue(array($mNewValue));
 156                  $this->addRule($oNewRule);
 157              }
 158              $this->removeRule($sBorderRule);
 159          }
 160      }
 161  
 162      /**
 163       * Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
 164       * into their constituent parts.
 165       * Handles margin, padding, border-color, border-style and border-width.
 166       * */
 167  	public function expandDimensionsShorthand() {
 168          $aExpansions = array(
 169              'margin' => 'margin-%s',
 170              'padding' => 'padding-%s',
 171              'border-color' => 'border-%s-color',
 172              'border-style' => 'border-%s-style',
 173              'border-width' => 'border-%s-width'
 174          );
 175          $aRules = $this->getRulesAssoc();
 176          foreach ($aExpansions as $sProperty => $sExpanded) {
 177              if (!isset($aRules[$sProperty]))
 178                  continue;
 179              $oRule = $aRules[$sProperty];
 180              $mRuleValue = $oRule->getValue();
 181              $aValues = array();
 182              if (!$mRuleValue instanceof RuleValueList) {
 183                  $aValues[] = $mRuleValue;
 184              } else {
 185                  $aValues = $mRuleValue->getListComponents();
 186              }
 187              $top = $right = $bottom = $left = null;
 188              switch (count($aValues)) {
 189                  case 1:
 190                      $top = $right = $bottom = $left = $aValues[0];
 191                      break;
 192                  case 2:
 193                      $top = $bottom = $aValues[0];
 194                      $left = $right = $aValues[1];
 195                      break;
 196                  case 3:
 197                      $top = $aValues[0];
 198                      $left = $right = $aValues[1];
 199                      $bottom = $aValues[2];
 200                      break;
 201                  case 4:
 202                      $top = $aValues[0];
 203                      $right = $aValues[1];
 204                      $bottom = $aValues[2];
 205                      $left = $aValues[3];
 206                      break;
 207              }
 208              foreach (array('top', 'right', 'bottom', 'left') as $sPosition) {
 209                  $oNewRule = new Rule(sprintf($sExpanded, $sPosition), $this->iLineNo);
 210                  $oNewRule->setIsImportant($oRule->getIsImportant());
 211                  $oNewRule->addValue(${$sPosition});
 212                  $this->addRule($oNewRule);
 213              }
 214              $this->removeRule($sProperty);
 215          }
 216      }
 217  
 218      /**
 219       * Convert shorthand font declarations
 220       * (e.g. <tt>font: 300 italic 11px/14px verdana, helvetica, sans-serif;</tt>)
 221       * into their constituent parts.
 222       * */
 223  	public function expandFontShorthand() {
 224          $aRules = $this->getRulesAssoc();
 225          if (!isset($aRules['font']))
 226              return;
 227          $oRule = $aRules['font'];
 228          // reset properties to 'normal' per http://www.w3.org/TR/21/fonts.html#font-shorthand
 229          $aFontProperties = array(
 230              'font-style' => 'normal',
 231              'font-variant' => 'normal',
 232              'font-weight' => 'normal',
 233              'font-size' => 'normal',
 234              'line-height' => 'normal'
 235          );
 236          $mRuleValue = $oRule->getValue();
 237          $aValues = array();
 238          if (!$mRuleValue instanceof RuleValueList) {
 239              $aValues[] = $mRuleValue;
 240          } else {
 241              $aValues = $mRuleValue->getListComponents();
 242          }
 243          foreach ($aValues as $mValue) {
 244              if (!$mValue instanceof Value) {
 245                  $mValue = mb_strtolower($mValue);
 246              }
 247              if (in_array($mValue, array('normal', 'inherit'))) {
 248                  foreach (array('font-style', 'font-weight', 'font-variant') as $sProperty) {
 249                      if (!isset($aFontProperties[$sProperty])) {
 250                          $aFontProperties[$sProperty] = $mValue;
 251                      }
 252                  }
 253              } else if (in_array($mValue, array('italic', 'oblique'))) {
 254                  $aFontProperties['font-style'] = $mValue;
 255              } else if ($mValue == 'small-caps') {
 256                  $aFontProperties['font-variant'] = $mValue;
 257              } else if (
 258                      in_array($mValue, array('bold', 'bolder', 'lighter'))
 259                      || ($mValue instanceof Size
 260                      && in_array($mValue->getSize(), range(100, 900, 100)))
 261              ) {
 262                  $aFontProperties['font-weight'] = $mValue;
 263              } else if ($mValue instanceof RuleValueList && $mValue->getListSeparator() == '/') {
 264                  list($oSize, $oHeight) = $mValue->getListComponents();
 265                  $aFontProperties['font-size'] = $oSize;
 266                  $aFontProperties['line-height'] = $oHeight;
 267              } else if ($mValue instanceof Size && $mValue->getUnit() !== null) {
 268                  $aFontProperties['font-size'] = $mValue;
 269              } else {
 270                  $aFontProperties['font-family'] = $mValue;
 271              }
 272          }
 273          foreach ($aFontProperties as $sProperty => $mValue) {
 274              $oNewRule = new Rule($sProperty, $this->iLineNo);
 275              $oNewRule->addValue($mValue);
 276              $oNewRule->setIsImportant($oRule->getIsImportant());
 277              $this->addRule($oNewRule);
 278          }
 279          $this->removeRule('font');
 280      }
 281  
 282      /*
 283       * Convert shorthand background declarations
 284       * (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
 285       * into their constituent parts.
 286       * @see http://www.w3.org/TR/21/colors.html#propdef-background
 287       * */
 288  
 289  	public function expandBackgroundShorthand() {
 290          $aRules = $this->getRulesAssoc();
 291          if (!isset($aRules['background']))
 292              return;
 293          $oRule = $aRules['background'];
 294          $aBgProperties = array(
 295              'background-color' => array('transparent'), 'background-image' => array('none'),
 296              'background-repeat' => array('repeat'), 'background-attachment' => array('scroll'),
 297              'background-position' => array(new Size(0, '%', null, false, $this->iLineNo), new Size(0, '%', null, false, $this->iLineNo))
 298          );
 299          $mRuleValue = $oRule->getValue();
 300          $aValues = array();
 301          if (!$mRuleValue instanceof RuleValueList) {
 302              $aValues[] = $mRuleValue;
 303          } else {
 304              $aValues = $mRuleValue->getListComponents();
 305          }
 306          if (count($aValues) == 1 && $aValues[0] == 'inherit') {
 307              foreach ($aBgProperties as $sProperty => $mValue) {
 308                  $oNewRule = new Rule($sProperty, $this->iLineNo);
 309                  $oNewRule->addValue('inherit');
 310                  $oNewRule->setIsImportant($oRule->getIsImportant());
 311                  $this->addRule($oNewRule);
 312              }
 313              $this->removeRule('background');
 314              return;
 315          }
 316          $iNumBgPos = 0;
 317          foreach ($aValues as $mValue) {
 318              if (!$mValue instanceof Value) {
 319                  $mValue = mb_strtolower($mValue);
 320              }
 321              if ($mValue instanceof URL) {
 322                  $aBgProperties['background-image'] = $mValue;
 323              } else if ($mValue instanceof Color) {
 324                  $aBgProperties['background-color'] = $mValue;
 325              } else if (in_array($mValue, array('scroll', 'fixed'))) {
 326                  $aBgProperties['background-attachment'] = $mValue;
 327              } else if (in_array($mValue, array('repeat', 'no-repeat', 'repeat-x', 'repeat-y'))) {
 328                  $aBgProperties['background-repeat'] = $mValue;
 329              } else if (in_array($mValue, array('left', 'center', 'right', 'top', 'bottom'))
 330                      || $mValue instanceof Size
 331              ) {
 332                  if ($iNumBgPos == 0) {
 333                      $aBgProperties['background-position'][0] = $mValue;
 334                      $aBgProperties['background-position'][1] = 'center';
 335                  } else {
 336                      $aBgProperties['background-position'][$iNumBgPos] = $mValue;
 337                  }
 338                  $iNumBgPos++;
 339              }
 340          }
 341          foreach ($aBgProperties as $sProperty => $mValue) {
 342              $oNewRule = new Rule($sProperty, $this->iLineNo);
 343              $oNewRule->setIsImportant($oRule->getIsImportant());
 344              $oNewRule->addValue($mValue);
 345              $this->addRule($oNewRule);
 346          }
 347          $this->removeRule('background');
 348      }
 349  
 350  	public function expandListStyleShorthand() {
 351          $aListProperties = array(
 352              'list-style-type' => 'disc',
 353              'list-style-position' => 'outside',
 354              'list-style-image' => 'none'
 355          );
 356          $aListStyleTypes = array(
 357              'none', 'disc', 'circle', 'square', 'decimal-leading-zero', 'decimal',
 358              'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin',
 359              'upper-alpha', 'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic',
 360              'hiragana', 'hira-gana-iroha', 'katakana-iroha', 'katakana'
 361          );
 362          $aListStylePositions = array(
 363              'inside', 'outside'
 364          );
 365          $aRules = $this->getRulesAssoc();
 366          if (!isset($aRules['list-style']))
 367              return;
 368          $oRule = $aRules['list-style'];
 369          $mRuleValue = $oRule->getValue();
 370          $aValues = array();
 371          if (!$mRuleValue instanceof RuleValueList) {
 372              $aValues[] = $mRuleValue;
 373          } else {
 374              $aValues = $mRuleValue->getListComponents();
 375          }
 376          if (count($aValues) == 1 && $aValues[0] == 'inherit') {
 377              foreach ($aListProperties as $sProperty => $mValue) {
 378                  $oNewRule = new Rule($sProperty, $this->iLineNo);
 379                  $oNewRule->addValue('inherit');
 380                  $oNewRule->setIsImportant($oRule->getIsImportant());
 381                  $this->addRule($oNewRule);
 382              }
 383              $this->removeRule('list-style');
 384              return;
 385          }
 386          foreach ($aValues as $mValue) {
 387              if (!$mValue instanceof Value) {
 388                  $mValue = mb_strtolower($mValue);
 389              }
 390              if ($mValue instanceof Url) {
 391                  $aListProperties['list-style-image'] = $mValue;
 392              } else if (in_array($mValue, $aListStyleTypes)) {
 393                  $aListProperties['list-style-types'] = $mValue;
 394              } else if (in_array($mValue, $aListStylePositions)) {
 395                  $aListProperties['list-style-position'] = $mValue;
 396              }
 397          }
 398          foreach ($aListProperties as $sProperty => $mValue) {
 399              $oNewRule = new Rule($sProperty, $this->iLineNo);
 400              $oNewRule->setIsImportant($oRule->getIsImportant());
 401              $oNewRule->addValue($mValue);
 402              $this->addRule($oNewRule);
 403          }
 404          $this->removeRule('list-style');
 405      }
 406  
 407  	public function createShorthandProperties(array $aProperties, $sShorthand) {
 408          $aRules = $this->getRulesAssoc();
 409          $aNewValues = array();
 410          foreach ($aProperties as $sProperty) {
 411              if (!isset($aRules[$sProperty]))
 412                  continue;
 413              $oRule = $aRules[$sProperty];
 414              if (!$oRule->getIsImportant()) {
 415                  $mRuleValue = $oRule->getValue();
 416                  $aValues = array();
 417                  if (!$mRuleValue instanceof RuleValueList) {
 418                      $aValues[] = $mRuleValue;
 419                  } else {
 420                      $aValues = $mRuleValue->getListComponents();
 421                  }
 422                  foreach ($aValues as $mValue) {
 423                      $aNewValues[] = $mValue;
 424                  }
 425                  $this->removeRule($sProperty);
 426              }
 427          }
 428          if (count($aNewValues)) {
 429              $oNewRule = new Rule($sShorthand, $this->iLineNo);
 430              foreach ($aNewValues as $mValue) {
 431                  $oNewRule->addValue($mValue);
 432              }
 433              $this->addRule($oNewRule);
 434          }
 435      }
 436  
 437  	public function createBackgroundShorthand() {
 438          $aProperties = array(
 439              'background-color', 'background-image', 'background-repeat',
 440              'background-position', 'background-attachment'
 441          );
 442          $this->createShorthandProperties($aProperties, 'background');
 443      }
 444  
 445  	public function createListStyleShorthand() {
 446          $aProperties = array(
 447              'list-style-type', 'list-style-position', 'list-style-image'
 448          );
 449          $this->createShorthandProperties($aProperties, 'list-style');
 450      }
 451  
 452      /**
 453       * Combine border-color, border-style and border-width into border
 454       * Should be run after create_dimensions_shorthand!
 455       * */
 456  	public function createBorderShorthand() {
 457          $aProperties = array(
 458              'border-width', 'border-style', 'border-color'
 459          );
 460          $this->createShorthandProperties($aProperties, 'border');
 461      }
 462  
 463      /*
 464       * Looks for long format CSS dimensional properties
 465       * (margin, padding, border-color, border-style and border-width) 
 466       * and converts them into shorthand CSS properties.
 467       * */
 468  
 469  	public function createDimensionsShorthand() {
 470          $aPositions = array('top', 'right', 'bottom', 'left');
 471          $aExpansions = array(
 472              'margin' => 'margin-%s',
 473              'padding' => 'padding-%s',
 474              'border-color' => 'border-%s-color',
 475              'border-style' => 'border-%s-style',
 476              'border-width' => 'border-%s-width'
 477          );
 478          $aRules = $this->getRulesAssoc();
 479          foreach ($aExpansions as $sProperty => $sExpanded) {
 480              $aFoldable = array();
 481              foreach ($aRules as $sRuleName => $oRule) {
 482                  foreach ($aPositions as $sPosition) {
 483                      if ($sRuleName == sprintf($sExpanded, $sPosition)) {
 484                          $aFoldable[$sRuleName] = $oRule;
 485                      }
 486                  }
 487              }
 488              // All four dimensions must be present
 489              if (count($aFoldable) == 4) {
 490                  $aValues = array();
 491                  foreach ($aPositions as $sPosition) {
 492                      $oRule = $aRules[sprintf($sExpanded, $sPosition)];
 493                      $mRuleValue = $oRule->getValue();
 494                      $aRuleValues = array();
 495                      if (!$mRuleValue instanceof RuleValueList) {
 496                          $aRuleValues[] = $mRuleValue;
 497                      } else {
 498                          $aRuleValues = $mRuleValue->getListComponents();
 499                      }
 500                      $aValues[$sPosition] = $aRuleValues;
 501                  }
 502                  $oNewRule = new Rule($sProperty, $this->iLineNo);
 503                  if ((string) $aValues['left'][0] == (string) $aValues['right'][0]) {
 504                      if ((string) $aValues['top'][0] == (string) $aValues['bottom'][0]) {
 505                          if ((string) $aValues['top'][0] == (string) $aValues['left'][0]) {
 506                              // All 4 sides are equal
 507                              $oNewRule->addValue($aValues['top']);
 508                          } else {
 509                              // Top and bottom are equal, left and right are equal
 510                              $oNewRule->addValue($aValues['top']);
 511                              $oNewRule->addValue($aValues['left']);
 512                          }
 513                      } else {
 514                          // Only left and right are equal
 515                          $oNewRule->addValue($aValues['top']);
 516                          $oNewRule->addValue($aValues['left']);
 517                          $oNewRule->addValue($aValues['bottom']);
 518                      }
 519                  } else {
 520                      // No sides are equal 
 521                      $oNewRule->addValue($aValues['top']);
 522                      $oNewRule->addValue($aValues['left']);
 523                      $oNewRule->addValue($aValues['bottom']);
 524                      $oNewRule->addValue($aValues['right']);
 525                  }
 526                  $this->addRule($oNewRule);
 527                  foreach ($aPositions as $sPosition) {
 528                      $this->removeRule(sprintf($sExpanded, $sPosition));
 529                  }
 530              }
 531          }
 532      }
 533  
 534      /**
 535       * Looks for long format CSS font properties (e.g. <tt>font-weight</tt>) and 
 536       * tries to convert them into a shorthand CSS <tt>font</tt> property. 
 537       * At least font-size AND font-family must be present in order to create a shorthand declaration.
 538       * */
 539  	public function createFontShorthand() {
 540          $aFontProperties = array(
 541              'font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', 'font-family'
 542          );
 543          $aRules = $this->getRulesAssoc();
 544          if (!isset($aRules['font-size']) || !isset($aRules['font-family'])) {
 545              return;
 546          }
 547          $oNewRule = new Rule('font', $this->iLineNo);
 548          foreach (array('font-style', 'font-variant', 'font-weight') as $sProperty) {
 549              if (isset($aRules[$sProperty])) {
 550                  $oRule = $aRules[$sProperty];
 551                  $mRuleValue = $oRule->getValue();
 552                  $aValues = array();
 553                  if (!$mRuleValue instanceof RuleValueList) {
 554                      $aValues[] = $mRuleValue;
 555                  } else {
 556                      $aValues = $mRuleValue->getListComponents();
 557                  }
 558                  if ($aValues[0] !== 'normal') {
 559                      $oNewRule->addValue($aValues[0]);
 560                  }
 561              }
 562          }
 563          // Get the font-size value
 564          $oRule = $aRules['font-size'];
 565          $mRuleValue = $oRule->getValue();
 566          $aFSValues = array();
 567          if (!$mRuleValue instanceof RuleValueList) {
 568              $aFSValues[] = $mRuleValue;
 569          } else {
 570              $aFSValues = $mRuleValue->getListComponents();
 571          }
 572          // But wait to know if we have line-height to add it
 573          if (isset($aRules['line-height'])) {
 574              $oRule = $aRules['line-height'];
 575              $mRuleValue = $oRule->getValue();
 576              $aLHValues = array();
 577              if (!$mRuleValue instanceof RuleValueList) {
 578                  $aLHValues[] = $mRuleValue;
 579              } else {
 580                  $aLHValues = $mRuleValue->getListComponents();
 581              }
 582              if ($aLHValues[0] !== 'normal') {
 583                  $val = new RuleValueList('/', $this->iLineNo);
 584                  $val->addListComponent($aFSValues[0]);
 585                  $val->addListComponent($aLHValues[0]);
 586                  $oNewRule->addValue($val);
 587              }
 588          } else {
 589              $oNewRule->addValue($aFSValues[0]);
 590          }
 591          $oRule = $aRules['font-family'];
 592          $mRuleValue = $oRule->getValue();
 593          $aFFValues = array();
 594          if (!$mRuleValue instanceof RuleValueList) {
 595              $aFFValues[] = $mRuleValue;
 596          } else {
 597              $aFFValues = $mRuleValue->getListComponents();
 598          }
 599          $oFFValue = new RuleValueList(',', $this->iLineNo);
 600          $oFFValue->setListComponents($aFFValues);
 601          $oNewRule->addValue($oFFValue);
 602  
 603          $this->addRule($oNewRule);
 604          foreach ($aFontProperties as $sProperty) {
 605              $this->removeRule($sProperty);
 606          }
 607      }
 608  
 609  	public function __toString() {
 610          return $this->render(new \Sabberworm\CSS\OutputFormat());
 611      }
 612  
 613  	public function render(\Sabberworm\CSS\OutputFormat $oOutputFormat) {
 614          if(count($this->aSelectors) === 0) {
 615              // If all the selectors have been removed, this declaration block becomes invalid
 616              throw new OutputException("Attempt to print declaration block with missing selector", $this->iLineNo);
 617          }
 618          $sResult = $oOutputFormat->sBeforeDeclarationBlock;
 619          $sResult .= $oOutputFormat->implode($oOutputFormat->spaceBeforeSelectorSeparator() . ',' . $oOutputFormat->spaceAfterSelectorSeparator(), $this->aSelectors);
 620          $sResult .= $oOutputFormat->sAfterDeclarationBlockSelectors;
 621          $sResult .= $oOutputFormat->spaceBeforeOpeningBrace() . '{';
 622          $sResult .= parent::render($oOutputFormat);
 623          $sResult .= '}';
 624          $sResult .= $oOutputFormat->sAfterDeclarationBlock;
 625          return $sResult;
 626      }
 627  
 628  }