[CLEANUP] Avoid Hungarian notation for oRule/oRuleSet

oliverklee · oliverklee · commit b06f903271e2 · 2025-01-27T23:50:51.000+01:00
Part of #756
diff --git a/src/CSSList/CSSBlockList.php b/src/CSSList/CSSBlockList.php
@@ -73,8 +73,8 @@ protected function allValues(
                 $this->allValues($oContent, $result, $searchString, $searchInFunctionArguments);
             }
         } elseif ($element instanceof RuleSet) {
-            foreach ($element->getRules($searchString) as $oRule) {
-                $this->allValues($oRule, $result, $searchString, $searchInFunctionArguments);
+            foreach ($element->getRules($searchString) as $rule) {
+                $this->allValues($rule, $result, $searchString, $searchInFunctionArguments);
             }
         } elseif ($element instanceof Rule) {
             $this->allValues($element->getValue(), $result, $searchString, $searchInFunctionArguments);
diff --git a/src/Rule/Rule.php b/src/Rule/Rule.php
@@ -79,20 +79,20 @@ public function __construct($sRule, $lineNumber = 0, $iColNo = 0)
     public static function parse(ParserState $parserState): Rule
     {
         $aComments = $parserState->consumeWhiteSpace();
-        $oRule = new Rule(
+        $rule = new Rule(
             $parserState->parseIdentifier(!$parserState->comes('--')),
             $parserState->currentLine(),
             $parserState->currentColumn()
         );
-        $oRule->setComments($aComments);
-        $oRule->addComments($parserState->consumeWhiteSpace());
+        $rule->setComments($aComments);
+        $rule->addComments($parserState->consumeWhiteSpace());
         $parserState->consume(':');
-        $oValue = Value::parseValue($parserState, self::listDelimiterForRule($oRule->getRule()));
-        $oRule->setValue($oValue);
+        $oValue = Value::parseValue($parserState, self::listDelimiterForRule($rule->getRule()));
+        $rule->setValue($oValue);
         if ($parserState->getSettings()->bLenientParsing) {
             while ($parserState->comes('\\')) {
                 $parserState->consume('\\');
-                $oRule->addIeHack($parserState->consume());
+                $rule->addIeHack($parserState->consume());
                 $parserState->consumeWhiteSpace();
             }
         }
@@ -101,7 +101,7 @@ public static function parse(ParserState $parserState): Rule
             $parserState->consume('!');
             $parserState->consumeWhiteSpace();
             $parserState->consume('important');
-            $oRule->setIsImportant(true);
+            $rule->setIsImportant(true);
         }
         $parserState->consumeWhiteSpace();
         while ($parserState->comes(';')) {
@@ -110,7 +110,7 @@ public static function parse(ParserState $parserState): Rule
 
         $parserState->consumeWhiteSpace();
 
-        return $oRule;
+        return $rule;
     }
 
     /**
diff --git a/src/RuleSet/RuleSet.php b/src/RuleSet/RuleSet.php
@@ -53,16 +53,16 @@ public function __construct($lineNumber = 0)
      * @throws UnexpectedTokenException
      * @throws UnexpectedEOFException
      */
-    public static function parseRuleSet(ParserState $parserState, RuleSet $oRuleSet): void
+    public static function parseRuleSet(ParserState $parserState, RuleSet $ruleSet): void
     {
         while ($parserState->comes(';')) {
             $parserState->consume(';');
         }
         while (!$parserState->comes('}')) {
-            $oRule = null;
+            $rule = null;
             if ($parserState->getSettings()->bLenientParsing) {
                 try {
-                    $oRule = Rule::parse($parserState);
+                    $rule = Rule::parse($parserState);
                 } catch (UnexpectedTokenException $e) {
                     try {
                         $sConsume = $parserState->consumeUntil(["\n", ';', '}'], true);
@@ -80,10 +80,10 @@ public static function parseRuleSet(ParserState $parserState, RuleSet $oRuleSet)
                     }
                 }
             } else {
-                $oRule = Rule::parse($parserState);
+                $rule = Rule::parse($parserState);
             }
-            if ($oRule instanceof Rule) {
-                $oRuleSet->addRule($oRule);
+            if ($rule instanceof Rule) {
+                $ruleSet->addRule($rule);
             }
         }
         $parserState->consume('}');
@@ -100,9 +100,9 @@ public function getLineNo()
     /**
      * @param Rule|null $oSibling
      */
-    public function addRule(Rule $oRule, ?Rule $oSibling = null): void
+    public function addRule(Rule $rule, ?Rule $oSibling = null): void
     {
-        $sRule = $oRule->getRule();
+        $sRule = $rule->getRule();
         if (!isset($this->aRules[$sRule])) {
             $this->aRules[$sRule] = [];
         }
@@ -113,28 +113,28 @@ public function addRule(Rule $oRule, ?Rule $oSibling = null): void
             $iSiblingPos = \array_search($oSibling, $this->aRules[$sRule], true);
             if ($iSiblingPos !== false) {
                 $iPosition = $iSiblingPos;
-                $oRule->setPosition($oSibling->getLineNo(), $oSibling->getColNo() - 1);
+                $rule->setPosition($oSibling->getLineNo(), $oSibling->getColNo() - 1);
             }
         }
-        if ($oRule->getLineNo() === 0 && $oRule->getColNo() === 0) {
+        if ($rule->getLineNo() === 0 && $rule->getColNo() === 0) {
             //this node is added manually, give it the next best line
             $rules = $this->getRules();
             $pos = \count($rules);
             if ($pos > 0) {
                 $last = $rules[$pos - 1];
-                $oRule->setPosition($last->getLineNo() + 1, 0);
+                $rule->setPosition($last->getLineNo() + 1, 0);
             }
         }
 
-        \array_splice($this->aRules[$sRule], $iPosition, 0, [$oRule]);
+        \array_splice($this->aRules[$sRule], $iPosition, 0, [$rule]);
     }
 
     /**
      * Returns all rules matching the given rule name
      *
-     * @example $oRuleSet->getRules('font') // returns array(0 => $oRule, …) or array().
+     * @example $ruleSet->getRules('font') // returns array(0 => $rule, …) or array().
      *
-     * @example $oRuleSet->getRules('font-')
+     * @example $ruleSet->getRules('font-')
      *          //returns an array of all rules either beginning with font- or matching font.
      *
      * @param Rule|string|null $mRule
@@ -206,8 +206,8 @@ public function getRulesAssoc($mRule = null)
     {
         /** @var array<string, Rule> $aResult */
         $aResult = [];
-        foreach ($this->getRules($mRule) as $oRule) {
-            $aResult[$oRule->getRule()] = $oRule;
+        foreach ($this->getRules($mRule) as $rule) {
+            $aResult[$rule->getRule()] = $rule;
         }
         return $aResult;
     }
@@ -219,7 +219,7 @@ public function getRulesAssoc($mRule = null)
      * If given a name, it will remove all rules by that name.
      *
      * Note: this is different from pre-v.2.0 behaviour of PHP-CSS-Parser, where passing a Rule instance would
-     * remove all rules with the same name. To get the old behaviour, use `removeRule($oRule->getRule())`.
+     * remove all rules with the same name. To get the old behaviour, use `removeRule($rule->getRule())`.
      *
      * @param Rule|string|null $mRule
      *        pattern to remove. If $mRule is null, all rules are removed. If the pattern ends in a dash,
@@ -233,8 +233,8 @@ public function removeRule($mRule): void
             if (!isset($this->aRules[$sRule])) {
                 return;
             }
-            foreach ($this->aRules[$sRule] as $iKey => $oRule) {
-                if ($oRule === $mRule) {
+            foreach ($this->aRules[$sRule] as $iKey => $rule) {
+                if ($rule === $mRule) {
                     unset($this->aRules[$sRule][$iKey]);
                 }
             }
@@ -268,9 +268,9 @@ protected function renderRules(OutputFormat $oOutputFormat)
         $bIsFirst = true;
         $oNextLevel = $oOutputFormat->nextLevel();
         foreach ($this->aRules as $aRules) {
-            foreach ($aRules as $oRule) {
-                $sRendered = $oNextLevel->safely(function () use ($oRule, $oNextLevel) {
-                    return $oRule->render($oNextLevel);
+            foreach ($aRules as $rule) {
+                $sRendered = $oNextLevel->safely(function () use ($rule, $oNextLevel) {
+                    return $rule->render($oNextLevel);
                 });
                 if ($sRendered === null) {
                     continue;

Original file line number	Diff line number	Diff line change
`@@ -73,8 +73,8 @@ protected function allValues(`
`73`	`73`	`$this->allValues($oContent, $result, $searchString, $searchInFunctionArguments);`
`74`	`74`	`}`
`75`	`75`	`} elseif ($element instanceof RuleSet) {`
`76`		`- foreach ($element->getRules($searchString) as $oRule) {`
`77`		`- $this->allValues($oRule, $result, $searchString, $searchInFunctionArguments);`
	`76`	`+ foreach ($element->getRules($searchString) as $rule) {`
	`77`	`+ $this->allValues($rule, $result, $searchString, $searchInFunctionArguments);`
`78`	`78`	`}`
`79`	`79`	`} elseif ($element instanceof Rule) {`
`80`	`80`	`$this->allValues($element->getValue(), $result, $searchString, $searchInFunctionArguments);`
Original file line number	Diff line number	Diff line change
`@@ -53,16 +53,16 @@ public function __construct($lineNumber = 0)`
`53`	`53`	`* @throws UnexpectedTokenException`
`54`	`54`	`* @throws UnexpectedEOFException`
`55`	`55`	`*/`
`56`		`- public static function parseRuleSet(ParserState $parserState, RuleSet $oRuleSet): void`
	`56`	`+ public static function parseRuleSet(ParserState $parserState, RuleSet $ruleSet): void`
`57`	`57`	`{`
`58`	`58`	`while ($parserState->comes(';')) {`
`59`	`59`	`$parserState->consume(';');`
`60`	`60`	`}`
`61`	`61`	`while (!$parserState->comes('}')) {`
`62`		`- $oRule = null;`
	`62`	`+ $rule = null;`
`63`	`63`	`if ($parserState->getSettings()->bLenientParsing) {`
`64`	`64`	`try {`
`65`		`- $oRule = Rule::parse($parserState);`
	`65`	`+ $rule = Rule::parse($parserState);`
`66`	`66`	`} catch (UnexpectedTokenException $e) {`
`67`	`67`	`try {`
`68`	`68`	`$sConsume = $parserState->consumeUntil(["\n", ';', '}'], true);`
`@@ -80,10 +80,10 @@ public static function parseRuleSet(ParserState $parserState, RuleSet $oRuleSet)`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`} else {`
`83`		`- $oRule = Rule::parse($parserState);`
	`83`	`+ $rule = Rule::parse($parserState);`
`84`	`84`	`}`
`85`		`- if ($oRule instanceof Rule) {`
`86`		`- $oRuleSet->addRule($oRule);`
	`85`	`+ if ($rule instanceof Rule) {`
	`86`	`+ $ruleSet->addRule($rule);`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`	`$parserState->consume('}');`
`@@ -100,9 +100,9 @@ public function getLineNo()`
`100`	`100`	`/**`
`101`	`101`	`* @param Rule\|null $oSibling`
`102`	`102`	`*/`
`103`		`- public function addRule(Rule $oRule, ?Rule $oSibling = null): void`
	`103`	`+ public function addRule(Rule $rule, ?Rule $oSibling = null): void`
`104`	`104`	`{`
`105`		`- $sRule = $oRule->getRule();`
	`105`	`+ $sRule = $rule->getRule();`
`106`	`106`	`if (!isset($this->aRules[$sRule])) {`
`107`	`107`	`$this->aRules[$sRule] = [];`
`108`	`108`	`}`
`@@ -113,28 +113,28 @@ public function addRule(Rule $oRule, ?Rule $oSibling = null): void`
`113`	`113`	`$iSiblingPos = \array_search($oSibling, $this->aRules[$sRule], true);`
`114`	`114`	`if ($iSiblingPos !== false) {`
`115`	`115`	`$iPosition = $iSiblingPos;`
`116`		`- $oRule->setPosition($oSibling->getLineNo(), $oSibling->getColNo() - 1);`
	`116`	`+ $rule->setPosition($oSibling->getLineNo(), $oSibling->getColNo() - 1);`
`117`	`117`	`}`
`118`	`118`	`}`
`119`		`- if ($oRule->getLineNo() === 0 && $oRule->getColNo() === 0) {`
	`119`	`+ if ($rule->getLineNo() === 0 && $rule->getColNo() === 0) {`
`120`	`120`	`//this node is added manually, give it the next best line`
`121`	`121`	`$rules = $this->getRules();`
`122`	`122`	`$pos = \count($rules);`
`123`	`123`	`if ($pos > 0) {`
`124`	`124`	`$last = $rules[$pos - 1];`
`125`		`- $oRule->setPosition($last->getLineNo() + 1, 0);`
	`125`	`+ $rule->setPosition($last->getLineNo() + 1, 0);`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`- \array_splice($this->aRules[$sRule], $iPosition, 0, [$oRule]);`
	`129`	`+ \array_splice($this->aRules[$sRule], $iPosition, 0, [$rule]);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`/**`
`133`	`133`	`* Returns all rules matching the given rule name`
`134`	`134`	`*`
`135`		`- * @example $oRuleSet->getRules('font') // returns array(0 => $oRule, …) or array().`
	`135`	`+ * @example $ruleSet->getRules('font') // returns array(0 => $rule, …) or array().`
`136`	`136`	`*`
`137`		`- * @example $oRuleSet->getRules('font-')`
	`137`	`+ * @example $ruleSet->getRules('font-')`
`138`	`138`	`* //returns an array of all rules either beginning with font- or matching font.`
`139`	`139`	`*`
`140`	`140`	`* @param Rule\|string\|null $mRule`
`@@ -206,8 +206,8 @@ public function getRulesAssoc($mRule = null)`
`206`	`206`	`{`
`207`	`207`	`/** @var array<string, Rule> $aResult */`
`208`	`208`	`$aResult = [];`
`209`		`- foreach ($this->getRules($mRule) as $oRule) {`
`210`		`- $aResult[$oRule->getRule()] = $oRule;`
	`209`	`+ foreach ($this->getRules($mRule) as $rule) {`
	`210`	`+ $aResult[$rule->getRule()] = $rule;`
`211`	`211`	`}`
`212`	`212`	`return $aResult;`
`213`	`213`	`}`
`@@ -219,7 +219,7 @@ public function getRulesAssoc($mRule = null)`
`219`	`219`	`* If given a name, it will remove all rules by that name.`
`220`	`220`	`*`
`221`	`221`	`* Note: this is different from pre-v.2.0 behaviour of PHP-CSS-Parser, where passing a Rule instance would`
`222`		- * remove all rules with the same name. To get the old behaviour, use `removeRule($oRule->getRule())`.
	`222`	+ * remove all rules with the same name. To get the old behaviour, use `removeRule($rule->getRule())`.
`223`	`223`	`*`
`224`	`224`	`* @param Rule\|string\|null $mRule`
`225`	`225`	`* pattern to remove. If $mRule is null, all rules are removed. If the pattern ends in a dash,`
`@@ -233,8 +233,8 @@ public function removeRule($mRule): void`
`233`	`233`	`if (!isset($this->aRules[$sRule])) {`
`234`	`234`	`return;`
`235`	`235`	`}`
`236`		`- foreach ($this->aRules[$sRule] as $iKey => $oRule) {`
`237`		`- if ($oRule === $mRule) {`
	`236`	`+ foreach ($this->aRules[$sRule] as $iKey => $rule) {`
	`237`	`+ if ($rule === $mRule) {`
`238`	`238`	`unset($this->aRules[$sRule][$iKey]);`
`239`	`239`	`}`
`240`	`240`	`}`
`@@ -268,9 +268,9 @@ protected function renderRules(OutputFormat $oOutputFormat)`
`268`	`268`	`$bIsFirst = true;`
`269`	`269`	`$oNextLevel = $oOutputFormat->nextLevel();`
`270`	`270`	`foreach ($this->aRules as $aRules) {`
`271`		`- foreach ($aRules as $oRule) {`
`272`		`- $sRendered = $oNextLevel->safely(function () use ($oRule, $oNextLevel) {`
`273`		`- return $oRule->render($oNextLevel);`
	`271`	`+ foreach ($aRules as $rule) {`
	`272`	`+ $sRendered = $oNextLevel->safely(function () use ($rule, $oNextLevel) {`
	`273`	`+ return $rule->render($oNextLevel);`
`274`	`274`	`});`
`275`	`275`	`if ($sRendered === null) {`
`276`	`276`	`continue;`