lib/rtlcss/RTLCSS.php

   1 <?php
   2 /**
   3  * RTLCSS.
   4  *
   5  * @package   MoodleHQ\RTLCSS
   6  * @copyright 2016 Frédéric Massart - FMCorz.net
   7  * @license   https://opensource.org/licenses/MIT MIT
   8  */
   9
  10 namespace MoodleHQ\RTLCSS;
  11
  12 use Sabberworm\CSS\CSSList\CSSList;
  13 use Sabberworm\CSS\CSSList\Document;
  14 use Sabberworm\CSS\OutputFormat;
  15 use Sabberworm\CSS\Parser;
  16 use Sabberworm\CSS\Rule\Rule;
  17 use Sabberworm\CSS\RuleSet\RuleSet;
  18 use Sabberworm\CSS\Settings;
  19 use Sabberworm\CSS\Value\CSSFunction;
  20 use Sabberworm\CSS\Value\CSSString;
  21 use Sabberworm\CSS\Value\PrimitiveValue;
  22 use Sabberworm\CSS\Value\RuleValueList;
  23 use Sabberworm\CSS\Value\Size;
  24 use Sabberworm\CSS\Value\ValueList;
  25
  26 /**
  27  * RTLCSS Class.
  28  *
  29  * @package   MoodleHQ\RTLCSS
  30  * @copyright 2016 Frédéric Massart - FMCorz.net
  31  * @license   https://opensource.org/licenses/MIT MIT
  32  */
  33 class RTLCSS {
  34
  35     protected $tree;
  36     protected $shouldAddCss = [];
  37     protected $shouldIgnore = false;
  38     protected $shouldRemove = false;
  39
  40     public function __construct(Document $tree) {
  41         $this->tree = $tree;
  42     }
  43
  44     protected function compare($what, $to, $ignoreCase) {
  45         if ($ignoreCase) {
  46             return strtolower($what) === strtolower($to);
  47         }
  48         return $what === $to;
  49     }
  50
  51     protected function complement($value) {
  52         if ($value instanceof Size) {
  53             $value->setSize(100 - $value->getSize());
  54
  55         } else if ($value instanceof CSSFunction) {
  56             $arguments = implode($value->getListSeparator(), $value->getArguments());
  57             $arguments = "100% - ($arguments)";
  58             $value->setListComponents([$arguments]);
  59         }
  60     }
  61
  62     public function flip() {
  63         $this->processBlock($this->tree);
  64         return $this->tree;
  65     }
  66
  67     protected function negate($value) {
  68         if ($value instanceof ValueList) {
  69             foreach ($value->getListComponents() as $part) {
  70                 $this->negate($part);
  71             }
  72         } else if ($value instanceof Size) {
  73             if ($value->getSize() != 0) {
  74                 $value->setSize(-$value->getSize());
  75             }
  76         }
  77     }
  78
  79     protected function parseComments(array $comments) {
  80         $startRule = '^(\s|\*)*!?rtl:';
  81         foreach ($comments as $comment) {
  82             $content = $comment->getComment();
  83             if (preg_match('/' . $startRule . 'ignore/', $content)) {
  84                 $this->shouldIgnore = 1;
  85             } else if (preg_match('/' . $startRule . 'begin:ignore/', $content)) {
  86                 $this->shouldIgnore = true;
  87             } else if (preg_match('/' . $startRule . 'end:ignore/', $content)) {
  88                 $this->shouldIgnore = false;
  89             } else if (preg_match('/' . $startRule . 'remove/', $content)) {
  90                 $this->shouldRemove = 1;
  91             } else if (preg_match('/' . $startRule . 'begin:remove/', $content)) {
  92                 $this->shouldRemove = true;
  93             } else if (preg_match('/' . $startRule . 'end:remove/', $content)) {
  94                 $this->shouldRemove = false;
  95             } else if (preg_match('/' . $startRule . 'raw:/', $content)) {
  96                 $this->shouldAddCss[] = preg_replace('/' . $startRule . 'raw:/', '', $content);
  97             }
  98         }
  99     }
 100
 101     protected function processBackground(Rule $rule) {
 102         $value = $rule->getValue();
 103
 104         // TODO Fix upstream library as it does not parse this well, commas don't take precedence.
 105         // There can be multiple sets of properties per rule.
 106         $hasItems = false;
 107         $items = [$value];
 108         if ($value instanceof RuleValueList && $value->getListSeparator() == ',') {
 109             $hasItems = true;
 110             $items = $value->getListComponents();
 111         }
 112
 113         // Foreach set.
 114         foreach ($items as $itemKey => $item) {
 115
 116             // There can be multiple values in the same set.
 117             $hasValues = false;
 118             $parts = [$item];
 119             if ($item instanceof RuleValueList) {
 120                 $hasValues = true;
 121                 $parts = $value->getListComponents();
 122             }
 123
 124             $requiresPositionalArgument = false;
 125             $hasPositionalArgument = false;
 126             foreach ($parts as $key => $part) {
 127                 $part = $parts[$key];
 128
 129                 if (!is_object($part)) {
 130                     $flipped = $this->swapLeftRight($part);
 131
 132                     // Positional arguments can have a size following.
 133                     $hasPositionalArgument = $parts[$key] != $flipped;
 134                     $requiresPositionalArgument = true;
 135
 136                     $parts[$key] = $flipped;
 137                     continue;
 138
 139                 } else if ($part instanceof CSSFunction && strpos($part->getName(), 'gradient') !== false) {
 140                     // TODO Fix this.
 141
 142                 } else if ($part instanceof Size && ($part->getUnit() === '%' || !$part->getUnit())) {
 143
 144                     // Is this a value we're interested in?
 145                     if (!$requiresPositionalArgument || $hasPositionalArgument) {
 146                         $this->complement($part);
 147                         $part->setUnit('%');
 148                         // We only need to change one value.
 149                         break;
 150                     }
 151
 152                 }
 153
 154                 $hasPositionalArgument = false;
 155             }
 156
 157             if ($hasValues) {
 158                 $item->setListComponents($parts);
 159             } else {
 160                 $items[$itemKey] = $parts[$key];
 161             }
 162         }
 163
 164         if ($hasItems) {
 165             $value->setListComponents($items);
 166         } else {
 167             $rule->setValue($items[0]);
 168         }
 169     }
 170
 171     protected function processBlock($block) {
 172         $contents = [];
 173
 174         foreach ($block->getContents() as $node) {
 175             $this->parseComments($node->getComments());
 176
 177             if ($toAdd = $this->shouldAddCss()) {
 178                 foreach ($toAdd as $add) {
 179                     $parser = new Parser($add);
 180                     $contents[] = $parser->parse();
 181                 }
 182             }
 183
 184             if ($this->shouldRemoveNext()) {
 185                 continue;
 186
 187             } else if (!$this->shouldIgnoreNext()) {
 188                 if ($node instanceof CSSList) {
 189                     $this->processBlock($node);
 190                 }
 191                 if ($node instanceof RuleSet) {
 192                     $this->processDeclaration($node);
 193                 }
 194             }
 195
 196             $contents[] = $node;
 197         }
 198
 199         $block->setContents($contents);
 200     }
 201
 202     protected function processDeclaration($node) {
 203         $rules = [];
 204
 205         foreach ($node->getRules() as $key => $rule) {
 206             $this->parseComments($rule->getComments());
 207
 208             if ($toAdd = $this->shouldAddCss()) {
 209                 foreach ($toAdd as $add) {
 210                     $parser = new Parser('.wrapper{' . $add . '}');
 211                     $tree = $parser->parse();
 212                     $contents = $tree->getContents();
 213                     foreach ($contents[0]->getRules() as $newRule) {
 214                         $rules[] = $newRule;
 215                     }
 216                 }
 217             }
 218
 219             if ($this->shouldRemoveNext()) {
 220                 continue;
 221
 222             } else if (!$this->shouldIgnoreNext()) {
 223                 $this->processRule($rule);
 224             }
 225
 226             $rules[] = $rule;
 227         }
 228
 229         $node->setRules($rules);
 230     }
 231
 232     protected function processRule($rule) {
 233         $property = $rule->getRule();
 234         $value = $rule->getValue();
 235
 236         if (preg_match('/direction$/im', $property)) {
 237             $rule->setValue($this->swapLtrRtl($value));
 238
 239         } else if (preg_match('/left/im', $property)) {
 240             $rule->setRule(str_replace('left', 'right', $property));
 241
 242         } else if (preg_match('/right/im', $property)) {
 243             $rule->setRule(str_replace('right', 'left', $property));
 244
 245         } else if (preg_match('/transition(-property)?$/i', $property)) {
 246             $rule->setValue($this->swapLeftRight($value));
 247
 248         } else if (preg_match('/float|clear|text-align/i', $property)) {
 249             $rule->setValue($this->swapLeftRight($value));
 250
 251         } else if (preg_match('/^(margin|padding|border-(color|style|width))$/i', $property)) {
 252
 253             if ($value instanceof RuleValueList) {
 254                 $values = $value->getListComponents();
 255                 $count = count($values);
 256                 if ($count == 4) {
 257                     $right = $values[3];
 258                     $values[3] = $values[1];
 259                     $values[1] = $right;
 260                 }
 261                 $value->setListComponents($values);
 262             }
 263
 264         } else if (preg_match('/border-radius/i', $property)) {
 265             if ($value instanceof RuleValueList) {
 266
 267                 // Border radius can contain two lists separated by a slash.
 268                 $groups = $value->getListComponents();
 269                 if ($value->getListSeparator() !== '/') {
 270                     $groups = [$value];
 271                 }
 272                 foreach ($groups as $group) {
 273                     if ($group instanceof RuleValueList) {
 274                         $values = $group->getListComponents();
 275                         switch (count($values)) {
 276                             case 2:
 277                                 $group->setListComponents(array_reverse($values));
 278                                 break;
 279                             case 3:
 280                                 $group->setListComponents([$values[1], $values[0], $values[1], $values[2]]);
 281                                 break;
 282                             case 4:
 283                                 $group->setListComponents([$values[1], $values[0], $values[3], $values[2]]);
 284                                 break;
 285                         }
 286                     }
 287                 }
 288             }
 289
 290         } else if (preg_match('/shadow/i', $property)) {
 291             // TODO Fix upstream, each shadow should be in a RuleValueList.
 292             if ($value instanceof RuleValueList) {
 293                 // negate($value->getListComponents()[0]);
 294             }
 295
 296         } else if (preg_match('/transform-origin/i', $property)) {
 297             $this->processTransformOrigin($rule);
 298
 299         } else if (preg_match('/^(?!text\-).*?transform$/i', $property)) {
 300             // TODO Parse function parameters first.
 301
 302         } else if (preg_match('/background(-position(-x)?|-image)?$/i', $property)) {
 303             $this->processBackground($rule);
 304
 305         } else if (preg_match('/cursor/i', $property)) {
 306             $hasList = false;
 307
 308             $parts = [$value];
 309             if ($value instanceof RuleValueList) {
 310                 $hastList = true;
 311                 $parts = $value->getListComponents();
 312             }
 313
 314             foreach ($parts as $key => $part) {
 315                 if (!is_object($part)) {
 316                     $parts[$key] = preg_replace_callback('/\b(ne|nw|se|sw|nesw|nwse)-resize/', function($matches) {
 317                         return str_replace($matches[1], str_replace(['e', 'w', '*'], ['*', 'e', 'w'], $matches[1]), $matches[0]);
 318                     }, $part);
 319                 }
 320             }
 321
 322             if ($hasList) {
 323                 $value->setListComponents($parts);
 324             } else {
 325                 $rule->setValue($parts[0]);
 326             }
 327
 328         }
 329
 330     }
 331
 332     protected function processTransformOrigin(Rule $rule) {
 333         $value = $rule->getValue();
 334         $foundLeftOrRight = false;
 335
 336         // Search for left or right.
 337         $parts = [$value];
 338         if ($value instanceof RuleValueList) {
 339             $parts = $value->getListComponents();
 340             $isInList = true;
 341         }
 342         foreach ($parts as $key => $part) {
 343             if (!is_object($part) && preg_match('/left|right/i', $part)) {
 344                 $foundLeftOrRight = true;
 345                 $parts[$key] = $this->swapLeftRight($part);
 346             }
 347         }
 348
 349         if ($foundLeftOrRight) {
 350             // We need to reconstruct the value because left/right are not represented by an object.
 351             $list = new RuleValueList(' ');
 352             $list->setListComponents($parts);
 353             $rule->setValue($list);
 354
 355         } else {
 356
 357             $value = $parts[0];
 358             // The first value may be referencing top or bottom (y instead of x).
 359             if (!is_object($value) && preg_match('/top|bottom/i', $value) && count($parts)>1) {
 360                 $value = $parts[1];
 361             }
 362
 363             // Flip the value.
 364             if ($value instanceof Size) {
 365
 366                 if ($value->getSize() == 0) {
 367                     $value->setSize(100);
 368                     $value->setUnit('%');
 369
 370                 } else if ($value->getUnit() === '%') {
 371                     $this->complement($value);
 372                 }
 373
 374             } else if ($value instanceof CSSFunction && strpos($value->getName(), 'calc') !== false) {
 375                 // TODO Fix upstream calc parsing.
 376                 $this->complement($value);
 377             }
 378         }
 379     }
 380
 381     protected function shouldAddCss() {
 382         if (!empty($this->shouldAddCss)) {
 383             $css = $this->shouldAddCss;
 384             $this->shouldAddCss = [];
 385             return $css;
 386         }
 387         return [];
 388     }
 389
 390     protected function shouldIgnoreNext() {
 391         if ($this->shouldIgnore) {
 392             if (is_int($this->shouldIgnore)) {
 393                 $this->shouldIgnore--;
 394             }
 395             return true;
 396         }
 397         return false;
 398     }
 399
 400     protected function shouldRemoveNext() {
 401         if ($this->shouldRemove) {
 402             if (is_int($this->shouldRemove)) {
 403                 $this->shouldRemove--;
 404             }
 405             return true;
 406         }
 407         return false;
 408     }
 409
 410     protected function swap($value, $a, $b, $options = ['scope' => '*', 'ignoreCase' => true]) {
 411         $expr = preg_quote($a) . '|' . preg_quote($b);
 412         if (!empty($options['greedy'])) {
 413             $expr = '\\b(' . $expr . ')\\b';
 414         }
 415         $flags = !empty($options['ignoreCase']) ? 'im' : 'm';
 416         $expr = "/$expr/$flags";
 417         return preg_replace_callback($expr, function($matches) use ($a, $b, $options) {
 418             return $this->compare($matches[0], $a, !empty($options['ignoreCase'])) ? $b : $a;
 419         }, $value);
 420     }
 421
 422     protected function swapLeftRight($value) {
 423         return $this->swap($value, 'left', 'right');
 424     }
 425
 426     protected function swapLtrRtl($value) {
 427         return $this->swap($value, 'ltr', 'rtl');
 428     }
 429
 430 }