arthurkushman / querypath

src/CSS/Traverser.php

Indentation +26 added lines, -26 removed lines

@@ -11,31 +11,31 @@
  */
 interface Traverser
 {
-	/**
-	 * Process a CSS selector and find matches.
-	 *
-	 * This specifies a query to be run by the Traverser. A given
-	 * Traverser may, in practice, delay the finding until some later time
-	 * but must return the found results when getMatches() is called.
-	 *
-	 * @param string $selector
-	 *   A selector. Typically this is a CSS 3 Selector.
-	 *
-	 * @return \Traverser
-	 *  The Traverser that can return matches.
-	 */
-	public function find($selector);
+    /**
+     * Process a CSS selector and find matches.
+     *
+     * This specifies a query to be run by the Traverser. A given
+     * Traverser may, in practice, delay the finding until some later time
+     * but must return the found results when getMatches() is called.
+     *
+     * @param string $selector
+     *   A selector. Typically this is a CSS 3 Selector.
+     *
+     * @return \Traverser
+     *  The Traverser that can return matches.
+     */
+    public function find($selector);
 
-	/**
-	 * Get the results of a find() operation.
-	 *
-	 * Return an array of matching items.
-	 *
-	 * @return array
-	 *   An array of matched values. The specific data type in the matches
-	 *   will differ depending on the data type searched, but in the core
-	 *   QueryPath implementation, this will be an array of DOMNode
-	 *   objects.
-	 */
-	public function matches();
+    /**
+     * Get the results of a find() operation.
+     *
+     * Return an array of matching items.
+     *
+     * @return array
+     *   An array of matched values. The specific data type in the matches
+     *   will differ depending on the data type searched, but in the core
+     *   QueryPath implementation, this will be an array of DOMNode
+     *   objects.
+     */
+    public function matches();
 }

src/CSS/Token.php

Indentation +64 added lines, -64 removed lines

@@ -14,74 +14,74 @@
  */
 final class Token
 {
-	public const CHAR = 0x0;
-	public const STAR = 0x1;
-	public const RANGLE = 0x2;
-	public const DOT = 0x3;
-	public const OCTO = 0x4;
-	public const RSQUARE = 0x5;
-	public const LSQUARE = 0x6;
-	public const COLON = 0x7;
-	public const RPAREN = 0x8;
-	public const LPAREN = 0x9;
-	public const PLUS = 0xA;
-	public const TILDE = 0xB;
-	public const EQ = 0xC;
-	public const PIPE = 0xD;
-	public const COMMA = 0xE;
-	public const WHITE = 0xF;
-	public const QUOTE = 0x10;
-	public const SQUOTE = 0x11;
-	public const BSLASH = 0x12;
-	public const CARAT = 0x13;
-	public const DOLLAR = 0x14;
-	public const AT = 0x15; // This is not in the spec. Apparently, old broken CSS uses it.
+    public const CHAR = 0x0;
+    public const STAR = 0x1;
+    public const RANGLE = 0x2;
+    public const DOT = 0x3;
+    public const OCTO = 0x4;
+    public const RSQUARE = 0x5;
+    public const LSQUARE = 0x6;
+    public const COLON = 0x7;
+    public const RPAREN = 0x8;
+    public const LPAREN = 0x9;
+    public const PLUS = 0xA;
+    public const TILDE = 0xB;
+    public const EQ = 0xC;
+    public const PIPE = 0xD;
+    public const COMMA = 0xE;
+    public const WHITE = 0xF;
+    public const QUOTE = 0x10;
+    public const SQUOTE = 0x11;
+    public const BSLASH = 0x12;
+    public const CARAT = 0x13;
+    public const DOLLAR = 0x14;
+    public const AT = 0x15; // This is not in the spec. Apparently, old broken CSS uses it.
 
-	// In legal range for string.
-	public const STRING_LEGAL = 0x63;
+    // In legal range for string.
+    public const STRING_LEGAL = 0x63;
 
-	/**
-	 * Get a name for a given constant. Used for error handling.
-	 */
-	public static function name($const_int)
-	{
-		$a = [
-			'character',
-			'star',
-			'right angle bracket',
-			'dot',
-			'octothorp',
-			'right square bracket',
-			'left square bracket',
-			'colon',
-			'right parenthesis',
-			'left parenthesis',
-			'plus',
-			'tilde',
-			'equals',
-			'vertical bar',
-			'comma',
-			'space',
-			'quote',
-			'single quote',
-			'backslash',
-			'carat',
-			'dollar',
-			'at',
-		];
+    /**
+     * Get a name for a given constant. Used for error handling.
+     */
+    public static function name($const_int)
+    {
+        $a = [
+            'character',
+            'star',
+            'right angle bracket',
+            'dot',
+            'octothorp',
+            'right square bracket',
+            'left square bracket',
+            'colon',
+            'right parenthesis',
+            'left parenthesis',
+            'plus',
+            'tilde',
+            'equals',
+            'vertical bar',
+            'comma',
+            'space',
+            'quote',
+            'single quote',
+            'backslash',
+            'carat',
+            'dollar',
+            'at',
+        ];
 
-		if (isset($a[$const_int]) && is_numeric($const_int)) {
-			return $a[$const_int];
-		}
+        if (isset($a[$const_int]) && is_numeric($const_int)) {
+            return $a[$const_int];
+        }
 
-		if ($const_int === self::STRING_LEGAL) {
-			return 'a legal non-alphanumeric character';
-		}
+        if ($const_int === self::STRING_LEGAL) {
+            return 'a legal non-alphanumeric character';
+        }
 
-		if ($const_int === false) {
-			return 'end of file';
-		}
+        if ($const_int === false) {
+            return 'end of file';
+        }
 
-		return sprintf('illegal character (%s)', $const_int);
-	}
+        return sprintf('illegal character (%s)', $const_int);
+    }
 }

src/CSS/Selector.php

Indentation +129 added lines, -129 removed lines

@@ -54,133 +54,133 @@
 class Selector implements EventHandler, IteratorAggregate, Countable
 {
 
-	protected $selectors = [];
-	protected $currSelector;
-	protected $selectorGroups = [];
-	protected $groupIndex = 0;
-
-	public function __construct()
-	{
-		$this->currSelector = new SimpleSelector();
-
-		$this->selectors[$this->groupIndex][] = $this->currSelector;
-	}
-
-	public function getIterator(): Traversable
-	{
-		return new ArrayIterator($this->selectors);
-	}
-
-	/**
-	 * Get the array of SimpleSelector objects.
-	 *
-	 * Normally, one iterates over a Selector. However, if it is
-	 * necessary to get the selector array and manipulate it, this
-	 * method can be used.
-	 */
-	public function toArray()
-	{
-		return $this->selectors;
-	}
-
-	public function count(): int
-	{
-		return count($this->selectors);
-	}
-
-	public function elementID($id)
-	{
-		$this->currSelector->id = $id;
-	}
-
-	public function element($name)
-	{
-		$this->currSelector->element = $name;
-	}
-
-	public function elementNS($name, $namespace = null)
-	{
-		$this->currSelector->ns      = $namespace;
-		$this->currSelector->element = $name;
-	}
-
-	public function anyElement()
-	{
-		$this->currSelector->element = '*';
-	}
-
-	public function anyElementInNS($ns)
-	{
-		$this->currSelector->ns      = $ns;
-		$this->currSelector->element = '*';
-	}
-
-	public function elementClass($name)
-	{
-		$this->currSelector->classes[] = $name;
-	}
-
-	public function attribute($name, $value = null, $operation = EventHandler::IS_EXACTLY)
-	{
-		$this->currSelector->attributes[] = [
-			'name'  => $name,
-			'value' => $value,
-			'op'    => $operation,
-		];
-	}
-
-	public function attributeNS($name, $ns, $value = null, $operation = EventHandler::IS_EXACTLY)
-	{
-		$this->currSelector->attributes[] = [
-			'name'  => $name,
-			'value' => $value,
-			'op'    => $operation,
-			'ns'    => $ns,
-		];
-	}
-
-	public function pseudoClass($name, $value = null)
-	{
-		$this->currSelector->pseudoClasses[] = ['name' => $name, 'value' => $value];
-	}
-
-	public function pseudoElement($name)
-	{
-		$this->currSelector->pseudoElements[] = $name;
-	}
-
-	public function combinator($combinatorName)
-	{
-		$this->currSelector->combinator = $combinatorName;
-		$this->currSelector             = new SimpleSelector();
-		array_unshift($this->selectors[$this->groupIndex], $this->currSelector);
-		//$this->selectors[]= $this->currSelector;
-	}
-
-	public function directDescendant()
-	{
-		$this->combinator(SimpleSelector::DIRECT_DESCENDANT);
-	}
-
-	public function adjacent()
-	{
-		$this->combinator(SimpleSelector::ADJACENT);
-	}
-
-	public function anotherSelector()
-	{
-		$this->groupIndex++;
-		$this->currSelector                 = new SimpleSelector();
-		$this->selectors[$this->groupIndex] = [$this->currSelector];
-	}
-
-	public function sibling()
-	{
-		$this->combinator(SimpleSelector::SIBLING);
-	}
-
-	public function anyDescendant()
-	{
-		$this->combinator(SimpleSelector::ANY_DESCENDANT);
-	}
+    protected $selectors = [];
+    protected $currSelector;
+    protected $selectorGroups = [];
+    protected $groupIndex = 0;
+
+    public function __construct()
+    {
+        $this->currSelector = new SimpleSelector();
+
+        $this->selectors[$this->groupIndex][] = $this->currSelector;
+    }
+
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->selectors);
+    }
+
+    /**
+     * Get the array of SimpleSelector objects.
+     *
+     * Normally, one iterates over a Selector. However, if it is
+     * necessary to get the selector array and manipulate it, this
+     * method can be used.
+     */
+    public function toArray()
+    {
+        return $this->selectors;
+    }
+
+    public function count(): int
+    {
+        return count($this->selectors);
+    }
+
+    public function elementID($id)
+    {
+        $this->currSelector->id = $id;
+    }
+
+    public function element($name)
+    {
+        $this->currSelector->element = $name;
+    }
+
+    public function elementNS($name, $namespace = null)
+    {
+        $this->currSelector->ns      = $namespace;
+        $this->currSelector->element = $name;
+    }
+
+    public function anyElement()
+    {
+        $this->currSelector->element = '*';
+    }
+
+    public function anyElementInNS($ns)
+    {
+        $this->currSelector->ns      = $ns;
+        $this->currSelector->element = '*';
+    }
+
+    public function elementClass($name)
+    {
+        $this->currSelector->classes[] = $name;
+    }
+
+    public function attribute($name, $value = null, $operation = EventHandler::IS_EXACTLY)
+    {
+        $this->currSelector->attributes[] = [
+            'name'  => $name,
+            'value' => $value,
+            'op'    => $operation,
+        ];
+    }
+
+    public function attributeNS($name, $ns, $value = null, $operation = EventHandler::IS_EXACTLY)
+    {
+        $this->currSelector->attributes[] = [
+            'name'  => $name,
+            'value' => $value,
+            'op'    => $operation,
+            'ns'    => $ns,
+        ];
+    }
+
+    public function pseudoClass($name, $value = null)
+    {
+        $this->currSelector->pseudoClasses[] = ['name' => $name, 'value' => $value];
+    }
+
+    public function pseudoElement($name)
+    {
+        $this->currSelector->pseudoElements[] = $name;
+    }
+
+    public function combinator($combinatorName)
+    {
+        $this->currSelector->combinator = $combinatorName;
+        $this->currSelector             = new SimpleSelector();
+        array_unshift($this->selectors[$this->groupIndex], $this->currSelector);
+        //$this->selectors[]= $this->currSelector;
+    }
+
+    public function directDescendant()
+    {
+        $this->combinator(SimpleSelector::DIRECT_DESCENDANT);
+    }
+
+    public function adjacent()
+    {
+        $this->combinator(SimpleSelector::ADJACENT);
+    }
+
+    public function anotherSelector()
+    {
+        $this->groupIndex++;
+        $this->currSelector                 = new SimpleSelector();
+        $this->selectors[$this->groupIndex] = [$this->currSelector];
+    }
+
+    public function sibling()
+    {
+        $this->combinator(SimpleSelector::SIBLING);
+    }
+
+    public function anyDescendant()
+    {
+        $this->combinator(SimpleSelector::ANY_DESCENDANT);
+    }
 }

src/CSS/DOMTraverser.php

Indentation +814 added lines, -814 removed lines

@@ -60,166 +60,166 @@ 
  */
 class DOMTraverser implements Traverser
 {
-	protected $matches = [];
-	protected $selector;
-	protected $dom;
-	protected $initialized = true;
-	protected $psHandler;
-	protected $scopeNode;
-
-	/**
-	 * Build a new DOMTraverser.
-	 *
-	 * This requires a DOM-like object or collection of DOM nodes.
-	 *
-	 * @param SplObjectStorage $splos
-	 * @param bool             $initialized
-	 * @param null             $scopeNode
-	 */
-	public function __construct(SplObjectStorage $splos, bool $initialized = false, $scopeNode = null)
-	{
-		$this->psHandler   = new PseudoClass();
-		$this->initialized = $initialized;
-
-		// Re-use the initial splos
-		$this->matches = $splos;
-
-		if (count($splos) !== 0) {
-			$splos->rewind();
-			$first = $splos->current();
-			if ($first instanceof DOMDocument) {
-				$this->dom = $first;//->documentElement;
-			} else {
-				$this->dom = $first->ownerDocument;//->documentElement;
-			}
-
-			$this->scopeNode = $scopeNode;
-			if (empty($scopeNode)) {
-				$this->scopeNode = $this->dom->documentElement;
-			}
-		}
-
-		// This assumes a DOM. Need to also accomodate the case
-		// where we get a set of elements.
-		/*
+    protected $matches = [];
+    protected $selector;
+    protected $dom;
+    protected $initialized = true;
+    protected $psHandler;
+    protected $scopeNode;
+
+    /**
+     * Build a new DOMTraverser.
+     *
+     * This requires a DOM-like object or collection of DOM nodes.
+     *
+     * @param SplObjectStorage $splos
+     * @param bool             $initialized
+     * @param null             $scopeNode
+     */
+    public function __construct(SplObjectStorage $splos, bool $initialized = false, $scopeNode = null)
+    {
+        $this->psHandler   = new PseudoClass();
+        $this->initialized = $initialized;
+
+        // Re-use the initial splos
+        $this->matches = $splos;
+
+        if (count($splos) !== 0) {
+            $splos->rewind();
+            $first = $splos->current();
+            if ($first instanceof DOMDocument) {
+                $this->dom = $first;//->documentElement;
+            } else {
+                $this->dom = $first->ownerDocument;//->documentElement;
+            }
+
+            $this->scopeNode = $scopeNode;
+            if (empty($scopeNode)) {
+                $this->scopeNode = $this->dom->documentElement;
+            }
+        }
+
+        // This assumes a DOM. Need to also accomodate the case
+        // where we get a set of elements.
+        /*
 		$this->dom = $dom;
 		$this->matches = new \SplObjectStorage();
 		$this->matches->attach($this->dom);
 		 */
-	}
-
-	public function debug($msg)
-	{
-		fwrite(STDOUT, PHP_EOL . $msg);
-	}
-
-	/**
-	 * Given a selector, find the matches in the given DOM.
-	 *
-	 * This is the main function for querying the DOM using a CSS
-	 * selector.
-	 *
-	 * @param string $selector
-	 *   The selector.
-	 *
-	 * @return DOMTraverser a list of matched
-	 *   DOMNode objects.
-	 * @throws ParseException
-	 */
-	public function find($selector): DOMTraverser
-	{
-		// Setup
-		$handler = new Selector();
-		$parser  = new Parser($selector, $handler);
-		$parser->parse();
-		$this->selector = $handler;
-
-		//$selector = $handler->toArray();
-		$found = $this->newMatches();
-		foreach ($handler as $selectorGroup) {
-			// Initialize matches if necessary.
-			if ($this->initialized) {
-				$candidates = $this->matches;
-			} else {
-				$candidates = $this->initialMatch($selectorGroup[0], $this->matches);
-			}
-
-			/** @var DOMElement $candidate */
-			foreach ($candidates as $candidate) {
-				// fprintf(STDOUT, "Testing %s against %s.\n", $candidate->tagName, $selectorGroup[0]);
-				if ($this->matchesSelector($candidate, $selectorGroup)) {
-					// $this->debug('Attaching ' . $candidate->nodeName);
-					$found->attach($candidate);
-				}
-			}
-		}
-		$this->setMatches($found);
-
-		return $this;
-	}
-
-	public function matches()
-	{
-		return $this->matches;
-	}
-
-	/**
-	 * Check whether the given node matches the given selector.
-	 *
-	 * A selector is a group of one or more simple selectors combined
-	 * by combinators. This determines if a given selector
-	 * matches the given node.
-	 *
-	 * @attention
-	 * Evaluation of selectors is done recursively. Thus the length
-	 * of the selector is limited to the recursion depth allowed by
-	 * the PHP configuration. This should only cause problems for
-	 * absolutely huge selectors or for versions of PHP tuned to
-	 * strictly limit recursion depth.
-	 *
-	 * @param DOMElement $node
-	 *   The DOMNode to check.
-	 * @param             $selector
-	 *
-	 * @return boolean
-	 *   A boolean TRUE if the node matches, false otherwise.
-	 */
-	public function matchesSelector(DOMElement $node, $selector)
-	{
-		return $this->matchesSimpleSelector($node, $selector, 0);
-	}
-
-	/**
-	 * Performs a match check on a SimpleSelector.
-	 *
-	 * Where matchesSelector() does a check on an entire selector,
-	 * this checks only a simple selector (plus an optional
-	 * combinator).
-	 *
-	 * @param DOMElement $node
-	 * @param             $selectors
-	 * @param             $index
-	 *
-	 * @return boolean
-	 *   A boolean TRUE if the node matches, false otherwise.
-	 * @throws NotImplementedException
-	 */
-	public function matchesSimpleSelector(DOMElement $node, $selectors, $index)
-	{
-		$selector = $selectors[$index];
-		// Note that this will short circuit as soon as one of these
-		// returns FALSE.
-		$result = $this->matchElement($node, $selector->element, $selector->ns)
-				  && $this->matchAttributes($node, $selector->attributes)
-				  && $this->matchId($node, $selector->id)
-				  && $this->matchClasses($node, $selector->classes)
-				  && $this->matchPseudoClasses($node, $selector->pseudoClasses)
-				  && $this->matchPseudoElements($node, $selector->pseudoElements);
-
-		$isNextRule = isset($selectors[++$index]);
-		// If there is another selector, we process that if there a match
-		// hasn't been found.
-		/*
+    }
+
+    public function debug($msg)
+    {
+        fwrite(STDOUT, PHP_EOL . $msg);
+    }
+
+    /**
+     * Given a selector, find the matches in the given DOM.
+     *
+     * This is the main function for querying the DOM using a CSS
+     * selector.
+     *
+     * @param string $selector
+     *   The selector.
+     *
+     * @return DOMTraverser a list of matched
+     *   DOMNode objects.
+     * @throws ParseException
+     */
+    public function find($selector): DOMTraverser
+    {
+        // Setup
+        $handler = new Selector();
+        $parser  = new Parser($selector, $handler);
+        $parser->parse();
+        $this->selector = $handler;
+
+        //$selector = $handler->toArray();
+        $found = $this->newMatches();
+        foreach ($handler as $selectorGroup) {
+            // Initialize matches if necessary.
+            if ($this->initialized) {
+                $candidates = $this->matches;
+            } else {
+                $candidates = $this->initialMatch($selectorGroup[0], $this->matches);
+            }
+
+            /** @var DOMElement $candidate */
+            foreach ($candidates as $candidate) {
+                // fprintf(STDOUT, "Testing %s against %s.\n", $candidate->tagName, $selectorGroup[0]);
+                if ($this->matchesSelector($candidate, $selectorGroup)) {
+                    // $this->debug('Attaching ' . $candidate->nodeName);
+                    $found->attach($candidate);
+                }
+            }
+        }
+        $this->setMatches($found);
+
+        return $this;
+    }
+
+    public function matches()
+    {
+        return $this->matches;
+    }
+
+    /**
+     * Check whether the given node matches the given selector.
+     *
+     * A selector is a group of one or more simple selectors combined
+     * by combinators. This determines if a given selector
+     * matches the given node.
+     *
+     * @attention
+     * Evaluation of selectors is done recursively. Thus the length
+     * of the selector is limited to the recursion depth allowed by
+     * the PHP configuration. This should only cause problems for
+     * absolutely huge selectors or for versions of PHP tuned to
+     * strictly limit recursion depth.
+     *
+     * @param DOMElement $node
+     *   The DOMNode to check.
+     * @param             $selector
+     *
+     * @return boolean
+     *   A boolean TRUE if the node matches, false otherwise.
+     */
+    public function matchesSelector(DOMElement $node, $selector)
+    {
+        return $this->matchesSimpleSelector($node, $selector, 0);
+    }
+
+    /**
+     * Performs a match check on a SimpleSelector.
+     *
+     * Where matchesSelector() does a check on an entire selector,
+     * this checks only a simple selector (plus an optional
+     * combinator).
+     *
+     * @param DOMElement $node
+     * @param             $selectors
+     * @param             $index
+     *
+     * @return boolean
+     *   A boolean TRUE if the node matches, false otherwise.
+     * @throws NotImplementedException
+     */
+    public function matchesSimpleSelector(DOMElement $node, $selectors, $index)
+    {
+        $selector = $selectors[$index];
+        // Note that this will short circuit as soon as one of these
+        // returns FALSE.
+        $result = $this->matchElement($node, $selector->element, $selector->ns)
+                  && $this->matchAttributes($node, $selector->attributes)
+                  && $this->matchId($node, $selector->id)
+                  && $this->matchClasses($node, $selector->classes)
+                  && $this->matchPseudoClasses($node, $selector->pseudoClasses)
+                  && $this->matchPseudoElements($node, $selector->pseudoElements);
+
+        $isNextRule = isset($selectors[++$index]);
+        // If there is another selector, we process that if there a match
+        // hasn't been found.
+        /*
 		if ($isNextRule && $selectors[$index]->combinator == SimpleSelector::anotherSelector) {
 		  // We may need to re-initialize the match set for the next selector.
 		  if (!$this->initialized) {
@@ -231,457 +231,457 @@ 
 		// If we have a match and we have a combinator, we need to
 		// recurse up the tree.
 		else*/
-		if ($isNextRule && $result) {
-			$result = $this->combine($node, $selectors, $index);
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Combine the next selector with the given match
-	 * using the next combinator.
-	 *
-	 * If the next selector is combined with another
-	 * selector, that will be evaluated too, and so on.
-	 * So if this function returns TRUE, it means that all
-	 * child selectors are also matches.
-	 *
-	 * @param DOMNode $node
-	 *   The DOMNode to test.
-	 * @param array   $selectors
-	 *   The array of simple selectors.
-	 * @param int     $index
-	 *   The index of the current selector.
-	 *
-	 * @return boolean
-	 *   TRUE if the next selector(s) match.
-	 */
-	public function combine(DOMElement $node, $selectors, $index)
-	{
-		$selector = $selectors[$index];
-		//$this->debug(implode(' ', $selectors));
-		switch ($selector->combinator) {
-			case SimpleSelector::ADJACENT:
-				return $this->combineAdjacent($node, $selectors, $index);
-			case SimpleSelector::SIBLING:
-				return $this->combineSibling($node, $selectors, $index);
-			case SimpleSelector::DIRECT_DESCENDANT:
-				return $this->combineDirectDescendant($node, $selectors, $index);
-			case SimpleSelector::ANY_DESCENDANT:
-				return $this->combineAnyDescendant($node, $selectors, $index);
-			case SimpleSelector::ANOTHER_SELECTOR:
-				// fprintf(STDOUT, "Next selector: %s\n", $selectors[$index]);
-				return $this->matchesSimpleSelector($node, $selectors, $index);
-		}
-
-		return false;
-	}
-
-	/**
-	 * Process an Adjacent Sibling.
-	 *
-	 * The spec does not indicate whether Adjacent should ignore non-Element
-	 * nodes, so we choose to ignore them.
-	 *
-	 * @param DOMNode $node
-	 *   A DOM Node.
-	 * @param array   $selectors
-	 *   The selectors array.
-	 * @param int     $index
-	 *   The current index to the operative simple selector in the selectors
-	 *   array.
-	 *
-	 * @return boolean
-	 *   TRUE if the combination matches, FALSE otherwise.
-	 */
-	public function combineAdjacent($node, $selectors, $index)
-	{
-		while (! empty($node->previousSibling)) {
-			$node = $node->previousSibling;
-			if ($node->nodeType == XML_ELEMENT_NODE) {
-				//$this->debug(sprintf('Testing %s against "%s"', $node->tagName, $selectors[$index]));
-				return $this->matchesSimpleSelector($node, $selectors, $index);
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Check all siblings.
-	 *
-	 * According to the spec, this only tests elements LEFT of the provided
-	 * node.
-	 *
-	 * @param DOMNode $node
-	 *   A DOM Node.
-	 * @param array   $selectors
-	 *   The selectors array.
-	 * @param int     $index
-	 *   The current index to the operative simple selector in the selectors
-	 *   array.
-	 *
-	 * @return boolean
-	 *   TRUE if the combination matches, FALSE otherwise.
-	 */
-	public function combineSibling($node, $selectors, $index)
-	{
-		while (! empty($node->previousSibling)) {
-			$node = $node->previousSibling;
-			if ($node->nodeType == XML_ELEMENT_NODE && $this->matchesSimpleSelector($node, $selectors, $index)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Handle a Direct Descendant combination.
-	 *
-	 * Check whether the given node is a rightly-related descendant
-	 * of its parent node.
-	 *
-	 * @param DOMNode $node
-	 *   A DOM Node.
-	 * @param array   $selectors
-	 *   The selectors array.
-	 * @param int     $index
-	 *   The current index to the operative simple selector in the selectors
-	 *   array.
-	 *
-	 * @return boolean
-	 *   TRUE if the combination matches, FALSE otherwise.
-	 */
-	public function combineDirectDescendant($node, $selectors, $index)
-	{
-		$parent = $node->parentNode;
-		if (empty($parent)) {
-			return false;
-		}
-
-		return $this->matchesSimpleSelector($parent, $selectors, $index);
-	}
-
-	/**
-	 * Handle Any Descendant combinations.
-	 *
-	 * This checks to see if there are any matching routes from the
-	 * selector beginning at the present node.
-	 *
-	 * @param DOMNode $node
-	 *   A DOM Node.
-	 * @param array   $selectors
-	 *   The selectors array.
-	 * @param int     $index
-	 *   The current index to the operative simple selector in the selectors
-	 *   array.
-	 *
-	 * @return boolean
-	 *   TRUE if the combination matches, FALSE otherwise.
-	 */
-	public function combineAnyDescendant($node, $selectors, $index)
-	{
-		while (! empty($node->parentNode)) {
-			$node = $node->parentNode;
-
-			// Catch case where element is child of something
-			// else. This should really only happen with a
-			// document element.
-			if ($node->nodeType != XML_ELEMENT_NODE) {
-				continue;
-			}
-
-			if ($this->matchesSimpleSelector($node, $selectors, $index)) {
-				return true;
-			}
-		}
-	}
-
-	/**
-	 * Get the intial match set.
-	 *
-	 * This should only be executed when not working with
-	 * an existing match set.
-	 *
-	 * @param \QueryPath\CSS\SimpleSelector $selector
-	 * @param SplObjectStorage              $matches
-	 *
-	 * @return SplObjectStorage
-	 */
-	protected function initialMatch(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
-	{
-		$element = $selector->element;
-
-		// If no element is specified, we have to start with the
-		// entire document.
-		if ($element === null) {
-			$element = '*';
-		}
-
-		// We try to do some optimization here to reduce the
-		// number of matches to the bare minimum. This will
-		// reduce the subsequent number of operations that
-		// must be performed in the query.
-
-		// Experimental: ID queries use XPath to match, since
-		// this should give us only a single matched element
-		// to work with.
-		if (/*$element == '*' &&*/
-		! empty($selector->id)) {
-			$initialMatches = $this->initialMatchOnID($selector, $matches);
-		} // If a namespace is set, find the namespace matches.
-		elseif (! empty($selector->ns)) {
-			$initialMatches = $this->initialMatchOnElementNS($selector, $matches);
-		}
-		// If the element is a wildcard, using class can
-		// substantially reduce the number of elements that
-		// we start with.
-		elseif ($element === '*' && ! empty($selector->classes)) {
-			$initialMatches = $this->initialMatchOnClasses($selector, $matches);
-		} else {
-			$initialMatches = $this->initialMatchOnElement($selector, $matches);
-		}
-
-		return $initialMatches;
-	}
-
-	/**
-	 * Shortcut for finding initial match by ID.
-	 *
-	 * If the element is set to '*' and an ID is
-	 * set, then this should be used to find by ID,
-	 * which will drastically reduce the amount of
-	 * comparison operations done in PHP.
-	 *
-	 * @param \QueryPath\CSS\SimpleSelector $selector
-	 * @param SplObjectStorage              $matches
-	 *
-	 * @return SplObjectStorage
-	 */
-	protected function initialMatchOnID(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
-	{
-		$id    = $selector->id;
-		$found = $this->newMatches();
-
-		// Issue #145: DOMXPath will through an exception if the DOM is
-		// not set.
-		if (! ($this->dom instanceof DOMDocument)) {
-			return $found;
-		}
-		$baseQuery = ".//*[@id='{$id}']";
-		$xpath     = new DOMXPath($this->dom);
-
-		// Now we try to find any matching IDs.
-		/** @var DOMElement $node */
-		foreach ($matches as $node) {
-			if ($node->getAttribute('id') === $id) {
-				$found->attach($node);
-			}
-
-			$nl = $this->initialXpathQuery($xpath, $node, $baseQuery);
-			if (! empty($nl) && $nl instanceof DOMNodeList) {
-				$this->attachNodeList($nl, $found);
-			}
-		}
-		// Unset the ID selector.
-		$selector->id = null;
-
-		return $found;
-	}
-
-	/**
-	 * Shortcut for setting the intial match.
-	 *
-	 * This shortcut should only be used when the initial
-	 * element is '*' and there are classes set.
-	 *
-	 * In any other case, the element finding algo is
-	 * faster and should be used instead.
-	 *
-	 * @param \QueryPath\CSS\SimpleSelector $selector
-	 * @param                               $matches
-	 *
-	 * @return SplObjectStorage
-	 */
-	protected function initialMatchOnClasses(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
-	{
-		$found = $this->newMatches();
-
-		// Issue #145: DOMXPath will through an exception if the DOM is
-		// not set.
-		if (! ($this->dom instanceof DOMDocument)) {
-			return $found;
-		}
-		$baseQuery = './/*[@class]';
-		$xpath     = new DOMXPath($this->dom);
-
-		// Now we try to find any matching IDs.
-		/** @var DOMElement $node */
-		foreach ($matches as $node) {
-			// Refactor me!
-			if ($node->hasAttribute('class')) {
-				$intersect = array_intersect($selector->classes, explode(' ', $node->getAttribute('class')));
-				if (count($intersect) === count($selector->classes)) {
-					$found->attach($node);
-				}
-			}
-
-			$nl = $this->initialXpathQuery($xpath, $node, $baseQuery);
-			/** @var DOMElement $subNode */
-			foreach ($nl as $subNode) {
-				$classes    = $subNode->getAttribute('class');
-				$classArray = explode(' ', $classes);
-
-				$intersect = array_intersect($selector->classes, $classArray);
-				if (count($intersect) === count($selector->classes)) {
-					$found->attach($subNode);
-				}
-			}
-		}
-
-		// Unset the classes selector.
-		$selector->classes = [];
-
-		return $found;
-	}
-
-	/**
-	 * Internal xpath query.
-	 *
-	 * This is optimized for very specific use, and is not a general
-	 * purpose function.
-	 *
-	 * @param DOMXPath   $xpath
-	 * @param DOMElement $node
-	 * @param string      $query
-	 *
-	 * @return DOMNodeList
-	 */
-	private function initialXpathQuery(DOMXPath $xpath, DOMElement $node, string $query): DOMNodeList
-	{
-		// This works around a bug in which the document element
-		// does not correctly search with the $baseQuery.
-		if ($node->isSameNode($this->dom->documentElement)) {
-			$query = mb_substr($query, 1);
-		}
-
-		return $xpath->query($query, $node);
-	}
-
-	/**
-	 * Shortcut for setting the initial match.
-	 *
-	 * @param $selector
-	 * @param $matches
-	 *
-	 * @return SplObjectStorage
-	 */
-	protected function initialMatchOnElement(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
-	{
-		$element = $selector->element;
-		if (null === $element) {
-			$element = '*';
-		}
-		$found = $this->newMatches();
-		/** @var DOMDocument $node */
-		foreach ($matches as $node) {
-			// Capture the case where the initial element is the root element.
-			if ($node->tagName === $element
-				|| ($element === '*' && $node->parentNode instanceof DOMDocument)) {
-				$found->attach($node);
-			}
-			$nl = $node->getElementsByTagName($element);
-			if (! empty($nl) && $nl instanceof DOMNodeList) {
-				$this->attachNodeList($nl, $found);
-			}
-		}
-
-		$selector->element = null;
-
-		return $found;
-	}
-
-	/**
-	 * Get elements and filter by namespace.
-	 *
-	 * @param \QueryPath\CSS\SimpleSelector $selector
-	 * @param SplObjectStorage              $matches
-	 *
-	 * @return SplObjectStorage
-	 */
-	protected function initialMatchOnElementNS(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
-	{
-		$ns = $selector->ns;
-
-		$elements = $this->initialMatchOnElement($selector, $matches);
-
-		// "any namespace" matches anything.
-		if ($ns === '*') {
-			return $elements;
-		}
-
-		// Loop through and make a list of items that need to be filtered
-		// out, then filter them. This is required b/c ObjectStorage iterates
-		// wrongly when an item is detached in an access loop.
-		$detach = [];
-		foreach ($elements as $node) {
-			// This lookup must be done PER NODE.
-			$nsuri = $node->lookupNamespaceURI($ns);
-			if (empty($nsuri) || $node->namespaceURI !== $nsuri) {
-				$detach[] = $node;
-			}
-		}
-		foreach ($detach as $rem) {
-			$elements->detach($rem);
-		}
-		$selector->ns = null;
-
-		return $elements;
-	}
-
-	/**
-	 * Checks to see if the DOMNode matches the given element selector.
-	 *
-	 * This handles the following cases:
-	 *
-	 * - element (foo)
-	 * - namespaced element (ns|foo)
-	 * - namespaced wildcard (ns|*)
-	 * - wildcard (* or *|*)
-	 *
-	 * @param DOMElement $node
-	 * @param             $element
-	 * @param null        $ns
-	 *
-	 * @return bool
-	 */
-	protected function matchElement(DOMElement $node, $element, $ns = null): bool
-	{
-		if (empty($element)) {
-			return true;
-		}
-
-		// Handle namespace.
-		if (! empty($ns) && $ns !== '*') {
-			// Check whether we have a matching NS URI.
-			$nsuri = $node->lookupNamespaceURI($ns);
-			if (empty($nsuri) || $node->namespaceURI !== $nsuri) {
-				return false;
-			}
-		}
-
-		// Compare local name to given element name.
-		return $element === '*' || $node->localName === $element;
-	}
-
-	/**
-	 * Checks to see if the given DOMNode matches an "any element" (*).
-	 *
-	 * This does not handle namespaced whildcards.
-	 */
-	/*
+        if ($isNextRule && $result) {
+            $result = $this->combine($node, $selectors, $index);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Combine the next selector with the given match
+     * using the next combinator.
+     *
+     * If the next selector is combined with another
+     * selector, that will be evaluated too, and so on.
+     * So if this function returns TRUE, it means that all
+     * child selectors are also matches.
+     *
+     * @param DOMNode $node
+     *   The DOMNode to test.
+     * @param array   $selectors
+     *   The array of simple selectors.
+     * @param int     $index
+     *   The index of the current selector.
+     *
+     * @return boolean
+     *   TRUE if the next selector(s) match.
+     */
+    public function combine(DOMElement $node, $selectors, $index)
+    {
+        $selector = $selectors[$index];
+        //$this->debug(implode(' ', $selectors));
+        switch ($selector->combinator) {
+            case SimpleSelector::ADJACENT:
+                return $this->combineAdjacent($node, $selectors, $index);
+            case SimpleSelector::SIBLING:
+                return $this->combineSibling($node, $selectors, $index);
+            case SimpleSelector::DIRECT_DESCENDANT:
+                return $this->combineDirectDescendant($node, $selectors, $index);
+            case SimpleSelector::ANY_DESCENDANT:
+                return $this->combineAnyDescendant($node, $selectors, $index);
+            case SimpleSelector::ANOTHER_SELECTOR:
+                // fprintf(STDOUT, "Next selector: %s\n", $selectors[$index]);
+                return $this->matchesSimpleSelector($node, $selectors, $index);
+        }
+
+        return false;
+    }
+
+    /**
+     * Process an Adjacent Sibling.
+     *
+     * The spec does not indicate whether Adjacent should ignore non-Element
+     * nodes, so we choose to ignore them.
+     *
+     * @param DOMNode $node
+     *   A DOM Node.
+     * @param array   $selectors
+     *   The selectors array.
+     * @param int     $index
+     *   The current index to the operative simple selector in the selectors
+     *   array.
+     *
+     * @return boolean
+     *   TRUE if the combination matches, FALSE otherwise.
+     */
+    public function combineAdjacent($node, $selectors, $index)
+    {
+        while (! empty($node->previousSibling)) {
+            $node = $node->previousSibling;
+            if ($node->nodeType == XML_ELEMENT_NODE) {
+                //$this->debug(sprintf('Testing %s against "%s"', $node->tagName, $selectors[$index]));
+                return $this->matchesSimpleSelector($node, $selectors, $index);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check all siblings.
+     *
+     * According to the spec, this only tests elements LEFT of the provided
+     * node.
+     *
+     * @param DOMNode $node
+     *   A DOM Node.
+     * @param array   $selectors
+     *   The selectors array.
+     * @param int     $index
+     *   The current index to the operative simple selector in the selectors
+     *   array.
+     *
+     * @return boolean
+     *   TRUE if the combination matches, FALSE otherwise.
+     */
+    public function combineSibling($node, $selectors, $index)
+    {
+        while (! empty($node->previousSibling)) {
+            $node = $node->previousSibling;
+            if ($node->nodeType == XML_ELEMENT_NODE && $this->matchesSimpleSelector($node, $selectors, $index)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Handle a Direct Descendant combination.
+     *
+     * Check whether the given node is a rightly-related descendant
+     * of its parent node.
+     *
+     * @param DOMNode $node
+     *   A DOM Node.
+     * @param array   $selectors
+     *   The selectors array.
+     * @param int     $index
+     *   The current index to the operative simple selector in the selectors
+     *   array.
+     *
+     * @return boolean
+     *   TRUE if the combination matches, FALSE otherwise.
+     */
+    public function combineDirectDescendant($node, $selectors, $index)
+    {
+        $parent = $node->parentNode;
+        if (empty($parent)) {
+            return false;
+        }
+
+        return $this->matchesSimpleSelector($parent, $selectors, $index);
+    }
+
+    /**
+     * Handle Any Descendant combinations.
+     *
+     * This checks to see if there are any matching routes from the
+     * selector beginning at the present node.
+     *
+     * @param DOMNode $node
+     *   A DOM Node.
+     * @param array   $selectors
+     *   The selectors array.
+     * @param int     $index
+     *   The current index to the operative simple selector in the selectors
+     *   array.
+     *
+     * @return boolean
+     *   TRUE if the combination matches, FALSE otherwise.
+     */
+    public function combineAnyDescendant($node, $selectors, $index)
+    {
+        while (! empty($node->parentNode)) {
+            $node = $node->parentNode;
+
+            // Catch case where element is child of something
+            // else. This should really only happen with a
+            // document element.
+            if ($node->nodeType != XML_ELEMENT_NODE) {
+                continue;
+            }
+
+            if ($this->matchesSimpleSelector($node, $selectors, $index)) {
+                return true;
+            }
+        }
+    }
+
+    /**
+     * Get the intial match set.
+     *
+     * This should only be executed when not working with
+     * an existing match set.
+     *
+     * @param \QueryPath\CSS\SimpleSelector $selector
+     * @param SplObjectStorage              $matches
+     *
+     * @return SplObjectStorage
+     */
+    protected function initialMatch(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
+    {
+        $element = $selector->element;
+
+        // If no element is specified, we have to start with the
+        // entire document.
+        if ($element === null) {
+            $element = '*';
+        }
+
+        // We try to do some optimization here to reduce the
+        // number of matches to the bare minimum. This will
+        // reduce the subsequent number of operations that
+        // must be performed in the query.
+
+        // Experimental: ID queries use XPath to match, since
+        // this should give us only a single matched element
+        // to work with.
+        if (/*$element == '*' &&*/
+        ! empty($selector->id)) {
+            $initialMatches = $this->initialMatchOnID($selector, $matches);
+        } // If a namespace is set, find the namespace matches.
+        elseif (! empty($selector->ns)) {
+            $initialMatches = $this->initialMatchOnElementNS($selector, $matches);
+        }
+        // If the element is a wildcard, using class can
+        // substantially reduce the number of elements that
+        // we start with.
+        elseif ($element === '*' && ! empty($selector->classes)) {
+            $initialMatches = $this->initialMatchOnClasses($selector, $matches);
+        } else {
+            $initialMatches = $this->initialMatchOnElement($selector, $matches);
+        }
+
+        return $initialMatches;
+    }
+
+    /**
+     * Shortcut for finding initial match by ID.
+     *
+     * If the element is set to '*' and an ID is
+     * set, then this should be used to find by ID,
+     * which will drastically reduce the amount of
+     * comparison operations done in PHP.
+     *
+     * @param \QueryPath\CSS\SimpleSelector $selector
+     * @param SplObjectStorage              $matches
+     *
+     * @return SplObjectStorage
+     */
+    protected function initialMatchOnID(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
+    {
+        $id    = $selector->id;
+        $found = $this->newMatches();
+
+        // Issue #145: DOMXPath will through an exception if the DOM is
+        // not set.
+        if (! ($this->dom instanceof DOMDocument)) {
+            return $found;
+        }
+        $baseQuery = ".//*[@id='{$id}']";
+        $xpath     = new DOMXPath($this->dom);
+
+        // Now we try to find any matching IDs.
+        /** @var DOMElement $node */
+        foreach ($matches as $node) {
+            if ($node->getAttribute('id') === $id) {
+                $found->attach($node);
+            }
+
+            $nl = $this->initialXpathQuery($xpath, $node, $baseQuery);
+            if (! empty($nl) && $nl instanceof DOMNodeList) {
+                $this->attachNodeList($nl, $found);
+            }
+        }
+        // Unset the ID selector.
+        $selector->id = null;
+
+        return $found;
+    }
+
+    /**
+     * Shortcut for setting the intial match.
+     *
+     * This shortcut should only be used when the initial
+     * element is '*' and there are classes set.
+     *
+     * In any other case, the element finding algo is
+     * faster and should be used instead.
+     *
+     * @param \QueryPath\CSS\SimpleSelector $selector
+     * @param                               $matches
+     *
+     * @return SplObjectStorage
+     */
+    protected function initialMatchOnClasses(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
+    {
+        $found = $this->newMatches();
+
+        // Issue #145: DOMXPath will through an exception if the DOM is
+        // not set.
+        if (! ($this->dom instanceof DOMDocument)) {
+            return $found;
+        }
+        $baseQuery = './/*[@class]';
+        $xpath     = new DOMXPath($this->dom);
+
+        // Now we try to find any matching IDs.
+        /** @var DOMElement $node */
+        foreach ($matches as $node) {
+            // Refactor me!
+            if ($node->hasAttribute('class')) {
+                $intersect = array_intersect($selector->classes, explode(' ', $node->getAttribute('class')));
+                if (count($intersect) === count($selector->classes)) {
+                    $found->attach($node);
+                }
+            }
+
+            $nl = $this->initialXpathQuery($xpath, $node, $baseQuery);
+            /** @var DOMElement $subNode */
+            foreach ($nl as $subNode) {
+                $classes    = $subNode->getAttribute('class');
+                $classArray = explode(' ', $classes);
+
+                $intersect = array_intersect($selector->classes, $classArray);
+                if (count($intersect) === count($selector->classes)) {
+                    $found->attach($subNode);
+                }
+            }
+        }
+
+        // Unset the classes selector.
+        $selector->classes = [];
+
+        return $found;
+    }
+
+    /**
+     * Internal xpath query.
+     *
+     * This is optimized for very specific use, and is not a general
+     * purpose function.
+     *
+     * @param DOMXPath   $xpath
+     * @param DOMElement $node
+     * @param string      $query
+     *
+     * @return DOMNodeList
+     */
+    private function initialXpathQuery(DOMXPath $xpath, DOMElement $node, string $query): DOMNodeList
+    {
+        // This works around a bug in which the document element
+        // does not correctly search with the $baseQuery.
+        if ($node->isSameNode($this->dom->documentElement)) {
+            $query = mb_substr($query, 1);
+        }
+
+        return $xpath->query($query, $node);
+    }
+
+    /**
+     * Shortcut for setting the initial match.
+     *
+     * @param $selector
+     * @param $matches
+     *
+     * @return SplObjectStorage
+     */
+    protected function initialMatchOnElement(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
+    {
+        $element = $selector->element;
+        if (null === $element) {
+            $element = '*';
+        }
+        $found = $this->newMatches();
+        /** @var DOMDocument $node */
+        foreach ($matches as $node) {
+            // Capture the case where the initial element is the root element.
+            if ($node->tagName === $element
+                || ($element === '*' && $node->parentNode instanceof DOMDocument)) {
+                $found->attach($node);
+            }
+            $nl = $node->getElementsByTagName($element);
+            if (! empty($nl) && $nl instanceof DOMNodeList) {
+                $this->attachNodeList($nl, $found);
+            }
+        }
+
+        $selector->element = null;
+
+        return $found;
+    }
+
+    /**
+     * Get elements and filter by namespace.
+     *
+     * @param \QueryPath\CSS\SimpleSelector $selector
+     * @param SplObjectStorage              $matches
+     *
+     * @return SplObjectStorage
+     */
+    protected function initialMatchOnElementNS(SimpleSelector $selector, SplObjectStorage $matches): SplObjectStorage
+    {
+        $ns = $selector->ns;
+
+        $elements = $this->initialMatchOnElement($selector, $matches);
+
+        // "any namespace" matches anything.
+        if ($ns === '*') {
+            return $elements;
+        }
+
+        // Loop through and make a list of items that need to be filtered
+        // out, then filter them. This is required b/c ObjectStorage iterates
+        // wrongly when an item is detached in an access loop.
+        $detach = [];
+        foreach ($elements as $node) {
+            // This lookup must be done PER NODE.
+            $nsuri = $node->lookupNamespaceURI($ns);
+            if (empty($nsuri) || $node->namespaceURI !== $nsuri) {
+                $detach[] = $node;
+            }
+        }
+        foreach ($detach as $rem) {
+            $elements->detach($rem);
+        }
+        $selector->ns = null;
+
+        return $elements;
+    }
+
+    /**
+     * Checks to see if the DOMNode matches the given element selector.
+     *
+     * This handles the following cases:
+     *
+     * - element (foo)
+     * - namespaced element (ns|foo)
+     * - namespaced wildcard (ns|*)
+     * - wildcard (* or *|*)
+     *
+     * @param DOMElement $node
+     * @param             $element
+     * @param null        $ns
+     *
+     * @return bool
+     */
+    protected function matchElement(DOMElement $node, $element, $ns = null): bool
+    {
+        if (empty($element)) {
+            return true;
+        }
+
+        // Handle namespace.
+        if (! empty($ns) && $ns !== '*') {
+            // Check whether we have a matching NS URI.
+            $nsuri = $node->lookupNamespaceURI($ns);
+            if (empty($nsuri) || $node->namespaceURI !== $nsuri) {
+                return false;
+            }
+        }
+
+        // Compare local name to given element name.
+        return $element === '*' || $node->localName === $element;
+    }
+
+    /**
+     * Checks to see if the given DOMNode matches an "any element" (*).
+     *
+     * This does not handle namespaced whildcards.
+     */
+    /*
 	protected function matchAnyElement($node) {
 	  $ancestors = $this->ancestors($node);
 
@@ -689,211 +689,211 @@ 
 	}
 	 */
 
-	/**
-	 * Get a list of ancestors to the present node.
-	 */
-	protected function ancestors($node)
-	{
-		$buffer = [];
-		$parent = $node;
-		while (($parent = $parent->parentNode) !== null) {
-			$buffer[] = $parent;
-		}
-
-		return $buffer;
-	}
-
-	/**
-	 * Check to see if DOMNode has all of the given attributes.
-	 *
-	 * This can handle namespaced attributes, including namespace
-	 * wildcards.
-	 *
-	 * @param DOMElement $node
-	 * @param             $attributes
-	 *
-	 * @return bool
-	 */
-	protected function matchAttributes(DOMElement $node, $attributes): bool
-	{
-		if (empty($attributes)) {
-			return true;
-		}
-
-		foreach ($attributes as $attr) {
-			$val = isset($attr['value']) ? $attr['value'] : null;
-
-			// Namespaced attributes.
-			if (isset($attr['ns']) && $attr['ns'] !== '*') {
-				$nsuri = $node->lookupNamespaceURI($attr['ns']);
-				if (empty($nsuri) || ! $node->hasAttributeNS($nsuri, $attr['name'])) {
-					return false;
-				}
-				$matches = Util::matchesAttributeNS($node, $attr['name'], $nsuri, $val, $attr['op']);
-			} elseif (isset($attr['ns']) && $attr['ns'] === '*' && $node->hasAttributes()) {
-				// Cycle through all of the attributes in the node. Note that
-				// these are DOMAttr objects.
-				$matches = false;
-				$name    = $attr['name'];
-				foreach ($node->attributes as $attrNode) {
-					if ($attrNode->localName === $name) {
-						$nsuri   = $attrNode->namespaceURI;
-						$matches = Util::matchesAttributeNS($node, $name, $nsuri, $val, $attr['op']);
-					}
-				}
-			} // No namespace.
-			else {
-				$matches = Util::matchesAttribute($node, $attr['name'], $val, $attr['op']);
-			}
-
-			if (! $matches) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Check that the given DOMNode has the given ID.
-	 *
-	 * @param DOMElement $node
-	 * @param             $id
-	 *
-	 * @return bool
-	 */
-	protected function matchId(DOMElement $node, $id): bool
-	{
-		if (empty($id)) {
-			return true;
-		}
-
-		return $node->hasAttribute('id') && $node->getAttribute('id') === $id;
-	}
-
-	/**
-	 * Check that the given DOMNode has all of the given classes.
-	 *
-	 * @param DOMElement $node
-	 * @param             $classes
-	 *
-	 * @return bool
-	 */
-	protected function matchClasses(DOMElement $node, $classes): bool
-	{
-		if (empty($classes)) {
-			return true;
-		}
-
-		if (! $node->hasAttribute('class')) {
-			return false;
-		}
-
-		$eleClasses = preg_split('/\s+/', $node->getAttribute('class'));
-		if (empty($eleClasses)) {
-			return false;
-		}
-
-		// The intersection should match the given $classes.
-		$missing = array_diff($classes, array_intersect($classes, $eleClasses));
-
-		return count($missing) === 0;
-	}
-
-	/**
-	 * @param DOMElement $node
-	 * @param             $pseudoClasses
-	 *
-	 * @return bool
-	 * @throws NotImplementedException
-	 * @throws ParseException
-	 */
-	protected function matchPseudoClasses(DOMElement $node, $pseudoClasses): bool
-	{
-		$ret = true;
-		foreach ($pseudoClasses as $pseudoClass) {
-			$name = $pseudoClass['name'];
-			// Avoid E_STRICT violation.
-			$value = $pseudoClass['value'] ?? null;
-			$ret   &= $this->psHandler->elementMatches($name, $node, $this->scopeNode, $value);
-		}
-
-		return $ret;
-	}
-
-	/**
-	 * Test whether the given node matches the pseudoElements.
-	 *
-	 * If any pseudo-elements are passed, this will test to see
-	 * <i>if conditions obtain that would allow the pseudo-element
-	 * to be created</i>. This does not modify the match in any way.
-	 *
-	 * @param DOMElement $node
-	 * @param             $pseudoElements
-	 *
-	 * @return bool
-	 * @throws NotImplementedException
-	 */
-	protected function matchPseudoElements(DOMElement $node, $pseudoElements): bool
-	{
-		if (empty($pseudoElements)) {
-			return true;
-		}
-
-		foreach ($pseudoElements as $pse) {
-			switch ($pse) {
-				case 'first-line':
-				case 'first-letter':
-				case 'before':
-				case 'after':
-					return strlen($node->textContent) > 0;
-				case 'selection':
-					throw new NotImplementedException("::$pse is not implemented.");
-			}
-		}
-
-		return false;
-	}
-
-	protected function newMatches()
-	{
-		return new SplObjectStorage();
-	}
-
-	/**
-	 * Get the internal match set.
-	 * Internal utility function.
-	 */
-	protected function getMatches()
-	{
-		return $this->matches();
-	}
-
-	/**
-	 * Set the internal match set.
-	 *
-	 * Internal utility function.
-	 */
-	protected function setMatches($matches)
-	{
-		$this->matches = $matches;
-	}
-
-	/**
-	 * Attach all nodes in a node list to the given \SplObjectStorage.
-	 *
-	 * @param DOMNodeList     $nodeList
-	 * @param SplObjectStorage $splos
-	 */
-	public function attachNodeList(DOMNodeList $nodeList, SplObjectStorage $splos)
-	{
-		foreach ($nodeList as $item) {
-			$splos->attach($item);
-		}
-	}
-
-	public function getDocument()
-	{
-		return $this->dom;
-	}
+    /**
+     * Get a list of ancestors to the present node.
+     */
+    protected function ancestors($node)
+    {
+        $buffer = [];
+        $parent = $node;
+        while (($parent = $parent->parentNode) !== null) {
+            $buffer[] = $parent;
+        }
+
+        return $buffer;
+    }
+
+    /**
+     * Check to see if DOMNode has all of the given attributes.
+     *
+     * This can handle namespaced attributes, including namespace
+     * wildcards.
+     *
+     * @param DOMElement $node
+     * @param             $attributes
+     *
+     * @return bool
+     */
+    protected function matchAttributes(DOMElement $node, $attributes): bool
+    {
+        if (empty($attributes)) {
+            return true;
+        }
+
+        foreach ($attributes as $attr) {
+            $val = isset($attr['value']) ? $attr['value'] : null;
+
+            // Namespaced attributes.
+            if (isset($attr['ns']) && $attr['ns'] !== '*') {
+                $nsuri = $node->lookupNamespaceURI($attr['ns']);
+                if (empty($nsuri) || ! $node->hasAttributeNS($nsuri, $attr['name'])) {
+                    return false;
+                }
+                $matches = Util::matchesAttributeNS($node, $attr['name'], $nsuri, $val, $attr['op']);
+            } elseif (isset($attr['ns']) && $attr['ns'] === '*' && $node->hasAttributes()) {
+                // Cycle through all of the attributes in the node. Note that
+                // these are DOMAttr objects.
+                $matches = false;
+                $name    = $attr['name'];
+                foreach ($node->attributes as $attrNode) {
+                    if ($attrNode->localName === $name) {
+                        $nsuri   = $attrNode->namespaceURI;
+                        $matches = Util::matchesAttributeNS($node, $name, $nsuri, $val, $attr['op']);
+                    }
+                }
+            } // No namespace.
+            else {
+                $matches = Util::matchesAttribute($node, $attr['name'], $val, $attr['op']);
+            }
+
+            if (! $matches) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Check that the given DOMNode has the given ID.
+     *
+     * @param DOMElement $node
+     * @param             $id
+     *
+     * @return bool
+     */
+    protected function matchId(DOMElement $node, $id): bool
+    {
+        if (empty($id)) {
+            return true;
+        }
+
+        return $node->hasAttribute('id') && $node->getAttribute('id') === $id;
+    }
+
+    /**
+     * Check that the given DOMNode has all of the given classes.
+     *
+     * @param DOMElement $node
+     * @param             $classes
+     *
+     * @return bool
+     */
+    protected function matchClasses(DOMElement $node, $classes): bool
+    {
+        if (empty($classes)) {
+            return true;
+        }
+
+        if (! $node->hasAttribute('class')) {
+            return false;
+        }
+
+        $eleClasses = preg_split('/\s+/', $node->getAttribute('class'));
+        if (empty($eleClasses)) {
+            return false;
+        }
+
+        // The intersection should match the given $classes.
+        $missing = array_diff($classes, array_intersect($classes, $eleClasses));
+
+        return count($missing) === 0;
+    }
+
+    /**
+     * @param DOMElement $node
+     * @param             $pseudoClasses
+     *
+     * @return bool
+     * @throws NotImplementedException
+     * @throws ParseException
+     */
+    protected function matchPseudoClasses(DOMElement $node, $pseudoClasses): bool
+    {
+        $ret = true;
+        foreach ($pseudoClasses as $pseudoClass) {
+            $name = $pseudoClass['name'];
+            // Avoid E_STRICT violation.
+            $value = $pseudoClass['value'] ?? null;
+            $ret   &= $this->psHandler->elementMatches($name, $node, $this->scopeNode, $value);
+        }
+
+        return $ret;
+    }
+
+    /**
+     * Test whether the given node matches the pseudoElements.
+     *
+     * If any pseudo-elements are passed, this will test to see
+     * <i>if conditions obtain that would allow the pseudo-element
+     * to be created</i>. This does not modify the match in any way.
+     *
+     * @param DOMElement $node
+     * @param             $pseudoElements
+     *
+     * @return bool
+     * @throws NotImplementedException
+     */
+    protected function matchPseudoElements(DOMElement $node, $pseudoElements): bool
+    {
+        if (empty($pseudoElements)) {
+            return true;
+        }
+
+        foreach ($pseudoElements as $pse) {
+            switch ($pse) {
+                case 'first-line':
+                case 'first-letter':
+                case 'before':
+                case 'after':
+                    return strlen($node->textContent) > 0;
+                case 'selection':
+                    throw new NotImplementedException("::$pse is not implemented.");
+            }
+        }
+
+        return false;
+    }
+
+    protected function newMatches()
+    {
+        return new SplObjectStorage();
+    }
+
+    /**
+     * Get the internal match set.
+     * Internal utility function.
+     */
+    protected function getMatches()
+    {
+        return $this->matches();
+    }
+
+    /**
+     * Set the internal match set.
+     *
+     * Internal utility function.
+     */
+    protected function setMatches($matches)
+    {
+        $this->matches = $matches;
+    }
+
+    /**
+     * Attach all nodes in a node list to the given \SplObjectStorage.
+     *
+     * @param DOMNodeList     $nodeList
+     * @param SplObjectStorage $splos
+     */
+    public function attachNodeList(DOMNodeList $nodeList, SplObjectStorage $splos)
+    {
+        foreach ($nodeList as $item) {
+            $splos->attach($item);
+        }
+    }
+
+    public function getDocument()
+    {
+        return $this->dom;
+    }
 }

Spacing +17 added lines, -17 removed lines

@@ -88,9 +88,9 @@ 
 			$splos->rewind();
 			$first = $splos->current();
 			if ($first instanceof DOMDocument) {
-				$this->dom = $first;//->documentElement;
+				$this->dom = $first; //->documentElement;
 			} else {
-				$this->dom = $first->ownerDocument;//->documentElement;
+				$this->dom = $first->ownerDocument; //->documentElement;
 			}
 
 			$this->scopeNode = $scopeNode;
@@ -297,7 +297,7 @@ 
 	 */
 	public function combineAdjacent($node, $selectors, $index)
 	{
-		while (! empty($node->previousSibling)) {
+		while (!empty($node->previousSibling)) {
 			$node = $node->previousSibling;
 			if ($node->nodeType == XML_ELEMENT_NODE) {
 				//$this->debug(sprintf('Testing %s against "%s"', $node->tagName, $selectors[$index]));
@@ -327,7 +327,7 @@ 
 	 */
 	public function combineSibling($node, $selectors, $index)
 	{
-		while (! empty($node->previousSibling)) {
+		while (!empty($node->previousSibling)) {
 			$node = $node->previousSibling;
 			if ($node->nodeType == XML_ELEMENT_NODE && $this->matchesSimpleSelector($node, $selectors, $index)) {
 				return true;
@@ -383,7 +383,7 @@ 
 	 */
 	public function combineAnyDescendant($node, $selectors, $index)
 	{
-		while (! empty($node->parentNode)) {
+		while (!empty($node->parentNode)) {
 			$node = $node->parentNode;
 
 			// Catch case where element is child of something
@@ -429,16 +429,16 @@ 
 		// this should give us only a single matched element
 		// to work with.
 		if (/*$element == '*' &&*/
-		! empty($selector->id)) {
+		!empty($selector->id)) {
 			$initialMatches = $this->initialMatchOnID($selector, $matches);
 		} // If a namespace is set, find the namespace matches.
-		elseif (! empty($selector->ns)) {
+		elseif (!empty($selector->ns)) {
 			$initialMatches = $this->initialMatchOnElementNS($selector, $matches);
 		}
 		// If the element is a wildcard, using class can
 		// substantially reduce the number of elements that
 		// we start with.
-		elseif ($element === '*' && ! empty($selector->classes)) {
+		elseif ($element === '*' && !empty($selector->classes)) {
 			$initialMatches = $this->initialMatchOnClasses($selector, $matches);
 		} else {
 			$initialMatches = $this->initialMatchOnElement($selector, $matches);
@@ -467,7 +467,7 @@ 
 
 		// Issue #145: DOMXPath will through an exception if the DOM is
 		// not set.
-		if (! ($this->dom instanceof DOMDocument)) {
+		if (!($this->dom instanceof DOMDocument)) {
 			return $found;
 		}
 		$baseQuery = ".//*[@id='{$id}']";
@@ -481,7 +481,7 @@ 
 			}
 
 			$nl = $this->initialXpathQuery($xpath, $node, $baseQuery);
-			if (! empty($nl) && $nl instanceof DOMNodeList) {
+			if (!empty($nl) && $nl instanceof DOMNodeList) {
 				$this->attachNodeList($nl, $found);
 			}
 		}
@@ -511,7 +511,7 @@ 
 
 		// Issue #145: DOMXPath will through an exception if the DOM is
 		// not set.
-		if (! ($this->dom instanceof DOMDocument)) {
+		if (!($this->dom instanceof DOMDocument)) {
 			return $found;
 		}
 		$baseQuery = './/*[@class]';
@@ -593,7 +593,7 @@ 
 				$found->attach($node);
 			}
 			$nl = $node->getElementsByTagName($element);
-			if (! empty($nl) && $nl instanceof DOMNodeList) {
+			if (!empty($nl) && $nl instanceof DOMNodeList) {
 				$this->attachNodeList($nl, $found);
 			}
 		}
@@ -664,7 +664,7 @@ 
 		}
 
 		// Handle namespace.
-		if (! empty($ns) && $ns !== '*') {
+		if (!empty($ns) && $ns !== '*') {
 			// Check whether we have a matching NS URI.
 			$nsuri = $node->lookupNamespaceURI($ns);
 			if (empty($nsuri) || $node->namespaceURI !== $nsuri) {
@@ -726,7 +726,7 @@ 
 			// Namespaced attributes.
 			if (isset($attr['ns']) && $attr['ns'] !== '*') {
 				$nsuri = $node->lookupNamespaceURI($attr['ns']);
-				if (empty($nsuri) || ! $node->hasAttributeNS($nsuri, $attr['name'])) {
+				if (empty($nsuri) || !$node->hasAttributeNS($nsuri, $attr['name'])) {
 					return false;
 				}
 				$matches = Util::matchesAttributeNS($node, $attr['name'], $nsuri, $val, $attr['op']);
@@ -746,7 +746,7 @@ 
 				$matches = Util::matchesAttribute($node, $attr['name'], $val, $attr['op']);
 			}
 
-			if (! $matches) {
+			if (!$matches) {
 				return false;
 			}
 		}
@@ -785,7 +785,7 @@ 
 			return true;
 		}
 
-		if (! $node->hasAttribute('class')) {
+		if (!$node->hasAttribute('class')) {
 			return false;
 		}
 
@@ -815,7 +815,7 @@ 
 			$name = $pseudoClass['name'];
 			// Avoid E_STRICT violation.
 			$value = $pseudoClass['value'] ?? null;
-			$ret   &= $this->psHandler->elementMatches($name, $node, $this->scopeNode, $value);
+			$ret &= $this->psHandler->elementMatches($name, $node, $this->scopeNode, $value);
 		}
 
 		return $ret;

src/CSS/Parser.php

Indentation +553 added lines, -553 removed lines

@@ -25,72 +25,72 @@ 
  */
 class Parser
 {
-	protected $scanner;
-	protected $buffer = '';
-	protected $handler;
-	private $strict = false;
-
-	protected $DEBUG = false;
-
-	/**
-	 * Construct a new CSS parser object. This will attempt to
-	 * parse the string as a CSS selector. As it parses, it will
-	 * send events to the EventHandler implementation.
-	 *
-	 * @param string       $string
-	 * @param EventHandler $handler
-	 */
-	public function __construct(string $string, EventHandler $handler)
-	{
-		$this->originalString = $string;
-		$is                   = new InputStream($string);
-		$this->scanner        = new Scanner($is);
-		$this->handler        = $handler;
-	}
-
-	/**
-	 * Parse the selector.
-	 *
-	 * This begins an event-based parsing process that will
-	 * fire events as the selector is handled. A EventHandler
-	 * implementation will be responsible for handling the events.
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	public function parse(): void
-	{
-		$this->scanner->nextToken();
-
-		while ($this->scanner->token !== false) {
-			// Primitive recursion detection.
-			$position = $this->scanner->position();
-
-			if ($this->DEBUG) {
-				echo 'PARSE ' . $this->scanner->token . PHP_EOL;
-			}
-			$this->selector();
-
-			$finalPosition = $this->scanner->position();
-			if ($this->scanner->token !== false && $finalPosition === $position) {
-				// If we get here, then the scanner did not pop a single character
-				// off of the input stream during a full run of the parser, which
-				// means that the current input does not match any recognizable
-				// pattern.
-				throw new ParseException('CSS selector is not well formed.');
-			}
-		}
-	}
-
-	/**
-	 * A restricted parser that can only parse simple selectors.
-	 * The pseudoClass handler for this parser will throw an
-	 * exception if it encounters a pseudo-element or the
-	 * negation pseudo-class.
-	 *
-	 * @deprecated This is not used anywhere in QueryPath and
-	 *  may be removed.
-	 *//*
+    protected $scanner;
+    protected $buffer = '';
+    protected $handler;
+    private $strict = false;
+
+    protected $DEBUG = false;
+
+    /**
+     * Construct a new CSS parser object. This will attempt to
+     * parse the string as a CSS selector. As it parses, it will
+     * send events to the EventHandler implementation.
+     *
+     * @param string       $string
+     * @param EventHandler $handler
+     */
+    public function __construct(string $string, EventHandler $handler)
+    {
+        $this->originalString = $string;
+        $is                   = new InputStream($string);
+        $this->scanner        = new Scanner($is);
+        $this->handler        = $handler;
+    }
+
+    /**
+     * Parse the selector.
+     *
+     * This begins an event-based parsing process that will
+     * fire events as the selector is handled. A EventHandler
+     * implementation will be responsible for handling the events.
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    public function parse(): void
+    {
+        $this->scanner->nextToken();
+
+        while ($this->scanner->token !== false) {
+            // Primitive recursion detection.
+            $position = $this->scanner->position();
+
+            if ($this->DEBUG) {
+                echo 'PARSE ' . $this->scanner->token . PHP_EOL;
+            }
+            $this->selector();
+
+            $finalPosition = $this->scanner->position();
+            if ($this->scanner->token !== false && $finalPosition === $position) {
+                // If we get here, then the scanner did not pop a single character
+                // off of the input stream during a full run of the parser, which
+                // means that the current input does not match any recognizable
+                // pattern.
+                throw new ParseException('CSS selector is not well formed.');
+            }
+        }
+    }
+
+    /**
+     * A restricted parser that can only parse simple selectors.
+     * The pseudoClass handler for this parser will throw an
+     * exception if it encounters a pseudo-element or the
+     * negation pseudo-class.
+     *
+     * @deprecated This is not used anywhere in QueryPath and
+     *  may be removed.
+     *//*
 	public function parseSimpleSelector() {
 	while ($this->scanner->token !== FALSE) {
 	  if ($this->DEBUG) print "SIMPLE SELECTOR\n";
@@ -105,261 +105,261 @@ 
 	}
 	}*/
 
-	/**
-	 * Handle an entire CSS selector.
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	private function selector(): void
-	{
-		if ($this->DEBUG) {
-			print 'SELECTOR' . $this->scanner->position() . PHP_EOL;
-		}
-
-		$this->consumeWhitespace(); // Remove leading whitespace
-		$this->simpleSelectors();
-		$this->combinator();
-	}
-
-	/**
-	 * Consume whitespace and return a count of the number of whitespace consumed.
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	private function consumeWhitespace(): int
-	{
-		if ($this->DEBUG) {
-			echo 'CONSUME WHITESPACE' . PHP_EOL;
-		}
-
-		$white = 0;
-		while ($this->scanner->token === Token::WHITE) {
-			$this->scanner->nextToken();
-			++$white;
-		}
-
-		return $white;
-	}
-
-	/**
-	 * Handle one of the five combinators: '>', '+', ' ', '~', and ','.
-	 * This will call the appropriate event handlers.
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 * @see EventHandler::anyDescendant(),
-	 * @see EventHandler::anotherSelector().
-	 * @see EventHandler::directDescendant(),
-	 * @see EventHandler::adjacent(),
-	 */
-	private function combinator(): void
-	{
-		if ($this->DEBUG) {
-			echo 'COMBINATOR' . PHP_EOL;
-		}
-		/*
+    /**
+     * Handle an entire CSS selector.
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    private function selector(): void
+    {
+        if ($this->DEBUG) {
+            print 'SELECTOR' . $this->scanner->position() . PHP_EOL;
+        }
+
+        $this->consumeWhitespace(); // Remove leading whitespace
+        $this->simpleSelectors();
+        $this->combinator();
+    }
+
+    /**
+     * Consume whitespace and return a count of the number of whitespace consumed.
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    private function consumeWhitespace(): int
+    {
+        if ($this->DEBUG) {
+            echo 'CONSUME WHITESPACE' . PHP_EOL;
+        }
+
+        $white = 0;
+        while ($this->scanner->token === Token::WHITE) {
+            $this->scanner->nextToken();
+            ++$white;
+        }
+
+        return $white;
+    }
+
+    /**
+     * Handle one of the five combinators: '>', '+', ' ', '~', and ','.
+     * This will call the appropriate event handlers.
+     *
+     * @throws ParseException
+     * @throws Exception
+     * @see EventHandler::anyDescendant(),
+     * @see EventHandler::anotherSelector().
+     * @see EventHandler::directDescendant(),
+     * @see EventHandler::adjacent(),
+     */
+    private function combinator(): void
+    {
+        if ($this->DEBUG) {
+            echo 'COMBINATOR' . PHP_EOL;
+        }
+        /*
 		 * Problem: ' ' and ' > ' are both valid combinators.
 		 * So we have to track whitespace consumption to see
 		 * if we are hitting the ' ' combinator or if the
 		 * selector just has whitespace padding another combinator.
 		 */
 
-		// Flag to indicate that post-checks need doing
-		$inCombinator = false;
-		$white        = $this->consumeWhitespace();
-		$t            = $this->scanner->token;
-
-		if ($t === Token::RANGLE) {
-			$this->handler->directDescendant();
-			$this->scanner->nextToken();
-			$inCombinator = true;
-			//$this->simpleSelectors();
-		} elseif ($t === Token::PLUS) {
-			$this->handler->adjacent();
-			$this->scanner->nextToken();
-			$inCombinator = true;
-			//$this->simpleSelectors();
-		} elseif ($t === Token::COMMA) {
-			$this->handler->anotherSelector();
-			$this->scanner->nextToken();
-			$inCombinator = true;
-			//$this->scanner->selectors();
-		} elseif ($t === Token::TILDE) {
-			$this->handler->sibling();
-			$this->scanner->nextToken();
-			$inCombinator = true;
-		}
-
-		// Check that we don't get two combinators in a row.
-		if ($inCombinator) {
-			if ($this->DEBUG) {
-				print 'COMBINATOR: ' . Token::name($t) . "\n";
-			}
-			$this->consumeWhitespace();
-			if ($this->isCombinator($this->scanner->token)) {
-				throw new ParseException('Illegal combinator: Cannot have two combinators in sequence.');
-			}
-		} // Check to see if we have whitespace combinator:
-		elseif ($white > 0) {
-			if ($this->DEBUG) {
-				echo 'COMBINATOR: any descendant' . PHP_EOL;
-			}
-			$this->handler->anyDescendant();
-		} else {
-			if ($this->DEBUG) {
-				echo 'COMBINATOR: no combinator found.' . PHP_EOL;
-			}
-		}
-	}
-
-	/**
-	 * Check if the token is a combinator.
-	 *
-	 * @param int $tok
-	 *
-	 * @return bool
-	 */
-	private function isCombinator(int $tok): bool
-	{
-		return in_array($tok, [Token::PLUS, Token::RANGLE, Token::COMMA, Token::TILDE], true);
-	}
-
-	/**
-	 * Handle a simple selector.
-	 *
-	 * @throws ParseException
-	 */
-	private function simpleSelectors(): void
-	{
-		if ($this->DEBUG) {
-			print 'SIMPLE SELECTOR' . PHP_EOL;
-		}
-		$this->allElements();
-		$this->elementName();
-		$this->elementClass();
-		$this->elementID();
-		$this->pseudoClass();
-		$this->attribute();
-	}
-
-	/**
-	 * Handles CSS ID selectors.
-	 * This will call EventHandler::elementID().
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	private function elementID(): void
-	{
-		if ($this->DEBUG) {
-			echo 'ELEMENT ID' . PHP_EOL;
-		}
-
-		if ($this->scanner->token === Token::OCTO) {
-			$this->scanner->nextToken();
-			if ($this->scanner->token !== Token::CHAR) {
-				throw new ParseException("Expected string after #");
-			}
-			$id = $this->scanner->getNameString();
-			$this->handler->elementID($id);
-		}
-	}
-
-	/**
-	 * Handles CSS class selectors.
-	 * This will call the EventHandler::elementClass() method.
-	 */
-	private function elementClass(): void
-	{
-		if ($this->DEBUG) {
-			print 'ELEMENT CLASS' . PHP_EOL;
-		}
-		if ($this->scanner->token == Token::DOT) {
-			$this->scanner->nextToken();
-			$this->consumeWhitespace(); // We're very fault tolerent. This should prob through error.
-			$cssClass = $this->scanner->getNameString();
-			$this->handler->elementClass($cssClass);
-		}
-	}
-
-	/**
-	 * Handle a pseudo-class and pseudo-element.
-	 *
-	 * CSS 3 selectors support separate pseudo-elements, using :: instead
-	 * of : for separator. This is now supported, and calls the pseudoElement
-	 * handler, EventHandler::pseudoElement().
-	 *
-	 * This will call EventHandler::pseudoClass() when a
-	 * pseudo-class is parsed.
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	private function pseudoClass($restricted = false): void
-	{
-		if ($this->DEBUG) {
-			echo 'PSEUDO-CLASS' . PHP_EOL;
-		}
-		if ($this->scanner->token === Token::COLON) {
-			// Check for CSS 3 pseudo element:
-			$isPseudoElement = false;
-			if ($this->scanner->nextToken() === Token::COLON) {
-				$isPseudoElement = true;
-				$this->scanner->nextToken();
-			}
-
-			$name = $this->scanner->getNameString();
-			if ($restricted && $name === 'not') {
-				throw new ParseException("The 'not' pseudo-class is illegal in this context.");
-			}
-
-			$value = null;
-			if ($this->scanner->token === Token::LPAREN) {
-				if ($isPseudoElement) {
-					throw new ParseException('Illegal left paren. Pseudo-Element cannot have arguments.');
-				}
-				$value = $this->pseudoClassValue();
-			}
-
-			// FIXME: This should throw errors when pseudo element has values.
-			if ($isPseudoElement) {
-				if ($restricted) {
-					throw new ParseException('Pseudo-Elements are illegal in this context.');
-				}
-				$this->handler->pseudoElement($name);
-				$this->consumeWhitespace();
-
-				// Per the spec, pseudo-elements must be the last items in a selector, so we
-				// check to make sure that we are either at the end of the stream or that a
-				// new selector is starting. Only one pseudo-element is allowed per selector.
-				if ($this->scanner->token !== false && $this->scanner->token !== Token::COMMA) {
-					throw new ParseException('A Pseudo-Element must be the last item in a selector.');
-				}
-			} else {
-				$this->handler->pseudoClass($name, $value);
-			}
-		}
-	}
-
-	/**
-	 * Get the value of a pseudo-classes.
-	 *
-	 * @return string
-	 *  Returns the value found from a pseudo-class.
-	 *
-	 * @todo Pseudoclasses can be passed pseudo-elements and
-	 *  other pseudo-classes as values, which means :pseudo(::pseudo)
-	 *  is legal.
-	 */
-	private function pseudoClassValue()
-	{
-		if ($this->scanner->token === Token::LPAREN) {
-			$buf = '';
-
-			// For now, just leave pseudoClass value vague.
-			/*
+        // Flag to indicate that post-checks need doing
+        $inCombinator = false;
+        $white        = $this->consumeWhitespace();
+        $t            = $this->scanner->token;
+
+        if ($t === Token::RANGLE) {
+            $this->handler->directDescendant();
+            $this->scanner->nextToken();
+            $inCombinator = true;
+            //$this->simpleSelectors();
+        } elseif ($t === Token::PLUS) {
+            $this->handler->adjacent();
+            $this->scanner->nextToken();
+            $inCombinator = true;
+            //$this->simpleSelectors();
+        } elseif ($t === Token::COMMA) {
+            $this->handler->anotherSelector();
+            $this->scanner->nextToken();
+            $inCombinator = true;
+            //$this->scanner->selectors();
+        } elseif ($t === Token::TILDE) {
+            $this->handler->sibling();
+            $this->scanner->nextToken();
+            $inCombinator = true;
+        }
+
+        // Check that we don't get two combinators in a row.
+        if ($inCombinator) {
+            if ($this->DEBUG) {
+                print 'COMBINATOR: ' . Token::name($t) . "\n";
+            }
+            $this->consumeWhitespace();
+            if ($this->isCombinator($this->scanner->token)) {
+                throw new ParseException('Illegal combinator: Cannot have two combinators in sequence.');
+            }
+        } // Check to see if we have whitespace combinator:
+        elseif ($white > 0) {
+            if ($this->DEBUG) {
+                echo 'COMBINATOR: any descendant' . PHP_EOL;
+            }
+            $this->handler->anyDescendant();
+        } else {
+            if ($this->DEBUG) {
+                echo 'COMBINATOR: no combinator found.' . PHP_EOL;
+            }
+        }
+    }
+
+    /**
+     * Check if the token is a combinator.
+     *
+     * @param int $tok
+     *
+     * @return bool
+     */
+    private function isCombinator(int $tok): bool
+    {
+        return in_array($tok, [Token::PLUS, Token::RANGLE, Token::COMMA, Token::TILDE], true);
+    }
+
+    /**
+     * Handle a simple selector.
+     *
+     * @throws ParseException
+     */
+    private function simpleSelectors(): void
+    {
+        if ($this->DEBUG) {
+            print 'SIMPLE SELECTOR' . PHP_EOL;
+        }
+        $this->allElements();
+        $this->elementName();
+        $this->elementClass();
+        $this->elementID();
+        $this->pseudoClass();
+        $this->attribute();
+    }
+
+    /**
+     * Handles CSS ID selectors.
+     * This will call EventHandler::elementID().
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    private function elementID(): void
+    {
+        if ($this->DEBUG) {
+            echo 'ELEMENT ID' . PHP_EOL;
+        }
+
+        if ($this->scanner->token === Token::OCTO) {
+            $this->scanner->nextToken();
+            if ($this->scanner->token !== Token::CHAR) {
+                throw new ParseException("Expected string after #");
+            }
+            $id = $this->scanner->getNameString();
+            $this->handler->elementID($id);
+        }
+    }
+
+    /**
+     * Handles CSS class selectors.
+     * This will call the EventHandler::elementClass() method.
+     */
+    private function elementClass(): void
+    {
+        if ($this->DEBUG) {
+            print 'ELEMENT CLASS' . PHP_EOL;
+        }
+        if ($this->scanner->token == Token::DOT) {
+            $this->scanner->nextToken();
+            $this->consumeWhitespace(); // We're very fault tolerent. This should prob through error.
+            $cssClass = $this->scanner->getNameString();
+            $this->handler->elementClass($cssClass);
+        }
+    }
+
+    /**
+     * Handle a pseudo-class and pseudo-element.
+     *
+     * CSS 3 selectors support separate pseudo-elements, using :: instead
+     * of : for separator. This is now supported, and calls the pseudoElement
+     * handler, EventHandler::pseudoElement().
+     *
+     * This will call EventHandler::pseudoClass() when a
+     * pseudo-class is parsed.
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    private function pseudoClass($restricted = false): void
+    {
+        if ($this->DEBUG) {
+            echo 'PSEUDO-CLASS' . PHP_EOL;
+        }
+        if ($this->scanner->token === Token::COLON) {
+            // Check for CSS 3 pseudo element:
+            $isPseudoElement = false;
+            if ($this->scanner->nextToken() === Token::COLON) {
+                $isPseudoElement = true;
+                $this->scanner->nextToken();
+            }
+
+            $name = $this->scanner->getNameString();
+            if ($restricted && $name === 'not') {
+                throw new ParseException("The 'not' pseudo-class is illegal in this context.");
+            }
+
+            $value = null;
+            if ($this->scanner->token === Token::LPAREN) {
+                if ($isPseudoElement) {
+                    throw new ParseException('Illegal left paren. Pseudo-Element cannot have arguments.');
+                }
+                $value = $this->pseudoClassValue();
+            }
+
+            // FIXME: This should throw errors when pseudo element has values.
+            if ($isPseudoElement) {
+                if ($restricted) {
+                    throw new ParseException('Pseudo-Elements are illegal in this context.');
+                }
+                $this->handler->pseudoElement($name);
+                $this->consumeWhitespace();
+
+                // Per the spec, pseudo-elements must be the last items in a selector, so we
+                // check to make sure that we are either at the end of the stream or that a
+                // new selector is starting. Only one pseudo-element is allowed per selector.
+                if ($this->scanner->token !== false && $this->scanner->token !== Token::COMMA) {
+                    throw new ParseException('A Pseudo-Element must be the last item in a selector.');
+                }
+            } else {
+                $this->handler->pseudoClass($name, $value);
+            }
+        }
+    }
+
+    /**
+     * Get the value of a pseudo-classes.
+     *
+     * @return string
+     *  Returns the value found from a pseudo-class.
+     *
+     * @todo Pseudoclasses can be passed pseudo-elements and
+     *  other pseudo-classes as values, which means :pseudo(::pseudo)
+     *  is legal.
+     */
+    private function pseudoClassValue()
+    {
+        if ($this->scanner->token === Token::LPAREN) {
+            $buf = '';
+
+            // For now, just leave pseudoClass value vague.
+            /*
 			// We have to peek to see if next char is a colon because
 			// pseudo-classes and pseudo-elements are legal strings here.
 			print $this->scanner->peek();
@@ -390,242 +390,242 @@ 
 			}
 			return $buf;
 			*/
-			//$buf .= $this->scanner->getQuotedString();
-			$buf .= $this->scanner->getPseudoClassString();
-
-			return $buf;
-		}
-	}
-
-	/**
-	 * Handle element names.
-	 * This will call the EventHandler::elementName().
-	 *
-	 * This handles:
-	 * <code>
-	 *  name (EventHandler::element())
-	 *  |name (EventHandler::element())
-	 *  ns|name (EventHandler::elementNS())
-	 *  ns|* (EventHandler::elementNS())
-	 * </code>
-	 */
-	private function elementName()
-	{
-		if ($this->DEBUG) {
-			print "ELEMENT NAME\n";
-		}
-		if ($this->scanner->token === Token::PIPE) {
-			// We have '|name', which is equiv to 'name'
-			$this->scanner->nextToken();
-			$this->consumeWhitespace();
-			$elementName = $this->scanner->getNameString();
-			$this->handler->element($elementName);
-		} elseif ($this->scanner->token === Token::CHAR) {
-			$elementName = $this->scanner->getNameString();
-			if ($this->scanner->token == Token::PIPE) {
-				// Get ns|name
-				$elementNS = $elementName;
-				$this->scanner->nextToken();
-				$this->consumeWhitespace();
-				if ($this->scanner->token === Token::STAR) {
-					// We have ns|*
-					$this->handler->anyElementInNS($elementNS);
-					$this->scanner->nextToken();
-				} elseif ($this->scanner->token !== Token::CHAR) {
-					$this->throwError(Token::CHAR, $this->scanner->token);
-				} else {
-					$elementName = $this->scanner->getNameString();
-					// We have ns|name
-					$this->handler->elementNS($elementName, $elementNS);
-				}
-			} else {
-				$this->handler->element($elementName);
-			}
-		}
-	}
-
-	/**
-	 * Check for all elements designators. Due to the new CSS 3 namespace
-	 * support, this is slightly more complicated, now, as it handles
-	 * the *|name and *|* cases as well as *.
-	 *
-	 * Calls EventHandler::anyElement() or EventHandler::elementName().
-	 */
-	private function allElements()
-	{
-		if ($this->scanner->token === Token::STAR) {
-			$this->scanner->nextToken();
-			if ($this->scanner->token === Token::PIPE) {
-				$this->scanner->nextToken();
-				if ($this->scanner->token === Token::STAR) {
-					// We got *|*. According to spec, this requires
-					// that the element has a namespace, so we pass it on
-					// to the handler:
-					$this->scanner->nextToken();
-					$this->handler->anyElementInNS('*');
-				} else {
-					// We got *|name, which means the name MUST be in a namespce,
-					// so we pass this off to elementNameNS().
-					$name = $this->scanner->getNameString();
-					$this->handler->elementNS($name, '*');
-				}
-			} else {
-				$this->handler->anyElement();
-			}
-		}
-	}
-
-	/**
-	 * Handler an attribute.
-	 * An attribute can be in one of two forms:
-	 * <code>[attrName]</code>
-	 * or
-	 * <code>[attrName="AttrValue"]</code>
-	 *
-	 * This may call the following event handlers: EventHandler::attribute().
-	 *
-	 * @throws ParseException
-	 * @throws Exception
-	 */
-	private function attribute()
-	{
-		if ($this->scanner->token === Token::LSQUARE) {
-			$attrVal = $op = $ns = null;
-
-			$this->scanner->nextToken();
-			$this->consumeWhitespace();
-
-			if ($this->scanner->token === Token::AT) {
-				if ($this->strict) {
-					throw new ParseException('The @ is illegal in attributes.');
-				}
-
-				$this->scanner->nextToken();
-				$this->consumeWhitespace();
-			}
-
-			if ($this->scanner->token === Token::STAR) {
-				// Global namespace... requires that attr be prefixed,
-				// so we pass this on to a namespace handler.
-				$ns = '*';
-				$this->scanner->nextToken();
-			}
-			if ($this->scanner->token === Token::PIPE) {
-				// Skip this. It's a global namespace.
-				$this->scanner->nextToken();
-				$this->consumeWhitespace();
-			}
-
-			$attrName = $this->scanner->getNameString();
-			$this->consumeWhitespace();
-
-			// Check for namespace attribute: ns|attr. We have to peek() to make
-			// sure that we haven't hit the |= operator, which looks the same.
-			if ($this->scanner->token === Token::PIPE && $this->scanner->peek() !== '=') {
-				// We have a namespaced attribute.
-				$ns = $attrName;
-				$this->scanner->nextToken();
-				$attrName = $this->scanner->getNameString();
-				$this->consumeWhitespace();
-			}
-
-			// Note: We require that operators do not have spaces
-			// between characters, e.g. ~= , not ~ =.
-
-			// Get the operator:
-			switch ($this->scanner->token) {
-				case Token::EQ:
-					$this->consumeWhitespace();
-					$op = EventHandler::IS_EXACTLY;
-					break;
-				case Token::TILDE:
-					if ($this->scanner->nextToken() !== Token::EQ) {
-						$this->throwError(Token::EQ, $this->scanner->token);
-					}
-					$op = EventHandler::CONTAINS_WITH_SPACE;
-					break;
-				case Token::PIPE:
-					if ($this->scanner->nextToken() !== Token::EQ) {
-						$this->throwError(Token::EQ, $this->scanner->token);
-					}
-					$op = EventHandler::CONTAINS_WITH_HYPHEN;
-					break;
-				case Token::STAR:
-					if ($this->scanner->nextToken() !== Token::EQ) {
-						$this->throwError(Token::EQ, $this->scanner->token);
-					}
-					$op = EventHandler::CONTAINS_IN_STRING;
-					break;
-				case Token::DOLLAR:
-					if ($this->scanner->nextToken() !== Token::EQ) {
-						$this->throwError(Token::EQ, $this->scanner->token);
-					}
-					$op = EventHandler::ENDS_WITH;
-					break;
-				case Token::CARAT:
-					if ($this->scanner->nextToken() !== Token::EQ) {
-						$this->throwError(Token::EQ, $this->scanner->token);
-					}
-					$op = EventHandler::BEGINS_WITH;
-					break;
-			}
-
-			if (isset($op)) {
-				// Consume '=' and go on.
-				$this->scanner->nextToken();
-				$this->consumeWhitespace();
-
-				// So... here we have a problem. The grammer suggests that the
-				// value here is String1 or String2, both of which are enclosed
-				// in quotes of some sort, and both of which allow lots of special
-				// characters. But the spec itself includes examples like this:
-				//   [lang=fr]
-				// So some bareword support is assumed. To get around this, we assume
-				// that bare words follow the NAME rules, while quoted strings follow
-				// the String1/String2 rules.
-
-				if ($this->scanner->token === Token::QUOTE || $this->scanner->token === Token::SQUOTE) {
-					$attrVal = $this->scanner->getQuotedString();
-				} else {
-					$attrVal = $this->scanner->getNameString();
-				}
-
-				if ($this->DEBUG) {
-					print "ATTR: $attrVal AND OP: $op\n";
-				}
-			}
-
-			$this->consumeWhitespace();
-
-			if ($this->scanner->token !== Token::RSQUARE) {
-				$this->throwError(Token::RSQUARE, $this->scanner->token);
-			}
-
-			if (isset($ns)) {
-				$this->handler->attributeNS($attrName, $ns, $attrVal, $op);
-			} elseif (isset($attrVal)) {
-				$this->handler->attribute($attrName, $attrVal, $op);
-			} else {
-				$this->handler->attribute($attrName);
-			}
-			$this->scanner->nextToken();
-		}
-	}
-
-	/**
-	 * Utility for throwing a consistantly-formatted parse error.
-	 */
-	private function throwError($expected, $got)
-	{
-		$filter = sprintf('Expected %s, got %s', Token::name($expected), Token::name($got));
-		throw new ParseException($filter);
-	}
-
-	/**
-	 * @return Scanner
-	 */
-	public function getScanner(): Scanner
-	{
-		return $this->scanner;
-	}
+            //$buf .= $this->scanner->getQuotedString();
+            $buf .= $this->scanner->getPseudoClassString();
+
+            return $buf;
+        }
+    }
+
+    /**
+     * Handle element names.
+     * This will call the EventHandler::elementName().
+     *
+     * This handles:
+     * <code>
+     *  name (EventHandler::element())
+     *  |name (EventHandler::element())
+     *  ns|name (EventHandler::elementNS())
+     *  ns|* (EventHandler::elementNS())
+     * </code>
+     */
+    private function elementName()
+    {
+        if ($this->DEBUG) {
+            print "ELEMENT NAME\n";
+        }
+        if ($this->scanner->token === Token::PIPE) {
+            // We have '|name', which is equiv to 'name'
+            $this->scanner->nextToken();
+            $this->consumeWhitespace();
+            $elementName = $this->scanner->getNameString();
+            $this->handler->element($elementName);
+        } elseif ($this->scanner->token === Token::CHAR) {
+            $elementName = $this->scanner->getNameString();
+            if ($this->scanner->token == Token::PIPE) {
+                // Get ns|name
+                $elementNS = $elementName;
+                $this->scanner->nextToken();
+                $this->consumeWhitespace();
+                if ($this->scanner->token === Token::STAR) {
+                    // We have ns|*
+                    $this->handler->anyElementInNS($elementNS);
+                    $this->scanner->nextToken();
+                } elseif ($this->scanner->token !== Token::CHAR) {
+                    $this->throwError(Token::CHAR, $this->scanner->token);
+                } else {
+                    $elementName = $this->scanner->getNameString();
+                    // We have ns|name
+                    $this->handler->elementNS($elementName, $elementNS);
+                }
+            } else {
+                $this->handler->element($elementName);
+            }
+        }
+    }
+
+    /**
+     * Check for all elements designators. Due to the new CSS 3 namespace
+     * support, this is slightly more complicated, now, as it handles
+     * the *|name and *|* cases as well as *.
+     *
+     * Calls EventHandler::anyElement() or EventHandler::elementName().
+     */
+    private function allElements()
+    {
+        if ($this->scanner->token === Token::STAR) {
+            $this->scanner->nextToken();
+            if ($this->scanner->token === Token::PIPE) {
+                $this->scanner->nextToken();
+                if ($this->scanner->token === Token::STAR) {
+                    // We got *|*. According to spec, this requires
+                    // that the element has a namespace, so we pass it on
+                    // to the handler:
+                    $this->scanner->nextToken();
+                    $this->handler->anyElementInNS('*');
+                } else {
+                    // We got *|name, which means the name MUST be in a namespce,
+                    // so we pass this off to elementNameNS().
+                    $name = $this->scanner->getNameString();
+                    $this->handler->elementNS($name, '*');
+                }
+            } else {
+                $this->handler->anyElement();
+            }
+        }
+    }
+
+    /**
+     * Handler an attribute.
+     * An attribute can be in one of two forms:
+     * <code>[attrName]</code>
+     * or
+     * <code>[attrName="AttrValue"]</code>
+     *
+     * This may call the following event handlers: EventHandler::attribute().
+     *
+     * @throws ParseException
+     * @throws Exception
+     */
+    private function attribute()
+    {
+        if ($this->scanner->token === Token::LSQUARE) {
+            $attrVal = $op = $ns = null;
+
+            $this->scanner->nextToken();
+            $this->consumeWhitespace();
+
+            if ($this->scanner->token === Token::AT) {
+                if ($this->strict) {
+                    throw new ParseException('The @ is illegal in attributes.');
+                }
+
+                $this->scanner->nextToken();
+                $this->consumeWhitespace();
+            }
+
+            if ($this->scanner->token === Token::STAR) {
+                // Global namespace... requires that attr be prefixed,
+                // so we pass this on to a namespace handler.
+                $ns = '*';
+                $this->scanner->nextToken();
+            }
+            if ($this->scanner->token === Token::PIPE) {
+                // Skip this. It's a global namespace.
+                $this->scanner->nextToken();
+                $this->consumeWhitespace();
+            }
+
+            $attrName = $this->scanner->getNameString();
+            $this->consumeWhitespace();
+
+            // Check for namespace attribute: ns|attr. We have to peek() to make
+            // sure that we haven't hit the |= operator, which looks the same.
+            if ($this->scanner->token === Token::PIPE && $this->scanner->peek() !== '=') {
+                // We have a namespaced attribute.
+                $ns = $attrName;
+                $this->scanner->nextToken();
+                $attrName = $this->scanner->getNameString();
+                $this->consumeWhitespace();
+            }
+
+            // Note: We require that operators do not have spaces
+            // between characters, e.g. ~= , not ~ =.
+
+            // Get the operator:
+            switch ($this->scanner->token) {
+                case Token::EQ:
+                    $this->consumeWhitespace();
+                    $op = EventHandler::IS_EXACTLY;
+                    break;
+                case Token::TILDE:
+                    if ($this->scanner->nextToken() !== Token::EQ) {
+                        $this->throwError(Token::EQ, $this->scanner->token);
+                    }
+                    $op = EventHandler::CONTAINS_WITH_SPACE;
+                    break;
+                case Token::PIPE:
+                    if ($this->scanner->nextToken() !== Token::EQ) {
+                        $this->throwError(Token::EQ, $this->scanner->token);
+                    }
+                    $op = EventHandler::CONTAINS_WITH_HYPHEN;
+                    break;
+                case Token::STAR:
+                    if ($this->scanner->nextToken() !== Token::EQ) {
+                        $this->throwError(Token::EQ, $this->scanner->token);
+                    }
+                    $op = EventHandler::CONTAINS_IN_STRING;
+                    break;
+                case Token::DOLLAR:
+                    if ($this->scanner->nextToken() !== Token::EQ) {
+                        $this->throwError(Token::EQ, $this->scanner->token);
+                    }
+                    $op = EventHandler::ENDS_WITH;
+                    break;
+                case Token::CARAT:
+                    if ($this->scanner->nextToken() !== Token::EQ) {
+                        $this->throwError(Token::EQ, $this->scanner->token);
+                    }
+                    $op = EventHandler::BEGINS_WITH;
+                    break;
+            }
+
+            if (isset($op)) {
+                // Consume '=' and go on.
+                $this->scanner->nextToken();
+                $this->consumeWhitespace();
+
+                // So... here we have a problem. The grammer suggests that the
+                // value here is String1 or String2, both of which are enclosed
+                // in quotes of some sort, and both of which allow lots of special
+                // characters. But the spec itself includes examples like this:
+                //   [lang=fr]
+                // So some bareword support is assumed. To get around this, we assume
+                // that bare words follow the NAME rules, while quoted strings follow
+                // the String1/String2 rules.
+
+                if ($this->scanner->token === Token::QUOTE || $this->scanner->token === Token::SQUOTE) {
+                    $attrVal = $this->scanner->getQuotedString();
+                } else {
+                    $attrVal = $this->scanner->getNameString();
+                }
+
+                if ($this->DEBUG) {
+                    print "ATTR: $attrVal AND OP: $op\n";
+                }
+            }
+
+            $this->consumeWhitespace();
+
+            if ($this->scanner->token !== Token::RSQUARE) {
+                $this->throwError(Token::RSQUARE, $this->scanner->token);
+            }
+
+            if (isset($ns)) {
+                $this->handler->attributeNS($attrName, $ns, $attrVal, $op);
+            } elseif (isset($attrVal)) {
+                $this->handler->attribute($attrName, $attrVal, $op);
+            } else {
+                $this->handler->attribute($attrName);
+            }
+            $this->scanner->nextToken();
+        }
+    }
+
+    /**
+     * Utility for throwing a consistantly-formatted parse error.
+     */
+    private function throwError($expected, $got)
+    {
+        $filter = sprintf('Expected %s, got %s', Token::name($expected), Token::name($got));
+        throw new ParseException($filter);
+    }
+
+    /**
+     * @return Scanner
+     */
+    public function getScanner(): Scanner
+    {
+        return $this->scanner;
+    }
 }

src/CSS/InputStream.php

Indentation +46 added lines, -46 removed lines

@@ -14,55 +14,55 @@
  */
 class InputStream
 {
-	protected $stream;
-	public $position = 0;
+    protected $stream;
+    public $position = 0;
 
-	/**
-	 * Build a new CSS input stream from a string.
-	 *
-	 * @param string
-	 *  String to turn into an input stream.
-	 */
-	public function __construct($string)
-	{
-		$this->stream = str_split($string);
-	}
+    /**
+     * Build a new CSS input stream from a string.
+     *
+     * @param string
+     *  String to turn into an input stream.
+     */
+    public function __construct($string)
+    {
+        $this->stream = str_split($string);
+    }
 
-	/**
-	 * Look ahead one character.
-	 *
-	 * @return char
-	 *  Returns the next character, but does not remove it from
-	 *  the stream.
-	 */
-	public function peek()
-	{
-		return $this->stream[0];
-	}
+    /**
+     * Look ahead one character.
+     *
+     * @return char
+     *  Returns the next character, but does not remove it from
+     *  the stream.
+     */
+    public function peek()
+    {
+        return $this->stream[0];
+    }
 
-	/**
-	 * Get the next unconsumed character in the stream.
-	 * This will remove that character from the front of the
-	 * stream and return it.
-	 */
-	public function consume()
-	{
-		$ret = array_shift($this->stream);
-		if (! empty($ret)) {
-			$this->position++;
-		}
+    /**
+     * Get the next unconsumed character in the stream.
+     * This will remove that character from the front of the
+     * stream and return it.
+     */
+    public function consume()
+    {
+        $ret = array_shift($this->stream);
+        if (! empty($ret)) {
+            $this->position++;
+        }
 
-		return $ret;
-	}
+        return $ret;
+    }
 
-	/**
-	 * Check if the stream is empty.
-	 *
-	 * @return boolean
-	 *   Returns TRUE when the stream is empty, FALSE otherwise.
-	 */
-	public function isEmpty()
-	{
-		return count($this->stream) === 0;
-	}
+    /**
+     * Check if the stream is empty.
+     *
+     * @return boolean
+     *   Returns TRUE when the stream is empty, FALSE otherwise.
+     */
+    public function isEmpty()
+    {
+        return count($this->stream) === 0;
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -48,7 +48,7 @@
 	public function consume()
 	{
 		$ret = array_shift($this->stream);
-		if (! empty($ret)) {
+		if (!empty($ret)) {
 			$this->position++;
 		}
 

src/Helpers/QueryMutators.php

Indentation +1061 added lines, -1061 removed lines

@@ -15,1065 +15,1065 @@
 trait QueryMutators
 {
 
-	/**
-	 * Empty everything within the specified element.
-	 *
-	 * A convenience function for removeChildren(). This is equivalent to jQuery's
-	 * empty() function. However, `empty` is a built-in in PHP, and cannot be used as a
-	 * function name.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the newly emptied elements.
-	 * @see        removeChildren()
-	 * @since      2.1
-	 * @author     eabrand
-	 * @deprecated The removeChildren() function is the preferred method.
-	 */
-	public function emptyElement(): Query
-	{
-		$this->removeChildren();
-
-		return $this;
-	}
-
-	/**
-	 * Insert the given markup as the last child.
-	 *
-	 * The markup will be inserted into each match in the set.
-	 *
-	 * The same element cannot be inserted multiple times into a document. DOM
-	 * documents do not allow a single object to be inserted multiple times
-	 * into the DOM. To insert the same XML repeatedly, we must first clone
-	 * the object. This has one practical implication: Once you have inserted
-	 * an element into the object, you cannot further manipulate the original
-	 * element and expect the changes to be replciated in the appended object.
-	 * (They are not the same -- there is no shared reference.) Instead, you
-	 * will need to retrieve the appended object and operate on that.
-	 *
-	 * @param mixed $data
-	 *  This can be either a string (the usual case), or a DOM Element.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @throws Exception
-	 * @see appendTo()
-	 * @see prepend()
-	 */
-	public function append($data): Query
-	{
-		$data = $this->prepareInsert($data);
-		if (isset($data)) {
-			if (empty($this->document->documentElement) && $this->matches->count() === 0) {
-				// Then we assume we are writing to the doc root
-				$this->document->appendChild($data);
-				$found = new SplObjectStorage();
-				$found->attach($this->document->documentElement);
-				$this->setMatches($found);
-			} else {
-				// You can only append in item once. So in cases where we
-				// need to append multiple times, we have to clone the node.
-				foreach ($this->matches as $m) {
-					// DOMDocumentFragments are even more troublesome, as they don't
-					// always clone correctly. So we have to clone their children.
-					if ($data instanceof DOMDocumentFragment) {
-						foreach ($data->childNodes as $n) {
-							$m->appendChild($n->cloneNode(true));
-						}
-					} else {
-						// Otherwise a standard clone will do.
-						$m->appendChild($data->cloneNode(true));
-					}
-
-				}
-			}
-
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Insert the given markup as the first child.
-	 *
-	 * The markup will be inserted into each match in the set.
-	 *
-	 * @param mixed $data
-	 *  This can be either a string (the usual case), or a DOM Element.
-	 *
-	 * @return DOMQuery
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @throws Exception
-	 * @see after()
-	 * @see prependTo()
-	 * @see append()
-	 * @see before()
-	 */
-	public function prepend($data): Query
-	{
-		$data = $this->prepareInsert($data);
-		if (isset($data)) {
-			foreach ($this->matches as $m) {
-				$ins = $data->cloneNode(true);
-				if ($m->hasChildNodes()) {
-					$m->insertBefore($ins, $m->childNodes->item(0));
-				} else {
-					$m->appendChild($ins);
-				}
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Take all nodes in the current object and prepend them to the children nodes of
-	 * each matched node in the passed-in DOMQuery object.
-	 *
-	 * This will iterate through each item in the current DOMQuery object and
-	 * add each item to the beginning of the children of each element in the
-	 * passed-in DOMQuery object.
-	 *
-	 * @param DOMQuery $dest
-	 *  The destination DOMQuery object.
-	 *
-	 * @return DOMQuery
-	 *  The original DOMQuery, unmodified. NOT the destination DOMQuery.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @see appendTo()
-	 * @see insertBefore()
-	 * @see insertAfter()
-	 * @see prepend()
-	 */
-	public function prependTo(Query $dest)
-	{
-		foreach ($this->matches as $m) {
-			$dest->prepend($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Insert the given data before each element in the current set of matches.
-	 *
-	 * This will take the give data (XML or HTML) and put it before each of the items that
-	 * the DOMQuery object currently contains. Contrast this with after().
-	 *
-	 * @param mixed $data
-	 *  The data to be inserted. This can be XML in a string, a DomFragment, a DOMElement,
-	 *  or the other usual suspects. (See {@link qp()}).
-	 *
-	 * @return DOMQuery
-	 *  Returns the DOMQuery with the new modifications. The list of elements currently
-	 *  selected will remain the same.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @throws Exception
-	 * @see append()
-	 * @see prepend()
-	 * @see insertBefore()
-	 * @see after()
-	 */
-	public function before($data): Query
-	{
-		$data = $this->prepareInsert($data);
-		foreach ($this->matches as $m) {
-			$ins = $data->cloneNode(true);
-			$m->parentNode->insertBefore($ins, $m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Insert the current elements into the destination document.
-	 * The items are inserted before each element in the given DOMQuery document.
-	 * That is, they will be siblings with the current elements.
-	 *
-	 * @param Query $dest
-	 *  Destination DOMQuery document.
-	 *
-	 * @return DOMQuery
-	 *  The current DOMQuery object, unaltered. Only the destination DOMQuery
-	 *  object is altered.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @see insertAfter()
-	 * @see appendTo()
-	 * @see before()
-	 */
-	public function insertBefore(Query $dest): Query
-	{
-		foreach ($this->matches as $m) {
-			$dest->before($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Insert the contents of the current DOMQuery after the nodes in the
-	 * destination DOMQuery object.
-	 *
-	 * @param Query $dest
-	 *  Destination object where the current elements will be deposited.
-	 *
-	 * @return DOMQuery
-	 *  The present DOMQuery, unaltered. Only the destination object is altered.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @see insertBefore()
-	 * @see append()
-	 * @see after()
-	 */
-	public function insertAfter(Query $dest): Query
-	{
-		foreach ($this->matches as $m) {
-			$dest->after($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Insert the given data after each element in the current DOMQuery object.
-	 *
-	 * This inserts the element as a peer to the currently matched elements.
-	 * Contrast this with {@link append()}, which inserts the data as children
-	 * of matched elements.
-	 *
-	 * @param mixed $data
-	 *  The data to be appended.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object (with the items inserted).
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @throws Exception
-	 * @see before()
-	 * @see append()
-	 */
-	public function after($data): Query
-	{
-		if (empty($data)) {
-			return $this;
-		}
-		$data = $this->prepareInsert($data);
-		foreach ($this->matches as $m) {
-			$ins = $data->cloneNode(true);
-			if (isset($m->nextSibling)) {
-				$m->parentNode->insertBefore($ins, $m->nextSibling);
-			} else {
-				$m->parentNode->appendChild($ins);
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Replace the existing element(s) in the list with a new one.
-	 *
-	 * @param mixed $new
-	 *  A DOMElement or XML in a string. This will replace all elements
-	 *  currently wrapped in the DOMQuery object.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object wrapping <b>the items that were removed</b>.
-	 *  This remains consistent with the jQuery API.
-	 * @throws Exception
-	 * @throws ParseException
-	 * @throws QueryPath
-	 * @see append()
-	 * @see prepend()
-	 * @see before()
-	 * @see after()
-	 * @see remove()
-	 * @see replaceAll()
-	 */
-	public function replaceWith($new): Query
-	{
-		$data  = $this->prepareInsert($new);
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			$parent = $m->parentNode;
-			$parent->insertBefore($data->cloneNode(true), $m);
-			$found->attach($parent->removeChild($m));
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Remove the parent element from the selected node or nodes.
-	 *
-	 * This takes the given list of nodes and "unwraps" them, moving them out of their parent
-	 * node, and then deleting the parent node.
-	 *
-	 * For example, consider this:
-	 *
-	 * @code
-	 *   <root><wrapper><content/></wrapper></root>
-	 * @endcode
-	 *
-	 * Now we can run this code:
-	 * @code
-	 *   qp($xml, 'content')->unwrap();
-	 * @endcode
-	 *
-	 * This will result in:
-	 *
-	 * @code
-	 *   <root><content/></root>
-	 * @endcode
-	 * This is the opposite of wrap().
-	 *
-	 * <b>The root element cannot be unwrapped.</b> It has no parents.
-	 * If you attempt to use unwrap on a root element, this will throw a
-	 * QueryPath::Exception. (You can, however, "Unwrap" a child that is
-	 * a direct descendant of the root element. This will remove the root
-	 * element, and replace the child as the root element. Be careful, though.
-	 * You cannot set more than one child as a root element.)
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object, with the same element(s) selected.
-	 * @throws Exception
-	 * @see    wrap()
-	 * @since  2.1
-	 * @author mbutcher
-	 */
-	public function unwrap(): Query
-	{
-		// We do this in two loops in order to
-		// capture the case where two matches are
-		// under the same parent. Othwerwise we might
-		// remove a match before we can move it.
-		$parents = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-
-			// Cannot unwrap the root element.
-			if ($m->isSameNode($m->ownerDocument->documentElement)) {
-				throw new Exception('Cannot unwrap the root element.');
-			}
-
-			// Move children to peer of parent.
-			$parent = $m->parentNode;
-			$old    = $parent->removeChild($m);
-			$parent->parentNode->insertBefore($old, $parent);
-			$parents->attach($parent);
-		}
-
-		// Now that all the children are moved, we
-		// remove all of the parents.
-		foreach ($parents as $ele) {
-			$ele->parentNode->removeChild($ele);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Wrap each element inside of the given markup.
-	 *
-	 * Markup is usually a string, but it can also be a DOMNode, a document
-	 * fragment, a SimpleXMLElement, or another DOMNode object (in which case
-	 * the first item in the list will be used.)
-	 *
-	 * @param mixed $markup
-	 *  Markup that will wrap each element in the current list.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the wrapping changes made.
-	 * @throws Exception
-	 * @throws QueryPath
-	 * @see wrapAll()
-	 * @see wrapInner()
-	 */
-	public function wrap($markup): Query
-	{
-		$data = $this->prepareInsert($markup);
-
-		// If the markup passed in is empty, we don't do any wrapping.
-		if (empty($data)) {
-			return $this;
-		}
-
-		foreach ($this->matches as $m) {
-			if ($data instanceof DOMDocumentFragment) {
-				$copy = $data->firstChild->cloneNode(true);
-			} else {
-				$copy = $data->cloneNode(true);
-			}
-
-			// XXX: Should be able to avoid doing this over and over.
-			if ($copy->hasChildNodes()) {
-				$deepest = $this->deepestNode($copy);
-				// FIXME: Does this need a different data structure?
-				$bottom = $deepest[0];
-			} else {
-				$bottom = $copy;
-			}
-
-			$parent = $m->parentNode;
-			$parent->insertBefore($copy, $m);
-			$m = $parent->removeChild($m);
-			$bottom->appendChild($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Wrap all elements inside of the given markup.
-	 *
-	 * So all elements will be grouped together under this single marked up
-	 * item. This works by first determining the parent element of the first item
-	 * in the list. It then moves all of the matching elements under the wrapper
-	 * and inserts the wrapper where that first element was found. (This is in
-	 * accordance with the way jQuery works.)
-	 *
-	 * Markup is usually XML in a string, but it can also be a DOMNode, a document
-	 * fragment, a SimpleXMLElement, or another DOMNode object (in which case
-	 * the first item in the list will be used.)
-	 *
-	 * @param string $markup
-	 *  Markup that will wrap all elements in the current list.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the wrapping changes made.
-	 * @throws Exception
-	 * @throws QueryPath
-	 * @see wrap()
-	 * @see wrapInner()
-	 */
-	public function wrapAll($markup)
-	{
-		if ($this->matches->count() === 0) {
-			return;
-		}
-
-		$data = $this->prepareInsert($markup);
-
-		if (empty($data)) {
-			return $this;
-		}
-
-		if ($data instanceof DOMDocumentFragment) {
-			$data = $data->firstChild->cloneNode(true);
-		} else {
-			$data = $data->cloneNode(true);
-		}
-
-		if ($data->hasChildNodes()) {
-			$deepest = $this->deepestNode($data);
-			// FIXME: Does this need fixing?
-			$bottom = $deepest[0];
-		} else {
-			$bottom = $data;
-		}
-
-		$first  = $this->getFirstMatch();
-		$parent = $first->parentNode;
-		$parent->insertBefore($data, $first);
-		foreach ($this->matches as $m) {
-			$bottom->appendChild($m->parentNode->removeChild($m));
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Wrap the child elements of each item in the list with the given markup.
-	 *
-	 * Markup is usually a string, but it can also be a DOMNode, a document
-	 * fragment, a SimpleXMLElement, or another DOMNode object (in which case
-	 * the first item in the list will be used.)
-	 *
-	 * @param string $markup
-	 *  Markup that will wrap children of each element in the current list.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the wrapping changes made.
-	 * @throws Exception
-	 * @throws QueryPath
-	 * @see wrap()
-	 * @see wrapAll()
-	 */
-	public function wrapInner($markup)
-	{
-		$data = $this->prepareInsert($markup);
-
-		// No data? Short circuit.
-		if (empty($data)) {
-			return $this;
-		}
-
-		foreach ($this->matches as $m) {
-			if ($data instanceof DOMDocumentFragment) {
-				$wrapper = $data->firstChild->cloneNode(true);
-			} else {
-				$wrapper = $data->cloneNode(true);
-			}
-
-			if ($wrapper->hasChildNodes()) {
-				$deepest = $this->deepestNode($wrapper);
-				// FIXME: ???
-				$bottom = $deepest[0];
-			} else {
-				$bottom = $wrapper;
-			}
-
-			if ($m->hasChildNodes()) {
-				while ($m->firstChild) {
-					$kid = $m->removeChild($m->firstChild);
-					$bottom->appendChild($kid);
-				}
-			}
-
-			$m->appendChild($wrapper);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Reduce the set of matches to the deepest child node in the tree.
-	 *
-	 * This loops through the matches and looks for the deepest child node of all of
-	 * the matches. "Deepest", here, is relative to the nodes in the list. It is
-	 * calculated as the distance from the starting node to the most distant child
-	 * node. In other words, it is not necessarily the farthest node from the root
-	 * element, but the farthest note from the matched element.
-	 *
-	 * In the case where there are multiple nodes at the same depth, all of the
-	 * nodes at that depth will be included.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery wrapping the single deepest node.
-	 * @throws ParseException
-	 */
-	public function deepest(): Query
-	{
-		$deepest = 0;
-		$winner  = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			$local_deepest = 0;
-			$local_ele     = $this->deepestNode($m, 0, null, $local_deepest);
-
-			// Replace with the new deepest.
-			if ($local_deepest > $deepest) {
-				$winner = new SplObjectStorage();
-				foreach ($local_ele as $lele) {
-					$winner->attach($lele);
-				}
-				$deepest = $local_deepest;
-			} // Augument with other equally deep elements.
-			elseif ($local_deepest === $deepest) {
-				foreach ($local_ele as $lele) {
-					$winner->attach($lele);
-				}
-			}
-		}
-
-		return $this->inst($winner, null);
-	}
-
-	/**
-	 * Add a class to all elements in the current DOMQuery.
-	 *
-	 * This searchers for a class attribute on each item wrapped by the current
-	 * DOMNode object. If no attribute is found, a new one is added and its value
-	 * is set to $class. If a class attribute is found, then the value is appended
-	 * on to the end.
-	 *
-	 * @param string $class
-	 *  The name of the class.
-	 *
-	 * @return DOMQuery
-	 *  Returns the DOMQuery object.
-	 * @see css()
-	 * @see attr()
-	 * @see removeClass()
-	 * @see hasClass()
-	 */
-	public function addClass($class)
-	{
-		foreach ($this->matches as $m) {
-			if ($m->hasAttribute('class')) {
-				$val = $m->getAttribute('class');
-				$m->setAttribute('class', $val . ' ' . $class);
-			} else {
-				$m->setAttribute('class', $class);
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Remove the named class from any element in the DOMQuery that has it.
-	 *
-	 * This may result in the entire class attribute being removed. If there
-	 * are other items in the class attribute, though, they will not be removed.
-	 *
-	 * Example:
-	 * Consider this XML:
-	 *
-	 * @code
-	 * <element class="first second"/>
-	 * @endcode
-	 *
-	 * Executing this fragment of code will remove only the 'first' class:
-	 * @code
-	 * qp(document, 'element')->removeClass('first');
-	 * @endcode
-	 *
-	 * The resulting XML will be:
-	 * @code
-	 * <element class="second"/>
-	 * @endcode
-	 *
-	 * To remove the entire 'class' attribute, you should use {@see removeAttr()}.
-	 *
-	 * @param string $class
-	 *  The class name to remove.
-	 *
-	 * @return DOMQuery
-	 *  The modified DOMNode object.
-	 * @see attr()
-	 * @see addClass()
-	 * @see hasClass()
-	 */
-	public function removeClass($class = false): Query
-	{
-		if (empty($class)) {
-			foreach ($this->matches as $m) {
-				$m->removeAttribute('class');
-			}
-		} else {
-			$to_remove = array_filter(explode(' ', $class));
-			foreach ($this->matches as $m) {
-				if ($m->hasAttribute('class')) {
-					$vals = array_filter(explode(' ', $m->getAttribute('class')));
-					$buf  = [];
-					foreach ($vals as $v) {
-						if (! in_array($v, $to_remove)) {
-							$buf[] = $v;
-						}
-					}
-					if (empty($buf)) {
-						$m->removeAttribute('class');
-					} else {
-						$m->setAttribute('class', implode(' ', $buf));
-					}
-				}
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Detach any items from the list if they match the selector.
-	 *
-	 * In other words, each item that matches the selector will be removed
-	 * from the DOM document. The returned DOMQuery wraps the list of
-	 * removed elements.
-	 *
-	 * If no selector is specified, this will remove all current matches from
-	 * the document.
-	 *
-	 * @param string $selector
-	 *  A CSS Selector.
-	 *
-	 * @return DOMQuery
-	 *  The Query path wrapping a list of removed items.
-	 * @throws ParseException
-	 * @see    replaceWith()
-	 * @see    removeChildren()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    replaceAll()
-	 */
-	public function detach($selector = null): Query
-	{
-		if (null !== $selector) {
-			$this->find($selector);
-		}
-
-		$found      = new SplObjectStorage();
-		$this->last = $this->matches;
-		foreach ($this->matches as $item) {
-			// The item returned is (according to docs) different from
-			// the one passed in, so we have to re-store it.
-			$found->attach($item->parentNode->removeChild($item));
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Attach any items from the list if they match the selector.
-	 *
-	 * If no selector is specified, this will remove all current matches from
-	 * the document.
-	 *
-	 * @param DOMQuery $dest
-	 *  A DOMQuery Selector.
-	 *
-	 * @return DOMQuery
-	 *  The Query path wrapping a list of removed items.
-	 * @throws QueryPath
-	 * @throws Exception
-	 * @see    removeChildren()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    replaceAll()
-	 * @see    replaceWith()
-	 */
-	public function attach(DOMQuery $dest): Query
-	{
-		foreach ($this->last as $m) {
-			$dest->append($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Append the current elements to the destination passed into the function.
-	 *
-	 * This cycles through all of the current matches and appends them to
-	 * the context given in $destination. If a selector is provided then the
-	 * $destination is queried (using that selector) prior to the data being
-	 * appended. The data is then appended to the found items.
-	 *
-	 * @param DOMQuery $dest
-	 *  A DOMQuery object that will be appended to.
-	 *
-	 * @return DOMQuery
-	 *  The original DOMQuery, unaltered. Only the destination DOMQuery will
-	 *  be modified.
-	 * @throws QueryPath::Exception
-	 *  Thrown if $data is an unsupported object type.
-	 * @throws Exception
-	 * @see append()
-	 * @see prependTo()
-	 */
-	public function appendTo(DOMQuery $dest): Query
-	{
-		foreach ($this->matches as $m) {
-			$dest->append($m);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Remove any items from the list if they match the selector.
-	 *
-	 * In other words, each item that matches the selector will be remove
-	 * from the DOM document. The returned DOMQuery wraps the list of
-	 * removed elements.
-	 *
-	 * If no selector is specified, this will remove all current matches from
-	 * the document.
-	 *
-	 * @param string $selector
-	 *  A CSS Selector.
-	 *
-	 * @return DOMQuery
-	 *  The Query path wrapping a list of removed items.
-	 * @throws ParseException
-	 * @see replaceWith()
-	 * @see removeChildren()
-	 * @see replaceAll()
-	 */
-	public function remove($selector = null): Query
-	{
-		if (! empty($selector)) {
-			// Do a non-destructive find.
-			$query = new QueryPathEventHandler($this->matches);
-			$query->find($selector);
-			$matches = $query->getMatches();
-		} else {
-			$matches = $this->matches;
-		}
-
-		$found = new SplObjectStorage();
-		foreach ($matches as $item) {
-			// The item returned is (according to docs) different from
-			// the one passed in, so we have to re-store it.
-			$found->attach($item->parentNode->removeChild($item));
-		}
-
-		// Return a clone DOMQuery with just the removed items. If
-		// no items are found, this will return an empty DOMQuery.
-		return count($found) === 0 ? new static() : new static($found);
-	}
-
-	/**
-	 * This replaces everything that matches the selector with the first value
-	 * in the current list.
-	 *
-	 * This is the reverse of replaceWith.
-	 *
-	 * Unlike jQuery, DOMQuery cannot assume a default document. Consequently,
-	 * you must specify the intended destination document. If it is omitted, the
-	 * present document is assumed to be tthe document. However, that can result
-	 * in undefined behavior if the selector and the replacement are not sufficiently
-	 * distinct.
-	 *
-	 * @param string       $selector
-	 *  The selector.
-	 * @param DOMDocument $document
-	 *  The destination document.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery wrapping the modified document.
-	 * @throws ParseException
-	 * @see        remove()
-	 * @see        replaceWith()
-	 * @deprecated Due to the fact that this is not a particularly friendly method,
-	 *             and that it can be easily replicated using {@see replaceWith()}, it is to be
-	 *             considered deprecated.
-	 */
-	public function replaceAll($selector, DOMDocument $document): Query
-	{
-		$replacement = $this->matches->count() > 0 ? $this->getFirstMatch() : $this->document->createTextNode('');
-
-		$c = new QueryPathEventHandler($document);
-		$c->find($selector);
-		$temp = $c->getMatches();
-		foreach ($temp as $item) {
-			$node = $replacement->cloneNode();
-			$node = $document->importNode($node);
-			$item->parentNode->replaceChild($node, $item);
-		}
-
-		return QueryPath::with($document, null, $this->options);
-	}
-
-	/**
-	 * Add more elements to the current set of matches.
-	 *
-	 * This begins the new query at the top of the DOM again. The results found
-	 * when running this selector are then merged into the existing results. In
-	 * this way, you can add additional elements to the existing set.
-	 *
-	 * @param string $selector
-	 *  A valid selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the newly added elements.
-	 * @see append()
-	 * @see after()
-	 * @see andSelf()
-	 * @see end()
-	 */
-	public function add($selector): Query
-	{
-
-		// This is destructive, so we need to set $last:
-		$this->last = $this->matches;
-
-		foreach (QueryPath::with($this->document, $selector, $this->options)->get() as $item) {
-			$this->matches->attach($item);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Remove all child nodes.
-	 *
-	 * This is equivalent to jQuery's empty() function. (However, empty() is a
-	 * PHP built-in, and cannot be used as a method name.)
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the child nodes removed.
-	 * @see replaceWith()
-	 * @see replaceAll()
-	 * @see remove()
-	 */
-	public function removeChildren(): Query
-	{
-		foreach ($this->matches as $m) {
-			while ($kid = $m->firstChild) {
-				$m->removeChild($kid);
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Get/set an attribute.
-	 * - If no parameters are specified, this returns an associative array of all
-	 *   name/value pairs.
-	 * - If both $name and $value are set, then this will set the attribute name/value
-	 *   pair for all items in this object.
-	 * - If $name is set, and is an array, then
-	 *   all attributes in the array will be set for all items in this object.
-	 * - If $name is a string and is set, then the attribute value will be returned.
-	 *
-	 * When an attribute value is retrieved, only the attribute value of the FIRST
-	 * match is returned.
-	 *
-	 * @param mixed  $name
-	 *   The name of the attribute or an associative array of name/value pairs.
-	 * @param string $value
-	 *   A value (used only when setting an individual property).
-	 *
-	 * @return mixed
-	 *   If this was a setter request, return the DOMQuery object. If this was
-	 *   an access request (getter), return the string value.
-	 * @see removeAttr()
-	 * @see tag()
-	 * @see hasAttr()
-	 * @see hasClass()
-	 */
-	public function attr($name = null, $value = null)
-	{
-		// Default case: Return all attributes as an assoc array.
-		if (is_null($name)) {
-			if ($this->matches->count() === 0) {
-				return null;
-			}
-			$ele    = $this->getFirstMatch();
-			$buffer = [];
-
-			// This does not appear to be part of the DOM
-			// spec. Nor is it documented. But it works.
-			foreach ($ele->attributes as $name => $attrNode) {
-				$buffer[$name] = $attrNode->value;
-			}
-
-			return $buffer;
-		}
-
-		// multi-setter
-		if (is_array($name)) {
-			foreach ($name as $k => $v) {
-				foreach ($this->matches as $m) {
-					$m->setAttribute($k, $v);
-				}
-			}
-
-			return $this;
-		}
-		// setter
-		if (isset($value)) {
-			foreach ($this->matches as $m) {
-				$m->setAttribute($name, $value);
-			}
-
-			return $this;
-		}
-
-		//getter
-		if ($this->matches->count() === 0) {
-			return null;
-		}
-
-		// Special node type handler:
-		if ($name === 'nodeType') {
-			return $this->getFirstMatch()->nodeType;
-		}
-
-		// Always return first match's attr.
-		return $this->getFirstMatch()->getAttribute($name);
-	}
-
-	/**
-	 * Set/get a CSS value for the current element(s).
-	 * This sets the CSS value for each element in the DOMQuery object.
-	 * It does this by setting (or getting) the style attribute (without a namespace).
-	 *
-	 * For example, consider this code:
-	 *
-	 * @code
-	 * <?php
-	 * qp(HTML_STUB, 'body')->css('background-color','red')->html();
-	 * ?>
-	 * @endcode
-	 * This will return the following HTML:
-	 * @code
-	 * <body style="background-color: red"/>
-	 * @endcode
-	 *
-	 * If no parameters are passed into this function, then the current style
-	 * element will be returned unparsed. Example:
-	 * @code
-	 * <?php
-	 * qp(HTML_STUB, 'body')->css('background-color','red')->css();
-	 * ?>
-	 * @endcode
-	 * This will return the following:
-	 * @code
-	 * background-color: red
-	 * @endcode
-	 *
-	 * As of QueryPath 2.1, existing style attributes will be merged with new attributes.
-	 * (In previous versions of QueryPath, a call to css() overwrite the existing style
-	 * values).
-	 *
-	 * @param mixed  $name
-	 *  If this is a string, it will be used as a CSS name. If it is an array,
-	 *  this will assume it is an array of name/value pairs of CSS rules. It will
-	 *  apply all rules to all elements in the set.
-	 * @param string $value
-	 *  The value to set. This is only set if $name is a string.
-	 *
-	 * @return DOMQuery
-	 */
-	public function css($name = null, $value = '')
-	{
-		if (empty($name)) {
-			return $this->attr('style');
-		}
-
-		// Get any existing CSS.
-		$css = [];
-		foreach ($this->matches as $match) {
-			$style = $match->getAttribute('style');
-			if (! empty($style)) {
-				// XXX: Is this sufficient?
-				$style_array = explode(';', $style);
-				foreach ($style_array as $item) {
-					$item = trim($item);
-
-					// Skip empty attributes.
-					if ($item === '') {
-						continue;
-					}
-
-					[$css_att, $css_val] = explode(':', $item, 2);
-					$css[$css_att] = trim($css_val);
-				}
-			}
-		}
-
-		if (is_array($name)) {
-			// Use array_merge instead of + to preserve order.
-			$css = array_merge($css, $name);
-		} else {
-			$css[$name] = $value;
-		}
-
-		// Collapse CSS into a string.
-		$format     = '%s: %s;';
-		$css_string = '';
-		foreach ($css as $n => $v) {
-			$css_string .= sprintf($format, $n, trim($v));
-		}
-
-		$this->attr('style', $css_string);
-
-		return $this;
-	}
+    /**
+     * Empty everything within the specified element.
+     *
+     * A convenience function for removeChildren(). This is equivalent to jQuery's
+     * empty() function. However, `empty` is a built-in in PHP, and cannot be used as a
+     * function name.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the newly emptied elements.
+     * @see        removeChildren()
+     * @since      2.1
+     * @author     eabrand
+     * @deprecated The removeChildren() function is the preferred method.
+     */
+    public function emptyElement(): Query
+    {
+        $this->removeChildren();
+
+        return $this;
+    }
+
+    /**
+     * Insert the given markup as the last child.
+     *
+     * The markup will be inserted into each match in the set.
+     *
+     * The same element cannot be inserted multiple times into a document. DOM
+     * documents do not allow a single object to be inserted multiple times
+     * into the DOM. To insert the same XML repeatedly, we must first clone
+     * the object. This has one practical implication: Once you have inserted
+     * an element into the object, you cannot further manipulate the original
+     * element and expect the changes to be replciated in the appended object.
+     * (They are not the same -- there is no shared reference.) Instead, you
+     * will need to retrieve the appended object and operate on that.
+     *
+     * @param mixed $data
+     *  This can be either a string (the usual case), or a DOM Element.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @throws Exception
+     * @see appendTo()
+     * @see prepend()
+     */
+    public function append($data): Query
+    {
+        $data = $this->prepareInsert($data);
+        if (isset($data)) {
+            if (empty($this->document->documentElement) && $this->matches->count() === 0) {
+                // Then we assume we are writing to the doc root
+                $this->document->appendChild($data);
+                $found = new SplObjectStorage();
+                $found->attach($this->document->documentElement);
+                $this->setMatches($found);
+            } else {
+                // You can only append in item once. So in cases where we
+                // need to append multiple times, we have to clone the node.
+                foreach ($this->matches as $m) {
+                    // DOMDocumentFragments are even more troublesome, as they don't
+                    // always clone correctly. So we have to clone their children.
+                    if ($data instanceof DOMDocumentFragment) {
+                        foreach ($data->childNodes as $n) {
+                            $m->appendChild($n->cloneNode(true));
+                        }
+                    } else {
+                        // Otherwise a standard clone will do.
+                        $m->appendChild($data->cloneNode(true));
+                    }
+
+                }
+            }
+
+        }
+
+        return $this;
+    }
+
+    /**
+     * Insert the given markup as the first child.
+     *
+     * The markup will be inserted into each match in the set.
+     *
+     * @param mixed $data
+     *  This can be either a string (the usual case), or a DOM Element.
+     *
+     * @return DOMQuery
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @throws Exception
+     * @see after()
+     * @see prependTo()
+     * @see append()
+     * @see before()
+     */
+    public function prepend($data): Query
+    {
+        $data = $this->prepareInsert($data);
+        if (isset($data)) {
+            foreach ($this->matches as $m) {
+                $ins = $data->cloneNode(true);
+                if ($m->hasChildNodes()) {
+                    $m->insertBefore($ins, $m->childNodes->item(0));
+                } else {
+                    $m->appendChild($ins);
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Take all nodes in the current object and prepend them to the children nodes of
+     * each matched node in the passed-in DOMQuery object.
+     *
+     * This will iterate through each item in the current DOMQuery object and
+     * add each item to the beginning of the children of each element in the
+     * passed-in DOMQuery object.
+     *
+     * @param DOMQuery $dest
+     *  The destination DOMQuery object.
+     *
+     * @return DOMQuery
+     *  The original DOMQuery, unmodified. NOT the destination DOMQuery.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @see appendTo()
+     * @see insertBefore()
+     * @see insertAfter()
+     * @see prepend()
+     */
+    public function prependTo(Query $dest)
+    {
+        foreach ($this->matches as $m) {
+            $dest->prepend($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Insert the given data before each element in the current set of matches.
+     *
+     * This will take the give data (XML or HTML) and put it before each of the items that
+     * the DOMQuery object currently contains. Contrast this with after().
+     *
+     * @param mixed $data
+     *  The data to be inserted. This can be XML in a string, a DomFragment, a DOMElement,
+     *  or the other usual suspects. (See {@link qp()}).
+     *
+     * @return DOMQuery
+     *  Returns the DOMQuery with the new modifications. The list of elements currently
+     *  selected will remain the same.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @throws Exception
+     * @see append()
+     * @see prepend()
+     * @see insertBefore()
+     * @see after()
+     */
+    public function before($data): Query
+    {
+        $data = $this->prepareInsert($data);
+        foreach ($this->matches as $m) {
+            $ins = $data->cloneNode(true);
+            $m->parentNode->insertBefore($ins, $m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Insert the current elements into the destination document.
+     * The items are inserted before each element in the given DOMQuery document.
+     * That is, they will be siblings with the current elements.
+     *
+     * @param Query $dest
+     *  Destination DOMQuery document.
+     *
+     * @return DOMQuery
+     *  The current DOMQuery object, unaltered. Only the destination DOMQuery
+     *  object is altered.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @see insertAfter()
+     * @see appendTo()
+     * @see before()
+     */
+    public function insertBefore(Query $dest): Query
+    {
+        foreach ($this->matches as $m) {
+            $dest->before($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Insert the contents of the current DOMQuery after the nodes in the
+     * destination DOMQuery object.
+     *
+     * @param Query $dest
+     *  Destination object where the current elements will be deposited.
+     *
+     * @return DOMQuery
+     *  The present DOMQuery, unaltered. Only the destination object is altered.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @see insertBefore()
+     * @see append()
+     * @see after()
+     */
+    public function insertAfter(Query $dest): Query
+    {
+        foreach ($this->matches as $m) {
+            $dest->after($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Insert the given data after each element in the current DOMQuery object.
+     *
+     * This inserts the element as a peer to the currently matched elements.
+     * Contrast this with {@link append()}, which inserts the data as children
+     * of matched elements.
+     *
+     * @param mixed $data
+     *  The data to be appended.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object (with the items inserted).
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @throws Exception
+     * @see before()
+     * @see append()
+     */
+    public function after($data): Query
+    {
+        if (empty($data)) {
+            return $this;
+        }
+        $data = $this->prepareInsert($data);
+        foreach ($this->matches as $m) {
+            $ins = $data->cloneNode(true);
+            if (isset($m->nextSibling)) {
+                $m->parentNode->insertBefore($ins, $m->nextSibling);
+            } else {
+                $m->parentNode->appendChild($ins);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Replace the existing element(s) in the list with a new one.
+     *
+     * @param mixed $new
+     *  A DOMElement or XML in a string. This will replace all elements
+     *  currently wrapped in the DOMQuery object.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object wrapping <b>the items that were removed</b>.
+     *  This remains consistent with the jQuery API.
+     * @throws Exception
+     * @throws ParseException
+     * @throws QueryPath
+     * @see append()
+     * @see prepend()
+     * @see before()
+     * @see after()
+     * @see remove()
+     * @see replaceAll()
+     */
+    public function replaceWith($new): Query
+    {
+        $data  = $this->prepareInsert($new);
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            $parent = $m->parentNode;
+            $parent->insertBefore($data->cloneNode(true), $m);
+            $found->attach($parent->removeChild($m));
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Remove the parent element from the selected node or nodes.
+     *
+     * This takes the given list of nodes and "unwraps" them, moving them out of their parent
+     * node, and then deleting the parent node.
+     *
+     * For example, consider this:
+     *
+     * @code
+     *   <root><wrapper><content/></wrapper></root>
+     * @endcode
+     *
+     * Now we can run this code:
+     * @code
+     *   qp($xml, 'content')->unwrap();
+     * @endcode
+     *
+     * This will result in:
+     *
+     * @code
+     *   <root><content/></root>
+     * @endcode
+     * This is the opposite of wrap().
+     *
+     * <b>The root element cannot be unwrapped.</b> It has no parents.
+     * If you attempt to use unwrap on a root element, this will throw a
+     * QueryPath::Exception. (You can, however, "Unwrap" a child that is
+     * a direct descendant of the root element. This will remove the root
+     * element, and replace the child as the root element. Be careful, though.
+     * You cannot set more than one child as a root element.)
+     *
+     * @return DOMQuery
+     *  The DOMQuery object, with the same element(s) selected.
+     * @throws Exception
+     * @see    wrap()
+     * @since  2.1
+     * @author mbutcher
+     */
+    public function unwrap(): Query
+    {
+        // We do this in two loops in order to
+        // capture the case where two matches are
+        // under the same parent. Othwerwise we might
+        // remove a match before we can move it.
+        $parents = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+
+            // Cannot unwrap the root element.
+            if ($m->isSameNode($m->ownerDocument->documentElement)) {
+                throw new Exception('Cannot unwrap the root element.');
+            }
+
+            // Move children to peer of parent.
+            $parent = $m->parentNode;
+            $old    = $parent->removeChild($m);
+            $parent->parentNode->insertBefore($old, $parent);
+            $parents->attach($parent);
+        }
+
+        // Now that all the children are moved, we
+        // remove all of the parents.
+        foreach ($parents as $ele) {
+            $ele->parentNode->removeChild($ele);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Wrap each element inside of the given markup.
+     *
+     * Markup is usually a string, but it can also be a DOMNode, a document
+     * fragment, a SimpleXMLElement, or another DOMNode object (in which case
+     * the first item in the list will be used.)
+     *
+     * @param mixed $markup
+     *  Markup that will wrap each element in the current list.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the wrapping changes made.
+     * @throws Exception
+     * @throws QueryPath
+     * @see wrapAll()
+     * @see wrapInner()
+     */
+    public function wrap($markup): Query
+    {
+        $data = $this->prepareInsert($markup);
+
+        // If the markup passed in is empty, we don't do any wrapping.
+        if (empty($data)) {
+            return $this;
+        }
+
+        foreach ($this->matches as $m) {
+            if ($data instanceof DOMDocumentFragment) {
+                $copy = $data->firstChild->cloneNode(true);
+            } else {
+                $copy = $data->cloneNode(true);
+            }
+
+            // XXX: Should be able to avoid doing this over and over.
+            if ($copy->hasChildNodes()) {
+                $deepest = $this->deepestNode($copy);
+                // FIXME: Does this need a different data structure?
+                $bottom = $deepest[0];
+            } else {
+                $bottom = $copy;
+            }
+
+            $parent = $m->parentNode;
+            $parent->insertBefore($copy, $m);
+            $m = $parent->removeChild($m);
+            $bottom->appendChild($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Wrap all elements inside of the given markup.
+     *
+     * So all elements will be grouped together under this single marked up
+     * item. This works by first determining the parent element of the first item
+     * in the list. It then moves all of the matching elements under the wrapper
+     * and inserts the wrapper where that first element was found. (This is in
+     * accordance with the way jQuery works.)
+     *
+     * Markup is usually XML in a string, but it can also be a DOMNode, a document
+     * fragment, a SimpleXMLElement, or another DOMNode object (in which case
+     * the first item in the list will be used.)
+     *
+     * @param string $markup
+     *  Markup that will wrap all elements in the current list.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the wrapping changes made.
+     * @throws Exception
+     * @throws QueryPath
+     * @see wrap()
+     * @see wrapInner()
+     */
+    public function wrapAll($markup)
+    {
+        if ($this->matches->count() === 0) {
+            return;
+        }
+
+        $data = $this->prepareInsert($markup);
+
+        if (empty($data)) {
+            return $this;
+        }
+
+        if ($data instanceof DOMDocumentFragment) {
+            $data = $data->firstChild->cloneNode(true);
+        } else {
+            $data = $data->cloneNode(true);
+        }
+
+        if ($data->hasChildNodes()) {
+            $deepest = $this->deepestNode($data);
+            // FIXME: Does this need fixing?
+            $bottom = $deepest[0];
+        } else {
+            $bottom = $data;
+        }
+
+        $first  = $this->getFirstMatch();
+        $parent = $first->parentNode;
+        $parent->insertBefore($data, $first);
+        foreach ($this->matches as $m) {
+            $bottom->appendChild($m->parentNode->removeChild($m));
+        }
+
+        return $this;
+    }
+
+    /**
+     * Wrap the child elements of each item in the list with the given markup.
+     *
+     * Markup is usually a string, but it can also be a DOMNode, a document
+     * fragment, a SimpleXMLElement, or another DOMNode object (in which case
+     * the first item in the list will be used.)
+     *
+     * @param string $markup
+     *  Markup that will wrap children of each element in the current list.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the wrapping changes made.
+     * @throws Exception
+     * @throws QueryPath
+     * @see wrap()
+     * @see wrapAll()
+     */
+    public function wrapInner($markup)
+    {
+        $data = $this->prepareInsert($markup);
+
+        // No data? Short circuit.
+        if (empty($data)) {
+            return $this;
+        }
+
+        foreach ($this->matches as $m) {
+            if ($data instanceof DOMDocumentFragment) {
+                $wrapper = $data->firstChild->cloneNode(true);
+            } else {
+                $wrapper = $data->cloneNode(true);
+            }
+
+            if ($wrapper->hasChildNodes()) {
+                $deepest = $this->deepestNode($wrapper);
+                // FIXME: ???
+                $bottom = $deepest[0];
+            } else {
+                $bottom = $wrapper;
+            }
+
+            if ($m->hasChildNodes()) {
+                while ($m->firstChild) {
+                    $kid = $m->removeChild($m->firstChild);
+                    $bottom->appendChild($kid);
+                }
+            }
+
+            $m->appendChild($wrapper);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Reduce the set of matches to the deepest child node in the tree.
+     *
+     * This loops through the matches and looks for the deepest child node of all of
+     * the matches. "Deepest", here, is relative to the nodes in the list. It is
+     * calculated as the distance from the starting node to the most distant child
+     * node. In other words, it is not necessarily the farthest node from the root
+     * element, but the farthest note from the matched element.
+     *
+     * In the case where there are multiple nodes at the same depth, all of the
+     * nodes at that depth will be included.
+     *
+     * @return DOMQuery
+     *  The DOMQuery wrapping the single deepest node.
+     * @throws ParseException
+     */
+    public function deepest(): Query
+    {
+        $deepest = 0;
+        $winner  = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            $local_deepest = 0;
+            $local_ele     = $this->deepestNode($m, 0, null, $local_deepest);
+
+            // Replace with the new deepest.
+            if ($local_deepest > $deepest) {
+                $winner = new SplObjectStorage();
+                foreach ($local_ele as $lele) {
+                    $winner->attach($lele);
+                }
+                $deepest = $local_deepest;
+            } // Augument with other equally deep elements.
+            elseif ($local_deepest === $deepest) {
+                foreach ($local_ele as $lele) {
+                    $winner->attach($lele);
+                }
+            }
+        }
+
+        return $this->inst($winner, null);
+    }
+
+    /**
+     * Add a class to all elements in the current DOMQuery.
+     *
+     * This searchers for a class attribute on each item wrapped by the current
+     * DOMNode object. If no attribute is found, a new one is added and its value
+     * is set to $class. If a class attribute is found, then the value is appended
+     * on to the end.
+     *
+     * @param string $class
+     *  The name of the class.
+     *
+     * @return DOMQuery
+     *  Returns the DOMQuery object.
+     * @see css()
+     * @see attr()
+     * @see removeClass()
+     * @see hasClass()
+     */
+    public function addClass($class)
+    {
+        foreach ($this->matches as $m) {
+            if ($m->hasAttribute('class')) {
+                $val = $m->getAttribute('class');
+                $m->setAttribute('class', $val . ' ' . $class);
+            } else {
+                $m->setAttribute('class', $class);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Remove the named class from any element in the DOMQuery that has it.
+     *
+     * This may result in the entire class attribute being removed. If there
+     * are other items in the class attribute, though, they will not be removed.
+     *
+     * Example:
+     * Consider this XML:
+     *
+     * @code
+     * <element class="first second"/>
+     * @endcode
+     *
+     * Executing this fragment of code will remove only the 'first' class:
+     * @code
+     * qp(document, 'element')->removeClass('first');
+     * @endcode
+     *
+     * The resulting XML will be:
+     * @code
+     * <element class="second"/>
+     * @endcode
+     *
+     * To remove the entire 'class' attribute, you should use {@see removeAttr()}.
+     *
+     * @param string $class
+     *  The class name to remove.
+     *
+     * @return DOMQuery
+     *  The modified DOMNode object.
+     * @see attr()
+     * @see addClass()
+     * @see hasClass()
+     */
+    public function removeClass($class = false): Query
+    {
+        if (empty($class)) {
+            foreach ($this->matches as $m) {
+                $m->removeAttribute('class');
+            }
+        } else {
+            $to_remove = array_filter(explode(' ', $class));
+            foreach ($this->matches as $m) {
+                if ($m->hasAttribute('class')) {
+                    $vals = array_filter(explode(' ', $m->getAttribute('class')));
+                    $buf  = [];
+                    foreach ($vals as $v) {
+                        if (! in_array($v, $to_remove)) {
+                            $buf[] = $v;
+                        }
+                    }
+                    if (empty($buf)) {
+                        $m->removeAttribute('class');
+                    } else {
+                        $m->setAttribute('class', implode(' ', $buf));
+                    }
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Detach any items from the list if they match the selector.
+     *
+     * In other words, each item that matches the selector will be removed
+     * from the DOM document. The returned DOMQuery wraps the list of
+     * removed elements.
+     *
+     * If no selector is specified, this will remove all current matches from
+     * the document.
+     *
+     * @param string $selector
+     *  A CSS Selector.
+     *
+     * @return DOMQuery
+     *  The Query path wrapping a list of removed items.
+     * @throws ParseException
+     * @see    replaceWith()
+     * @see    removeChildren()
+     * @since  2.1
+     * @author eabrand
+     * @see    replaceAll()
+     */
+    public function detach($selector = null): Query
+    {
+        if (null !== $selector) {
+            $this->find($selector);
+        }
+
+        $found      = new SplObjectStorage();
+        $this->last = $this->matches;
+        foreach ($this->matches as $item) {
+            // The item returned is (according to docs) different from
+            // the one passed in, so we have to re-store it.
+            $found->attach($item->parentNode->removeChild($item));
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Attach any items from the list if they match the selector.
+     *
+     * If no selector is specified, this will remove all current matches from
+     * the document.
+     *
+     * @param DOMQuery $dest
+     *  A DOMQuery Selector.
+     *
+     * @return DOMQuery
+     *  The Query path wrapping a list of removed items.
+     * @throws QueryPath
+     * @throws Exception
+     * @see    removeChildren()
+     * @since  2.1
+     * @author eabrand
+     * @see    replaceAll()
+     * @see    replaceWith()
+     */
+    public function attach(DOMQuery $dest): Query
+    {
+        foreach ($this->last as $m) {
+            $dest->append($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Append the current elements to the destination passed into the function.
+     *
+     * This cycles through all of the current matches and appends them to
+     * the context given in $destination. If a selector is provided then the
+     * $destination is queried (using that selector) prior to the data being
+     * appended. The data is then appended to the found items.
+     *
+     * @param DOMQuery $dest
+     *  A DOMQuery object that will be appended to.
+     *
+     * @return DOMQuery
+     *  The original DOMQuery, unaltered. Only the destination DOMQuery will
+     *  be modified.
+     * @throws QueryPath::Exception
+     *  Thrown if $data is an unsupported object type.
+     * @throws Exception
+     * @see append()
+     * @see prependTo()
+     */
+    public function appendTo(DOMQuery $dest): Query
+    {
+        foreach ($this->matches as $m) {
+            $dest->append($m);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Remove any items from the list if they match the selector.
+     *
+     * In other words, each item that matches the selector will be remove
+     * from the DOM document. The returned DOMQuery wraps the list of
+     * removed elements.
+     *
+     * If no selector is specified, this will remove all current matches from
+     * the document.
+     *
+     * @param string $selector
+     *  A CSS Selector.
+     *
+     * @return DOMQuery
+     *  The Query path wrapping a list of removed items.
+     * @throws ParseException
+     * @see replaceWith()
+     * @see removeChildren()
+     * @see replaceAll()
+     */
+    public function remove($selector = null): Query
+    {
+        if (! empty($selector)) {
+            // Do a non-destructive find.
+            $query = new QueryPathEventHandler($this->matches);
+            $query->find($selector);
+            $matches = $query->getMatches();
+        } else {
+            $matches = $this->matches;
+        }
+
+        $found = new SplObjectStorage();
+        foreach ($matches as $item) {
+            // The item returned is (according to docs) different from
+            // the one passed in, so we have to re-store it.
+            $found->attach($item->parentNode->removeChild($item));
+        }
+
+        // Return a clone DOMQuery with just the removed items. If
+        // no items are found, this will return an empty DOMQuery.
+        return count($found) === 0 ? new static() : new static($found);
+    }
+
+    /**
+     * This replaces everything that matches the selector with the first value
+     * in the current list.
+     *
+     * This is the reverse of replaceWith.
+     *
+     * Unlike jQuery, DOMQuery cannot assume a default document. Consequently,
+     * you must specify the intended destination document. If it is omitted, the
+     * present document is assumed to be tthe document. However, that can result
+     * in undefined behavior if the selector and the replacement are not sufficiently
+     * distinct.
+     *
+     * @param string       $selector
+     *  The selector.
+     * @param DOMDocument $document
+     *  The destination document.
+     *
+     * @return DOMQuery
+     *  The DOMQuery wrapping the modified document.
+     * @throws ParseException
+     * @see        remove()
+     * @see        replaceWith()
+     * @deprecated Due to the fact that this is not a particularly friendly method,
+     *             and that it can be easily replicated using {@see replaceWith()}, it is to be
+     *             considered deprecated.
+     */
+    public function replaceAll($selector, DOMDocument $document): Query
+    {
+        $replacement = $this->matches->count() > 0 ? $this->getFirstMatch() : $this->document->createTextNode('');
+
+        $c = new QueryPathEventHandler($document);
+        $c->find($selector);
+        $temp = $c->getMatches();
+        foreach ($temp as $item) {
+            $node = $replacement->cloneNode();
+            $node = $document->importNode($node);
+            $item->parentNode->replaceChild($node, $item);
+        }
+
+        return QueryPath::with($document, null, $this->options);
+    }
+
+    /**
+     * Add more elements to the current set of matches.
+     *
+     * This begins the new query at the top of the DOM again. The results found
+     * when running this selector are then merged into the existing results. In
+     * this way, you can add additional elements to the existing set.
+     *
+     * @param string $selector
+     *  A valid selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the newly added elements.
+     * @see append()
+     * @see after()
+     * @see andSelf()
+     * @see end()
+     */
+    public function add($selector): Query
+    {
+
+        // This is destructive, so we need to set $last:
+        $this->last = $this->matches;
+
+        foreach (QueryPath::with($this->document, $selector, $this->options)->get() as $item) {
+            $this->matches->attach($item);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Remove all child nodes.
+     *
+     * This is equivalent to jQuery's empty() function. (However, empty() is a
+     * PHP built-in, and cannot be used as a method name.)
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the child nodes removed.
+     * @see replaceWith()
+     * @see replaceAll()
+     * @see remove()
+     */
+    public function removeChildren(): Query
+    {
+        foreach ($this->matches as $m) {
+            while ($kid = $m->firstChild) {
+                $m->removeChild($kid);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get/set an attribute.
+     * - If no parameters are specified, this returns an associative array of all
+     *   name/value pairs.
+     * - If both $name and $value are set, then this will set the attribute name/value
+     *   pair for all items in this object.
+     * - If $name is set, and is an array, then
+     *   all attributes in the array will be set for all items in this object.
+     * - If $name is a string and is set, then the attribute value will be returned.
+     *
+     * When an attribute value is retrieved, only the attribute value of the FIRST
+     * match is returned.
+     *
+     * @param mixed  $name
+     *   The name of the attribute or an associative array of name/value pairs.
+     * @param string $value
+     *   A value (used only when setting an individual property).
+     *
+     * @return mixed
+     *   If this was a setter request, return the DOMQuery object. If this was
+     *   an access request (getter), return the string value.
+     * @see removeAttr()
+     * @see tag()
+     * @see hasAttr()
+     * @see hasClass()
+     */
+    public function attr($name = null, $value = null)
+    {
+        // Default case: Return all attributes as an assoc array.
+        if (is_null($name)) {
+            if ($this->matches->count() === 0) {
+                return null;
+            }
+            $ele    = $this->getFirstMatch();
+            $buffer = [];
+
+            // This does not appear to be part of the DOM
+            // spec. Nor is it documented. But it works.
+            foreach ($ele->attributes as $name => $attrNode) {
+                $buffer[$name] = $attrNode->value;
+            }
+
+            return $buffer;
+        }
+
+        // multi-setter
+        if (is_array($name)) {
+            foreach ($name as $k => $v) {
+                foreach ($this->matches as $m) {
+                    $m->setAttribute($k, $v);
+                }
+            }
+
+            return $this;
+        }
+        // setter
+        if (isset($value)) {
+            foreach ($this->matches as $m) {
+                $m->setAttribute($name, $value);
+            }
+
+            return $this;
+        }
+
+        //getter
+        if ($this->matches->count() === 0) {
+            return null;
+        }
+
+        // Special node type handler:
+        if ($name === 'nodeType') {
+            return $this->getFirstMatch()->nodeType;
+        }
+
+        // Always return first match's attr.
+        return $this->getFirstMatch()->getAttribute($name);
+    }
+
+    /**
+     * Set/get a CSS value for the current element(s).
+     * This sets the CSS value for each element in the DOMQuery object.
+     * It does this by setting (or getting) the style attribute (without a namespace).
+     *
+     * For example, consider this code:
+     *
+     * @code
+     * <?php
+     * qp(HTML_STUB, 'body')->css('background-color','red')->html();
+     * ?>
+     * @endcode
+     * This will return the following HTML:
+     * @code
+     * <body style="background-color: red"/>
+     * @endcode
+     *
+     * If no parameters are passed into this function, then the current style
+     * element will be returned unparsed. Example:
+     * @code
+     * <?php
+     * qp(HTML_STUB, 'body')->css('background-color','red')->css();
+     * ?>
+     * @endcode
+     * This will return the following:
+     * @code
+     * background-color: red
+     * @endcode
+     *
+     * As of QueryPath 2.1, existing style attributes will be merged with new attributes.
+     * (In previous versions of QueryPath, a call to css() overwrite the existing style
+     * values).
+     *
+     * @param mixed  $name
+     *  If this is a string, it will be used as a CSS name. If it is an array,
+     *  this will assume it is an array of name/value pairs of CSS rules. It will
+     *  apply all rules to all elements in the set.
+     * @param string $value
+     *  The value to set. This is only set if $name is a string.
+     *
+     * @return DOMQuery
+     */
+    public function css($name = null, $value = '')
+    {
+        if (empty($name)) {
+            return $this->attr('style');
+        }
+
+        // Get any existing CSS.
+        $css = [];
+        foreach ($this->matches as $match) {
+            $style = $match->getAttribute('style');
+            if (! empty($style)) {
+                // XXX: Is this sufficient?
+                $style_array = explode(';', $style);
+                foreach ($style_array as $item) {
+                    $item = trim($item);
+
+                    // Skip empty attributes.
+                    if ($item === '') {
+                        continue;
+                    }
+
+                    [$css_att, $css_val] = explode(':', $item, 2);
+                    $css[$css_att] = trim($css_val);
+                }
+            }
+        }
+
+        if (is_array($name)) {
+            // Use array_merge instead of + to preserve order.
+            $css = array_merge($css, $name);
+        } else {
+            $css[$name] = $value;
+        }
+
+        // Collapse CSS into a string.
+        $format     = '%s: %s;';
+        $css_string = '';
+        foreach ($css as $n => $v) {
+            $css_string .= sprintf($format, $n, trim($v));
+        }
+
+        $this->attr('style', $css_string);
+
+        return $this;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -661,7 +661,7 @@ 
 					$vals = array_filter(explode(' ', $m->getAttribute('class')));
 					$buf  = [];
 					foreach ($vals as $v) {
-						if (! in_array($v, $to_remove)) {
+						if (!in_array($v, $to_remove)) {
 							$buf[] = $v;
 						}
 					}
@@ -795,7 +795,7 @@ 
 	 */
 	public function remove($selector = null): Query
 	{
-		if (! empty($selector)) {
+		if (!empty($selector)) {
 			// Do a non-destructive find.
 			$query = new QueryPathEventHandler($this->matches);
 			$query->find($selector);
@@ -1041,7 +1041,7 @@ 
 		$css = [];
 		foreach ($this->matches as $match) {
 			$style = $match->getAttribute('style');
-			if (! empty($style)) {
+			if (!empty($style)) {
 				// XXX: Is this sufficient?
 				$style_array = explode(';', $style);
 				foreach ($style_array as $item) {

src/Helpers/QueryChecks.php

Indentation +174 added lines, -174 removed lines

@@ -20,182 +20,182 @@
 trait QueryChecks
 {
 
-	/**
-	 * Given a selector, this checks to see if the current set has one or more matches.
-	 *
-	 * Unlike jQuery's version, this supports full selectors (not just simple ones).
-	 *
-	 * @param string|DOMNode $selector
-	 *   The selector to search for. As of QueryPath 2.1.1, this also supports passing a
-	 *   DOMNode object.
-	 *
-	 * @return boolean
-	 *   TRUE if one or more elements match. FALSE if no match is found.
-	 * @throws Exception
-	 * @throws Exception
-	 * @see get()
-	 * @see eq()
-	 */
-	public function is($selector): bool
-	{
-		if (is_object($selector)) {
-			if ($selector instanceof DOMNode) {
-				return count($this->matches) === 1 && $selector->isSameNode($this->get(0));
-			}
-
-			if ($selector instanceof Traversable) {
-				if (count($selector) !== count($this->matches)) {
-					return false;
-				}
-				// Without $seen, there is an edge case here if $selector contains the same object
-				// more than once, but the counts are equal. For example, [a, a, a, a] will
-				// pass an is() on [a, b, c, d]. We use the $seen SPLOS to prevent this.
-				$seen = new SplObjectStorage();
-				foreach ($selector as $item) {
-					if (! $this->matches->contains($item) || $seen->contains($item)) {
-						return false;
-					}
-					$seen->attach($item);
-				}
-
-				return true;
-			}
-			throw new Exception('Cannot compare an object to a DOMQuery.');
-		}
-
-		return $this->branch($selector)->count() > 0;
-	}
-
-	/**
-	 * Reduce the elements matched by DOMQuery to only those which contain the given item.
-	 *
-	 * There are two ways in which this is different from jQuery's implementation:
-	 * - We allow ANY DOMNode, not just DOMElements. That means this will work on
-	 *   processor instructions, text nodes, comments, etc.
-	 * - Unlike jQuery, this implementation of has() follows QueryPath standard behavior
-	 *   and modifies the existing object. It does not create a brand new object.
-	 *
-	 * @param mixed $contained
-	 *     - If $contained is a CSS selector (e.g. '#foo'), this will test to see
-	 *     if the current DOMQuery has any elements that contain items that match
-	 *     the selector.
-	 *     - If $contained is a DOMNode, then this will test to see if THE EXACT DOMNode
-	 *     exists in the currently matched elements. (Note that you cannot match across DOM trees, even if it is the
-	 *     same document.)
-	 *
-	 * @return DOMQuery
-	 * @throws ParseException
-	 * @todo   It would be trivially easy to add support for iterating over an array or Iterable of DOMNodes.
-	 * @since  2.1
-	 * @author eabrand
-	 */
-	public function has($contained): Query
-	{
-		/*
+    /**
+     * Given a selector, this checks to see if the current set has one or more matches.
+     *
+     * Unlike jQuery's version, this supports full selectors (not just simple ones).
+     *
+     * @param string|DOMNode $selector
+     *   The selector to search for. As of QueryPath 2.1.1, this also supports passing a
+     *   DOMNode object.
+     *
+     * @return boolean
+     *   TRUE if one or more elements match. FALSE if no match is found.
+     * @throws Exception
+     * @throws Exception
+     * @see get()
+     * @see eq()
+     */
+    public function is($selector): bool
+    {
+        if (is_object($selector)) {
+            if ($selector instanceof DOMNode) {
+                return count($this->matches) === 1 && $selector->isSameNode($this->get(0));
+            }
+
+            if ($selector instanceof Traversable) {
+                if (count($selector) !== count($this->matches)) {
+                    return false;
+                }
+                // Without $seen, there is an edge case here if $selector contains the same object
+                // more than once, but the counts are equal. For example, [a, a, a, a] will
+                // pass an is() on [a, b, c, d]. We use the $seen SPLOS to prevent this.
+                $seen = new SplObjectStorage();
+                foreach ($selector as $item) {
+                    if (! $this->matches->contains($item) || $seen->contains($item)) {
+                        return false;
+                    }
+                    $seen->attach($item);
+                }
+
+                return true;
+            }
+            throw new Exception('Cannot compare an object to a DOMQuery.');
+        }
+
+        return $this->branch($selector)->count() > 0;
+    }
+
+    /**
+     * Reduce the elements matched by DOMQuery to only those which contain the given item.
+     *
+     * There are two ways in which this is different from jQuery's implementation:
+     * - We allow ANY DOMNode, not just DOMElements. That means this will work on
+     *   processor instructions, text nodes, comments, etc.
+     * - Unlike jQuery, this implementation of has() follows QueryPath standard behavior
+     *   and modifies the existing object. It does not create a brand new object.
+     *
+     * @param mixed $contained
+     *     - If $contained is a CSS selector (e.g. '#foo'), this will test to see
+     *     if the current DOMQuery has any elements that contain items that match
+     *     the selector.
+     *     - If $contained is a DOMNode, then this will test to see if THE EXACT DOMNode
+     *     exists in the currently matched elements. (Note that you cannot match across DOM trees, even if it is the
+     *     same document.)
+     *
+     * @return DOMQuery
+     * @throws ParseException
+     * @todo   It would be trivially easy to add support for iterating over an array or Iterable of DOMNodes.
+     * @since  2.1
+     * @author eabrand
+     */
+    public function has($contained): Query
+    {
+        /*
 		if (count($this->matches) == 0) {
 		return false;
 		}
 		*/
-		$found = new SplObjectStorage();
-
-		// If it's a selector, we just get all of the DOMNodes that match the selector.
-		$nodes = [];
-		if (is_string($contained)) {
-			// Get the list of nodes.
-			$nodes = $this->branch($contained)->get();
-		} elseif ($contained instanceof DOMNode) {
-			// Make a list with one node.
-			$nodes = [$contained];
-		}
-
-		// Now we go through each of the nodes that we are testing. We want to find
-		// ALL PARENTS that are in our existing DOMQuery matches. Those are the
-		// ones we add to our new matches.
-		foreach ($nodes as $original_node) {
-			$node = $original_node;
-			while (! empty($node)/* && $node != $node->ownerDocument*/) {
-				if ($this->matches->contains($node)) {
-					$found->attach($node);
-				}
-				$node = $node->parentNode;
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Returns TRUE if any of the elements in the DOMQuery have the specified class.
-	 *
-	 * @param string $class
-	 *  The name of the class.
-	 *
-	 * @return boolean
-	 *  TRUE if the class exists in one or more of the elements, FALSE otherwise.
-	 * @see addClass()
-	 * @see removeClass()
-	 */
-	public function hasClass($class): bool
-	{
-		foreach ($this->matches as $m) {
-			if ($m->hasAttribute('class')) {
-				$vals = explode(' ', $m->getAttribute('class'));
-				if (in_array($class, $vals)) {
-					return true;
-				}
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Check to see if the given attribute is present.
-	 *
-	 * This returns TRUE if <em>all</em> selected items have the attribute, or
-	 * FALSE if at least one item does not have the attribute.
-	 *
-	 * @param string $attrName
-	 *  The attribute name.
-	 *
-	 * @return boolean
-	 *  TRUE if all matches have the attribute, FALSE otherwise.
-	 * @since 2.0
-	 * @see   attr()
-	 * @see   hasClass()
-	 */
-	public function hasAttr($attrName): bool
-	{
-		foreach ($this->matches as $match) {
-			if (! $match->hasAttribute($attrName)) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Remove the named attribute from all elements in the current DOMQuery.
-	 *
-	 * This will remove any attribute with the given name. It will do this on each
-	 * item currently wrapped by DOMQuery.
-	 *
-	 * As is the case in jQuery, this operation is not considered destructive.
-	 *
-	 * @param string $name
-	 *  Name of the parameter to remove.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with the same elements.
-	 * @see attr()
-	 */
-	public function removeAttr($name): Query
-	{
-		foreach ($this->matches as $m) {
-			$m->removeAttribute($name);
-		}
-
-		return $this;
-	}
+        $found = new SplObjectStorage();
+
+        // If it's a selector, we just get all of the DOMNodes that match the selector.
+        $nodes = [];
+        if (is_string($contained)) {
+            // Get the list of nodes.
+            $nodes = $this->branch($contained)->get();
+        } elseif ($contained instanceof DOMNode) {
+            // Make a list with one node.
+            $nodes = [$contained];
+        }
+
+        // Now we go through each of the nodes that we are testing. We want to find
+        // ALL PARENTS that are in our existing DOMQuery matches. Those are the
+        // ones we add to our new matches.
+        foreach ($nodes as $original_node) {
+            $node = $original_node;
+            while (! empty($node)/* && $node != $node->ownerDocument*/) {
+                if ($this->matches->contains($node)) {
+                    $found->attach($node);
+                }
+                $node = $node->parentNode;
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Returns TRUE if any of the elements in the DOMQuery have the specified class.
+     *
+     * @param string $class
+     *  The name of the class.
+     *
+     * @return boolean
+     *  TRUE if the class exists in one or more of the elements, FALSE otherwise.
+     * @see addClass()
+     * @see removeClass()
+     */
+    public function hasClass($class): bool
+    {
+        foreach ($this->matches as $m) {
+            if ($m->hasAttribute('class')) {
+                $vals = explode(' ', $m->getAttribute('class'));
+                if (in_array($class, $vals)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check to see if the given attribute is present.
+     *
+     * This returns TRUE if <em>all</em> selected items have the attribute, or
+     * FALSE if at least one item does not have the attribute.
+     *
+     * @param string $attrName
+     *  The attribute name.
+     *
+     * @return boolean
+     *  TRUE if all matches have the attribute, FALSE otherwise.
+     * @since 2.0
+     * @see   attr()
+     * @see   hasClass()
+     */
+    public function hasAttr($attrName): bool
+    {
+        foreach ($this->matches as $match) {
+            if (! $match->hasAttribute($attrName)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Remove the named attribute from all elements in the current DOMQuery.
+     *
+     * This will remove any attribute with the given name. It will do this on each
+     * item currently wrapped by DOMQuery.
+     *
+     * As is the case in jQuery, this operation is not considered destructive.
+     *
+     * @param string $name
+     *  Name of the parameter to remove.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with the same elements.
+     * @see attr()
+     */
+    public function removeAttr($name): Query
+    {
+        foreach ($this->matches as $m) {
+            $m->removeAttribute($name);
+        }
+
+        return $this;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -52,7 +52,7 @@ 
 				// pass an is() on [a, b, c, d]. We use the $seen SPLOS to prevent this.
 				$seen = new SplObjectStorage();
 				foreach ($selector as $item) {
-					if (! $this->matches->contains($item) || $seen->contains($item)) {
+					if (!$this->matches->contains($item) || $seen->contains($item)) {
 						return false;
 					}
 					$seen->attach($item);
@@ -113,7 +113,7 @@ 
 		// ones we add to our new matches.
 		foreach ($nodes as $original_node) {
 			$node = $original_node;
-			while (! empty($node)/* && $node != $node->ownerDocument*/) {
+			while (!empty($node)/* && $node != $node->ownerDocument*/) {
 				if ($this->matches->contains($node)) {
 					$found->attach($node);
 				}
@@ -167,7 +167,7 @@ 
 	public function hasAttr($attrName): bool
 	{
 		foreach ($this->matches as $match) {
-			if (! $match->hasAttribute($attrName)) {
+			if (!$match->hasAttribute($attrName)) {
 				return false;
 			}
 		}

src/Helpers/QueryFilters.php

Indentation +1124 added lines, -1124 removed lines

@@ -22,1128 +22,1128 @@
 trait QueryFilters
 {
 
-	/**
-	 * Filter a list down to only elements that match the selector.
-	 * Use this, for example, to find all elements with a class, or with
-	 * certain children.
-	 *
-	 * @param string $selector
-	 *   The selector to use as a filter.
-	 *
-	 * @return Query The DOMQuery with non-matching items filtered out.*   The DOMQuery with non-matching items
-	 *               filtered out.
-	 * @throws ParseException
-	 * @see filterCallback()
-	 * @see map()
-	 * @see find()
-	 * @see is()
-	 * @see filterLambda()
-	 */
-	public function filter($selector): Query
-	{
-		$found = new SplObjectStorage();
-		$tmp   = new SplObjectStorage();
-
-		foreach ($this->matches as $m) {
-			$tmp->attach($m);
-			// Seems like this should be right... but it fails unit
-			// tests. Need to compare to jQuery.
-			// $query = new \QueryPath\CSS\DOMTraverser($tmp, TRUE, $m);
-			$query = new DOMTraverser($tmp);
-			$query->find($selector);
-			if (count($query->matches())) {
-				$found->attach($m);
-			}
-			$tmp->detach($m);
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Filter based on a lambda function.
-	 *
-	 * The function string will be executed as if it were the body of a
-	 * function. It is passed two arguments:
-	 * - $index: The index of the item.
-	 * - $item: The current Element.
-	 * If the function returns boolean FALSE, the item will be removed from
-	 * the list of elements. Otherwise it will be kept.
-	 *
-	 * Example:
-	 *
-	 * @code
-	 * qp('li')->filterLambda('qp($item)->attr("id") == "test"');
-	 * @endcode
-	 *
-	 * The above would filter down the list to only an item whose ID is
-	 * 'text'.
-	 *
-	 * @param string $fn
-	 *  Inline lambda function in a string.
-	 *
-	 * @return DOMQuery
-	 * @throws ParseException
-	 *
-	 * @see map()
-	 * @see mapLambda()
-	 * @see filterCallback()
-	 * @see filter()
-	 * @deprecated
-	 *   Since PHP 5.3 supports anonymous functions -- REAL Lambdas -- this
-	 *   method is not necessary and should be avoided.
-	 */
-	public function filterLambda($fn): Query
-	{
-		$function = create_function('$index, $item', $fn);
-		$found    = new SplObjectStorage();
-		$i        = 0;
-		foreach ($this->matches as $item) {
-			if ($function($i++, $item) !== false) {
-				$found->attach($item);
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Use regular expressions to filter based on the text content of matched elements.
-	 *
-	 * Only items that match the given regular expression will be kept. All others will
-	 * be removed.
-	 *
-	 * The regular expression is run against the <i>text content</i> (the PCDATA) of the
-	 * elements. This is a way of filtering elements based on their content.
-	 *
-	 * Example:
-	 *
-	 * @code
-	 *  <?xml version="1.0"?>
-	 *  <div>Hello <i>World</i></div>
-	 * @endcode
-	 *
-	 * @code
-	 *  <?php
-	 *    // This will be 1.
-	 *    qp($xml, 'div')->filterPreg('/World/')->matches->count();
-	 *  ?>
-	 * @endcode
-	 *
-	 * The return value above will be 1 because the text content of @codeqp($xml, 'div')@endcode is
-	 * @codeHello World@endcode.
-	 *
-	 * Compare this to the behavior of the <em>:contains()</em> CSS3 pseudo-class.
-	 *
-	 * @param string $regex
-	 *  A regular expression.
-	 *
-	 * @return DOMQuery
-	 * @throws ParseException
-	 * @see       filterCallback()
-	 * @see       preg_match()
-	 * @see       filter()
-	 */
-	public function filterPreg($regex): Query
-	{
-		$found = new SplObjectStorage();
-
-		foreach ($this->matches as $item) {
-			if (preg_match($regex, $item->textContent) > 0) {
-				$found->attach($item);
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Filter based on a callback function.
-	 *
-	 * A callback may be any of the following:
-	 *  - a function: 'my_func'.
-	 *  - an object/method combo: $obj, 'myMethod'
-	 *  - a class/method combo: 'MyClass', 'myMethod'
-	 * Note that classes are passed in strings. Objects are not.
-	 *
-	 * Each callback is passed to arguments:
-	 *  - $index: The index position of the object in the array.
-	 *  - $item: The item to be operated upon.
-	 *
-	 * If the callback function returns FALSE, the item will be removed from the
-	 * set of matches. Otherwise the item will be considered a match and left alone.
-	 *
-	 * @param callback $callback .
-	 *                           A callback either as a string (function) or an array (object, method OR
-	 *                           classname, method).
-	 *
-	 * @return DOMQuery
-	 *                           Query path object augmented according to the function.
-	 * @throws ParseException
-	 * @throws Exception
-	 * @see map()
-	 * @see is()
-	 * @see find()
-	 * @see filter()
-	 * @see filterLambda()
-	 */
-	public function filterCallback($callback): Query
-	{
-		$found = new SplObjectStorage();
-		$i     = 0;
-		if (is_callable($callback)) {
-			foreach ($this->matches as $item) {
-				if ($callback($i++, $item) !== false) {
-					$found->attach($item);
-				}
-			}
-		} else {
-			throw new Exception('The specified callback is not callable.');
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Run a function on each item in a set.
-	 *
-	 * The mapping callback can return anything. Whatever it returns will be
-	 * stored as a match in the set, though. This means that afer a map call,
-	 * there is no guarantee that the elements in the set will behave correctly
-	 * with other DOMQuery functions.
-	 *
-	 * Callback rules:
-	 * - If the callback returns NULL, the item will be removed from the array.
-	 * - If the callback returns an array, the entire array will be stored in
-	 *   the results.
-	 * - If the callback returns anything else, it will be appended to the array
-	 *   of matches.
-	 *
-	 * @param callback $callback
-	 *  The function or callback to use. The callback will be passed two params:
-	 *  - $index: The index position in the list of items wrapped by this object.
-	 *  - $item: The current item.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object wrapping a list of whatever values were returned
-	 *  by each run of the callback.
-	 *
-	 * @throws Exception
-	 * @throws ParseException
-	 * @see find()
-	 * @see DOMQuery::get()
-	 * @see filter()
-	 */
-	public function map($callback): Query
-	{
-		$found = new SplObjectStorage();
-
-		if (is_callable($callback)) {
-			$i = 0;
-			foreach ($this->matches as $item) {
-				$c = call_user_func($callback, $i, $item);
-				if (isset($c)) {
-					if (is_array($c) || $c instanceof Iterable) {
-						foreach ($c as $retval) {
-							if (! is_object($retval)) {
-								$tmp              = new stdClass();
-								$tmp->textContent = $retval;
-								$retval           = $tmp;
-							}
-							$found->attach($retval);
-						}
-					} else {
-						if (! is_object($c)) {
-							$tmp              = new stdClass();
-							$tmp->textContent = $c;
-							$c                = $tmp;
-						}
-						$found->attach($c);
-					}
-				}
-				++$i;
-			}
-		} else {
-			throw new Exception('Callback is not callable.');
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Narrow the items in this object down to only a slice of the starting items.
-	 *
-	 * @param integer $start
-	 *  Where in the list of matches to begin the slice.
-	 * @param integer $length
-	 *  The number of items to include in the slice. If nothing is specified, the
-	 *  all remaining matches (from $start onward) will be included in the sliced
-	 *  list.
-	 *
-	 * @return DOMQuery
-	 * @throws ParseException
-	 * @see array_slice()
-	 */
-	public function slice($start, $length = 0): Query
-	{
-		$end   = $length;
-		$found = new SplObjectStorage();
-		if ($start >= $this->count()) {
-			return $this->inst($found, null);
-		}
-
-		$i = $j = 0;
-		foreach ($this->matches as $m) {
-			if ($i >= $start) {
-				if ($end > 0 && $j >= $end) {
-					break;
-				}
-				$found->attach($m);
-				++$j;
-			}
-			++$i;
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Run a callback on each item in the list of items.
-	 *
-	 * Rules of the callback:
-	 * - A callback is passed two variables: $index and $item. (There is no
-	 *   special treatment of $this, as there is in jQuery.)
-	 *   - You will want to pass $item by reference if it is not an
-	 *     object (DOMNodes are all objects).
-	 * - A callback that returns FALSE will stop execution of the each() loop. This
-	 *   works like break in a standard loop.
-	 * - A TRUE return value from the callback is analogous to a continue statement.
-	 * - All other return values are ignored.
-	 *
-	 * @param callback $callback
-	 *  The callback to run.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery.
-	 * @throws Exception
-	 * @see filter()
-	 * @see map()
-	 * @see eachLambda()
-	 */
-	public function each($callback): Query
-	{
-		if (is_callable($callback)) {
-			$i = 0;
-			foreach ($this->matches as $item) {
-				if (call_user_func($callback, $i, $item) === false) {
-					return $this;
-				}
-				++$i;
-			}
-		} else {
-			throw new Exception('Callback is not callable.');
-		}
-
-		return $this;
-	}
-
-	/**
-	 * An each() iterator that takes a lambda function.
-	 *
-	 * @param string $lambda
-	 *  The lambda function. This will be passed ($index, &$item).
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object.
-	 * @deprecated
-	 *   Since PHP 5.3 supports anonymous functions -- REAL Lambdas -- this
-	 *   method is not necessary and should be avoided.
-	 * @see each()
-	 * @see filterLambda()
-	 * @see filterCallback()
-	 * @see map()
-	 */
-	public function eachLambda($lambda): Query
-	{
-		$index = 0;
-		foreach ($this->matches as $item) {
-			$fn = create_function('$index, &$item', $lambda);
-			if ($fn($index, $item) === false) {
-				return $this;
-			}
-			++$index;
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Get the even elements, so counter-intuitively 1, 3, 5, etc.
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    parent()
-	 * @see    parents()
-	 * @see    next()
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    removeChildren()
-	 */
-	public function even(): Query
-	{
-		$found = new SplObjectStorage();
-		$even  = false;
-		foreach ($this->matches as $m) {
-			if ($even && $m->nodeType === XML_ELEMENT_NODE) {
-				$found->attach($m);
-			}
-			$even = $even ? false : true;
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the odd elements, so counter-intuitively 0, 2, 4, etc.
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    parent()
-	 * @see    parents()
-	 * @see    next()
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    removeChildren()
-	 */
-	public function odd(): Query
-	{
-		$found = new SplObjectStorage();
-		$odd   = true;
-		foreach ($this->matches as $m) {
-			if ($odd && $m->nodeType === XML_ELEMENT_NODE) {
-				$found->attach($m);
-			}
-			$odd = $odd ? false : true;
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the first matching element.
-	 *
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    next()
-	 */
-	public function first(): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			if ($m->nodeType === XML_ELEMENT_NODE) {
-				$found->attach($m);
-				break;
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the first child of the matching element.
-	 *
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    next()
-	 */
-	public function firstChild(): Query
-	{
-		// Could possibly use $m->firstChild http://theserverpages.com/php/manual/en/ref.dom.php
-		$found = new SplObjectStorage();
-		$flag  = false;
-		foreach ($this->matches as $m) {
-			foreach ($m->childNodes as $c) {
-				if ($c->nodeType === XML_ELEMENT_NODE) {
-					$found->attach($c);
-					$flag = true;
-					break;
-				}
-			}
-			if ($flag) {
-				break;
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the last matching element.
-	 *
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    next()
-	 */
-	public function last(): Query
-	{
-		$found = new SplObjectStorage();
-		$item  = null;
-		foreach ($this->matches as $m) {
-			if ($m->nodeType === XML_ELEMENT_NODE) {
-				$item = $m;
-			}
-		}
-		if ($item) {
-			$found->attach($item);
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the last child of the matching element.
-	 *
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see    prev()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    next()
-	 */
-	public function lastChild(): Query
-	{
-		$found = new SplObjectStorage();
-		$item  = null;
-		foreach ($this->matches as $m) {
-			foreach ($m->childNodes as $c) {
-				if ($c->nodeType === XML_ELEMENT_NODE) {
-					$item = $c;
-				}
-			}
-			if ($item) {
-				$found->attach($item);
-				$item = null;
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get all siblings after an element until the selector is reached.
-	 *
-	 * For each element in the DOMQuery, get all siblings that appear after
-	 * it. If a selector is passed in, then only siblings that match the
-	 * selector will be included.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object, now containing the matching siblings.
-	 * @throws Exception
-	 * @see    prevAll()
-	 * @see    children()
-	 * @see    siblings()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    next()
-	 */
-	public function nextUntil($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->nextSibling)) {
-				$m = $m->nextSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (null !== $selector && QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-						break;
-					}
-					$found->attach($m);
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the previous siblings for each element in the DOMQuery
-	 * until the selector is reached.
-	 *
-	 * For each element in the DOMQuery, get all previous siblings. If a
-	 * selector is provided, only matching siblings will be retrieved.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object, now wrapping previous sibling elements.
-	 * @throws Exception
-	 * @see    prev()
-	 * @see    nextAll()
-	 * @see    siblings()
-	 * @see    contents()
-	 * @see    children()
-	 * @since  2.1
-	 * @author eabrand
-	 */
-	public function prevUntil($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->previousSibling)) {
-				$m = $m->previousSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (null !== $selector && QueryPath::with($m, null, $this->options)->is($selector)) {
-						break;
-					}
-
-					$found->attach($m);
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get all ancestors of each element in the DOMQuery until the selector is reached.
-	 *
-	 * If a selector is present, only matching ancestors will be retrieved.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 Selector.
-	 *
-	 * @return DOMQuery
-	 *  A DOMNode object containing the matching ancestors.
-	 * @throws Exception
-	 * @see    siblings()
-	 * @see    children()
-	 * @since  2.1
-	 * @author eabrand
-	 * @see    parent()
-	 */
-	public function parentsUntil($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
-				$m = $m->parentNode;
-				// Is there any case where parent node is not an element?
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-							break;
-						}
-						$found->attach($m);
-					} else {
-						$found->attach($m);
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Reduce the matched set to just one.
-	 *
-	 * This will take a matched set and reduce it to just one item -- the item
-	 * at the index specified. This is a destructive operation, and can be undone
-	 * with {@link end()}.
-	 *
-	 * @param $index
-	 *  The index of the element to keep. The rest will be
-	 *  discarded.
-	 *
-	 * @return DOMQuery
-	 * @throws ParseException
-	 * @see is()
-	 * @see end()
-	 * @see get()
-	 */
-	public function eq($index): Query
-	{
-		return $this->inst($this->getNthMatch($index), null);
-	}
-
-	/**
-	 * Filter a list to contain only items that do NOT match.
-	 *
-	 * @param string $selector
-	 *  A selector to use as a negation filter. If the filter is matched, the
-	 *  element will be removed from the list.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object with matching items filtered out.
-	 * @throws ParseException
-	 * @throws Exception
-	 * @see find()
-	 */
-	public function not($selector): Query
-	{
-		$found = new SplObjectStorage();
-		if ($selector instanceof DOMElement) {
-			foreach ($this->matches as $m) {
-				if ($m !== $selector) {
-					$found->attach($m);
-				}
-			}
-		} elseif (is_array($selector)) {
-			foreach ($this->matches as $m) {
-				if (! in_array($m, $selector, true)) {
-					$found->attach($m);
-				}
-			}
-		} elseif ($selector instanceof SplObjectStorage) {
-			foreach ($this->matches as $m) {
-				if ($selector->contains($m)) {
-					$found->attach($m);
-				}
-			}
-		} else {
-			foreach ($this->matches as $m) {
-				if (! QueryPath::with($m, null, $this->options)->is($selector)) {
-					$found->attach($m);
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Find the closest element matching the selector.
-	 *
-	 * This finds the closest match in the ancestry chain. It first checks the
-	 * present element. If the present element does not match, this traverses up
-	 * the ancestry chain (e.g. checks each parent) looking for an item that matches.
-	 *
-	 * It is provided for jQuery 1.3 compatibility.
-	 *
-	 * @param string $selector
-	 *  A CSS Selector to match.
-	 *
-	 * @return DOMQuery
-	 *  The set of matches.
-	 * @throws Exception
-	 * @since 2.0
-	 */
-	public function closest($selector): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-				$found->attach($m);
-			} else {
-				while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
-					$m = $m->parentNode;
-					// Is there any case where parent node is not an element?
-					if ($m->nodeType === XML_ELEMENT_NODE && QueryPath::with(
-						$m,
-						null,
-						$this->options
-					)->is($selector) > 0) {
-						$found->attach($m);
-						break;
-					}
-				}
-			}
-		}
-
-		// XXX: Should this be an in-place modification?
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the immediate parent of each element in the DOMQuery.
-	 *
-	 * If a selector is passed, this will return the nearest matching parent for
-	 * each element in the DOMQuery.
-	 *
-	 * @param string $selector
-	 *  A valid CSS3 selector.
-	 *
-	 * @return DOMQuery
-	 *  A DOMNode object wrapping the matching parents.
-	 * @throws Exception
-	 * @see siblings()
-	 * @see parents()
-	 * @see children()
-	 */
-	public function parent($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
-				$m = $m->parentNode;
-				// Is there any case where parent node is not an element?
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-							$found->attach($m);
-							break;
-						}
-					} else {
-						$found->attach($m);
-						break;
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get all ancestors of each element in the DOMQuery.
-	 *
-	 * If a selector is present, only matching ancestors will be retrieved.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 Selector.
-	 *
-	 * @return DOMQuery
-	 *  A DOMNode object containing the matching ancestors.
-	 * @throws ParseException
-	 * @throws Exception
-	 * @see children()
-	 * @see parent()
-	 * @see siblings()
-	 */
-	public function parents($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
-				$m = $m->parentNode;
-				// Is there any case where parent node is not an element?
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-							$found->attach($m);
-						}
-					} else {
-						$found->attach($m);
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the next sibling of each element in the DOMQuery.
-	 *
-	 * If a selector is provided, the next matching sibling will be returned.
-	 *
-	 * @param string $selector
-	 *  A CSS3 selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object.
-	 * @throws Exception
-	 * @throws ParseException
-	 * @see nextAll()
-	 * @see prev()
-	 * @see children()
-	 * @see contents()
-	 * @see parent()
-	 * @see parents()
-	 */
-	public function next($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->nextSibling)) {
-				$m = $m->nextSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-							$found->attach($m);
-							break;
-						}
-					} else {
-						$found->attach($m);
-						break;
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get all siblings after an element.
-	 *
-	 * For each element in the DOMQuery, get all siblings that appear after
-	 * it. If a selector is passed in, then only siblings that match the
-	 * selector will be included.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object, now containing the matching siblings.
-	 * @throws Exception
-	 * @throws ParseException
-	 * @see next()
-	 * @see prevAll()
-	 * @see children()
-	 * @see siblings()
-	 */
-	public function nextAll($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->nextSibling)) {
-				$m = $m->nextSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
-							$found->attach($m);
-						}
-					} else {
-						$found->attach($m);
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the next sibling before each element in the DOMQuery.
-	 *
-	 * For each element in the DOMQuery, this retrieves the previous sibling
-	 * (if any). If a selector is supplied, it retrieves the first matching
-	 * sibling (if any is found).
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 selector.
-	 *
-	 * @return DOMQuery
-	 *  A DOMNode object, now containing any previous siblings that have been
-	 *  found.
-	 * @throws Exception
-	 * @throws ParseException
-	 * @see prevAll()
-	 * @see next()
-	 * @see siblings()
-	 * @see children()
-	 */
-	public function prev($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->previousSibling)) {
-				$m = $m->previousSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector)) {
-							$found->attach($m);
-							break;
-						}
-					} else {
-						$found->attach($m);
-						break;
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the previous siblings for each element in the DOMQuery.
-	 *
-	 * For each element in the DOMQuery, get all previous siblings. If a
-	 * selector is provided, only matching siblings will be retrieved.
-	 *
-	 * @param string $selector
-	 *  A valid CSS 3 selector.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery object, now wrapping previous sibling elements.
-	 * @throws ParseException
-	 * @throws Exception
-	 * @see siblings()
-	 * @see contents()
-	 * @see children()
-	 * @see prev()
-	 * @see nextAll()
-	 */
-	public function prevAll($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			while (isset($m->previousSibling)) {
-				$m = $m->previousSibling;
-				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
-						if (QueryPath::with($m, null, $this->options)->is($selector)) {
-							$found->attach($m);
-						}
-					} else {
-						$found->attach($m);
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get the children of the elements in the DOMQuery object.
-	 *
-	 * If a selector is provided, the list of children will be filtered through
-	 * the selector.
-	 *
-	 * @param string $selector
-	 *  A valid selector.
-	 *
-	 * @return DOMQuery
-	 *  A DOMQuery wrapping all of the children.
-	 * @throws ParseException
-	 * @see parent()
-	 * @see parents()
-	 * @see next()
-	 * @see prev()
-	 * @see removeChildren()
-	 */
-	public function children($selector = null): Query
-	{
-		$found  = new SplObjectStorage();
-		$filter = is_string($selector) && strlen($selector) > 0;
-
-		if ($filter) {
-			$tmp = new SplObjectStorage();
-		}
-		foreach ($this->matches as $m) {
-			foreach ($m->childNodes as $c) {
-				if ($c->nodeType === XML_ELEMENT_NODE) {
-					// This is basically an optimized filter() just for children().
-					if ($filter) {
-						$tmp->attach($c);
-						$query = new DOMTraverser($tmp, true, $c);
-						$query->find($selector);
-						if (count($query->matches()) > 0) {
-							$found->attach($c);
-						}
-						$tmp->detach($c);
-					} // No filter. Just attach it.
-					else {
-						$found->attach($c);
-					}
-				}
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get all child nodes (not just elements) of all items in the matched set.
-	 *
-	 * It gets only the immediate children, not all nodes in the subtree.
-	 *
-	 * This does not process iframes. Xinclude processing is dependent on the
-	 * DOM implementation and configuration.
-	 *
-	 * @return DOMQuery
-	 *  A DOMNode object wrapping all child nodes for all elements in the
-	 *  DOMNode object.
-	 * @throws ParseException
-	 * @see text()
-	 * @see html()
-	 * @see innerHTML()
-	 * @see xml()
-	 * @see innerXML()
-	 * @see find()
-	 */
-	public function contents(): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			if (empty($m->childNodes)) {
-				continue;
-			}
-			foreach ($m->childNodes as $c) {
-				$found->attach($c);
-			}
-		}
-
-		return $this->inst($found, null);
-	}
-
-	/**
-	 * Get a list of siblings for elements currently wrapped by this object.
-	 *
-	 * This will compile a list of every sibling of every element in the
-	 * current list of elements.
-	 *
-	 * Note that if two siblings are present in the DOMQuery object to begin with,
-	 * then both will be returned in the matched set, since they are siblings of each
-	 * other. In other words,if the matches contain a and b, and a and b are siblings of
-	 * each other, than running siblings will return a set that contains
-	 * both a and b.
-	 *
-	 * @param string $selector
-	 *  If the optional selector is provided, siblings will be filtered through
-	 *  this expression.
-	 *
-	 * @return DOMQuery
-	 *  The DOMQuery containing the matched siblings.
-	 * @throws ParseException
-	 * @throws ParseException
-	 * @see parent()
-	 * @see parents()
-	 * @see contents()
-	 * @see children()
-	 */
-	public function siblings($selector = null): Query
-	{
-		$found = new SplObjectStorage();
-		foreach ($this->matches as $m) {
-			$parent = $m->parentNode;
-			foreach ($parent->childNodes as $n) {
-				if ($n->nodeType === XML_ELEMENT_NODE && $n !== $m) {
-					$found->attach($n);
-				}
-			}
-		}
-		if (empty($selector)) {
-			return $this->inst($found, null);
-		}
-
-		return $this->inst($found, null)->filter($selector);
-	}
+    /**
+     * Filter a list down to only elements that match the selector.
+     * Use this, for example, to find all elements with a class, or with
+     * certain children.
+     *
+     * @param string $selector
+     *   The selector to use as a filter.
+     *
+     * @return Query The DOMQuery with non-matching items filtered out.*   The DOMQuery with non-matching items
+     *               filtered out.
+     * @throws ParseException
+     * @see filterCallback()
+     * @see map()
+     * @see find()
+     * @see is()
+     * @see filterLambda()
+     */
+    public function filter($selector): Query
+    {
+        $found = new SplObjectStorage();
+        $tmp   = new SplObjectStorage();
+
+        foreach ($this->matches as $m) {
+            $tmp->attach($m);
+            // Seems like this should be right... but it fails unit
+            // tests. Need to compare to jQuery.
+            // $query = new \QueryPath\CSS\DOMTraverser($tmp, TRUE, $m);
+            $query = new DOMTraverser($tmp);
+            $query->find($selector);
+            if (count($query->matches())) {
+                $found->attach($m);
+            }
+            $tmp->detach($m);
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Filter based on a lambda function.
+     *
+     * The function string will be executed as if it were the body of a
+     * function. It is passed two arguments:
+     * - $index: The index of the item.
+     * - $item: The current Element.
+     * If the function returns boolean FALSE, the item will be removed from
+     * the list of elements. Otherwise it will be kept.
+     *
+     * Example:
+     *
+     * @code
+     * qp('li')->filterLambda('qp($item)->attr("id") == "test"');
+     * @endcode
+     *
+     * The above would filter down the list to only an item whose ID is
+     * 'text'.
+     *
+     * @param string $fn
+     *  Inline lambda function in a string.
+     *
+     * @return DOMQuery
+     * @throws ParseException
+     *
+     * @see map()
+     * @see mapLambda()
+     * @see filterCallback()
+     * @see filter()
+     * @deprecated
+     *   Since PHP 5.3 supports anonymous functions -- REAL Lambdas -- this
+     *   method is not necessary and should be avoided.
+     */
+    public function filterLambda($fn): Query
+    {
+        $function = create_function('$index, $item', $fn);
+        $found    = new SplObjectStorage();
+        $i        = 0;
+        foreach ($this->matches as $item) {
+            if ($function($i++, $item) !== false) {
+                $found->attach($item);
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Use regular expressions to filter based on the text content of matched elements.
+     *
+     * Only items that match the given regular expression will be kept. All others will
+     * be removed.
+     *
+     * The regular expression is run against the <i>text content</i> (the PCDATA) of the
+     * elements. This is a way of filtering elements based on their content.
+     *
+     * Example:
+     *
+     * @code
+     *  <?xml version="1.0"?>
+     *  <div>Hello <i>World</i></div>
+     * @endcode
+     *
+     * @code
+     *  <?php
+     *    // This will be 1.
+     *    qp($xml, 'div')->filterPreg('/World/')->matches->count();
+     *  ?>
+     * @endcode
+     *
+     * The return value above will be 1 because the text content of @codeqp($xml, 'div')@endcode is
+     * @codeHello World@endcode.
+     *
+     * Compare this to the behavior of the <em>:contains()</em> CSS3 pseudo-class.
+     *
+     * @param string $regex
+     *  A regular expression.
+     *
+     * @return DOMQuery
+     * @throws ParseException
+     * @see       filterCallback()
+     * @see       preg_match()
+     * @see       filter()
+     */
+    public function filterPreg($regex): Query
+    {
+        $found = new SplObjectStorage();
+
+        foreach ($this->matches as $item) {
+            if (preg_match($regex, $item->textContent) > 0) {
+                $found->attach($item);
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Filter based on a callback function.
+     *
+     * A callback may be any of the following:
+     *  - a function: 'my_func'.
+     *  - an object/method combo: $obj, 'myMethod'
+     *  - a class/method combo: 'MyClass', 'myMethod'
+     * Note that classes are passed in strings. Objects are not.
+     *
+     * Each callback is passed to arguments:
+     *  - $index: The index position of the object in the array.
+     *  - $item: The item to be operated upon.
+     *
+     * If the callback function returns FALSE, the item will be removed from the
+     * set of matches. Otherwise the item will be considered a match and left alone.
+     *
+     * @param callback $callback .
+     *                           A callback either as a string (function) or an array (object, method OR
+     *                           classname, method).
+     *
+     * @return DOMQuery
+     *                           Query path object augmented according to the function.
+     * @throws ParseException
+     * @throws Exception
+     * @see map()
+     * @see is()
+     * @see find()
+     * @see filter()
+     * @see filterLambda()
+     */
+    public function filterCallback($callback): Query
+    {
+        $found = new SplObjectStorage();
+        $i     = 0;
+        if (is_callable($callback)) {
+            foreach ($this->matches as $item) {
+                if ($callback($i++, $item) !== false) {
+                    $found->attach($item);
+                }
+            }
+        } else {
+            throw new Exception('The specified callback is not callable.');
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Run a function on each item in a set.
+     *
+     * The mapping callback can return anything. Whatever it returns will be
+     * stored as a match in the set, though. This means that afer a map call,
+     * there is no guarantee that the elements in the set will behave correctly
+     * with other DOMQuery functions.
+     *
+     * Callback rules:
+     * - If the callback returns NULL, the item will be removed from the array.
+     * - If the callback returns an array, the entire array will be stored in
+     *   the results.
+     * - If the callback returns anything else, it will be appended to the array
+     *   of matches.
+     *
+     * @param callback $callback
+     *  The function or callback to use. The callback will be passed two params:
+     *  - $index: The index position in the list of items wrapped by this object.
+     *  - $item: The current item.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object wrapping a list of whatever values were returned
+     *  by each run of the callback.
+     *
+     * @throws Exception
+     * @throws ParseException
+     * @see find()
+     * @see DOMQuery::get()
+     * @see filter()
+     */
+    public function map($callback): Query
+    {
+        $found = new SplObjectStorage();
+
+        if (is_callable($callback)) {
+            $i = 0;
+            foreach ($this->matches as $item) {
+                $c = call_user_func($callback, $i, $item);
+                if (isset($c)) {
+                    if (is_array($c) || $c instanceof Iterable) {
+                        foreach ($c as $retval) {
+                            if (! is_object($retval)) {
+                                $tmp              = new stdClass();
+                                $tmp->textContent = $retval;
+                                $retval           = $tmp;
+                            }
+                            $found->attach($retval);
+                        }
+                    } else {
+                        if (! is_object($c)) {
+                            $tmp              = new stdClass();
+                            $tmp->textContent = $c;
+                            $c                = $tmp;
+                        }
+                        $found->attach($c);
+                    }
+                }
+                ++$i;
+            }
+        } else {
+            throw new Exception('Callback is not callable.');
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Narrow the items in this object down to only a slice of the starting items.
+     *
+     * @param integer $start
+     *  Where in the list of matches to begin the slice.
+     * @param integer $length
+     *  The number of items to include in the slice. If nothing is specified, the
+     *  all remaining matches (from $start onward) will be included in the sliced
+     *  list.
+     *
+     * @return DOMQuery
+     * @throws ParseException
+     * @see array_slice()
+     */
+    public function slice($start, $length = 0): Query
+    {
+        $end   = $length;
+        $found = new SplObjectStorage();
+        if ($start >= $this->count()) {
+            return $this->inst($found, null);
+        }
+
+        $i = $j = 0;
+        foreach ($this->matches as $m) {
+            if ($i >= $start) {
+                if ($end > 0 && $j >= $end) {
+                    break;
+                }
+                $found->attach($m);
+                ++$j;
+            }
+            ++$i;
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Run a callback on each item in the list of items.
+     *
+     * Rules of the callback:
+     * - A callback is passed two variables: $index and $item. (There is no
+     *   special treatment of $this, as there is in jQuery.)
+     *   - You will want to pass $item by reference if it is not an
+     *     object (DOMNodes are all objects).
+     * - A callback that returns FALSE will stop execution of the each() loop. This
+     *   works like break in a standard loop.
+     * - A TRUE return value from the callback is analogous to a continue statement.
+     * - All other return values are ignored.
+     *
+     * @param callback $callback
+     *  The callback to run.
+     *
+     * @return DOMQuery
+     *  The DOMQuery.
+     * @throws Exception
+     * @see filter()
+     * @see map()
+     * @see eachLambda()
+     */
+    public function each($callback): Query
+    {
+        if (is_callable($callback)) {
+            $i = 0;
+            foreach ($this->matches as $item) {
+                if (call_user_func($callback, $i, $item) === false) {
+                    return $this;
+                }
+                ++$i;
+            }
+        } else {
+            throw new Exception('Callback is not callable.');
+        }
+
+        return $this;
+    }
+
+    /**
+     * An each() iterator that takes a lambda function.
+     *
+     * @param string $lambda
+     *  The lambda function. This will be passed ($index, &$item).
+     *
+     * @return DOMQuery
+     *  The DOMQuery object.
+     * @deprecated
+     *   Since PHP 5.3 supports anonymous functions -- REAL Lambdas -- this
+     *   method is not necessary and should be avoided.
+     * @see each()
+     * @see filterLambda()
+     * @see filterCallback()
+     * @see map()
+     */
+    public function eachLambda($lambda): Query
+    {
+        $index = 0;
+        foreach ($this->matches as $item) {
+            $fn = create_function('$index, &$item', $lambda);
+            if ($fn($index, $item) === false) {
+                return $this;
+            }
+            ++$index;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get the even elements, so counter-intuitively 1, 3, 5, etc.
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    parent()
+     * @see    parents()
+     * @see    next()
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    removeChildren()
+     */
+    public function even(): Query
+    {
+        $found = new SplObjectStorage();
+        $even  = false;
+        foreach ($this->matches as $m) {
+            if ($even && $m->nodeType === XML_ELEMENT_NODE) {
+                $found->attach($m);
+            }
+            $even = $even ? false : true;
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the odd elements, so counter-intuitively 0, 2, 4, etc.
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    parent()
+     * @see    parents()
+     * @see    next()
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    removeChildren()
+     */
+    public function odd(): Query
+    {
+        $found = new SplObjectStorage();
+        $odd   = true;
+        foreach ($this->matches as $m) {
+            if ($odd && $m->nodeType === XML_ELEMENT_NODE) {
+                $found->attach($m);
+            }
+            $odd = $odd ? false : true;
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the first matching element.
+     *
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    next()
+     */
+    public function first(): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            if ($m->nodeType === XML_ELEMENT_NODE) {
+                $found->attach($m);
+                break;
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the first child of the matching element.
+     *
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    next()
+     */
+    public function firstChild(): Query
+    {
+        // Could possibly use $m->firstChild http://theserverpages.com/php/manual/en/ref.dom.php
+        $found = new SplObjectStorage();
+        $flag  = false;
+        foreach ($this->matches as $m) {
+            foreach ($m->childNodes as $c) {
+                if ($c->nodeType === XML_ELEMENT_NODE) {
+                    $found->attach($c);
+                    $flag = true;
+                    break;
+                }
+            }
+            if ($flag) {
+                break;
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the last matching element.
+     *
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    next()
+     */
+    public function last(): Query
+    {
+        $found = new SplObjectStorage();
+        $item  = null;
+        foreach ($this->matches as $m) {
+            if ($m->nodeType === XML_ELEMENT_NODE) {
+                $item = $m;
+            }
+        }
+        if ($item) {
+            $found->attach($item);
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the last child of the matching element.
+     *
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see    prev()
+     * @since  2.1
+     * @author eabrand
+     * @see    next()
+     */
+    public function lastChild(): Query
+    {
+        $found = new SplObjectStorage();
+        $item  = null;
+        foreach ($this->matches as $m) {
+            foreach ($m->childNodes as $c) {
+                if ($c->nodeType === XML_ELEMENT_NODE) {
+                    $item = $c;
+                }
+            }
+            if ($item) {
+                $found->attach($item);
+                $item = null;
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get all siblings after an element until the selector is reached.
+     *
+     * For each element in the DOMQuery, get all siblings that appear after
+     * it. If a selector is passed in, then only siblings that match the
+     * selector will be included.
+     *
+     * @param string $selector
+     *  A valid CSS 3 selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object, now containing the matching siblings.
+     * @throws Exception
+     * @see    prevAll()
+     * @see    children()
+     * @see    siblings()
+     * @since  2.1
+     * @author eabrand
+     * @see    next()
+     */
+    public function nextUntil($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->nextSibling)) {
+                $m = $m->nextSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (null !== $selector && QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                        break;
+                    }
+                    $found->attach($m);
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the previous siblings for each element in the DOMQuery
+     * until the selector is reached.
+     *
+     * For each element in the DOMQuery, get all previous siblings. If a
+     * selector is provided, only matching siblings will be retrieved.
+     *
+     * @param string $selector
+     *  A valid CSS 3 selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object, now wrapping previous sibling elements.
+     * @throws Exception
+     * @see    prev()
+     * @see    nextAll()
+     * @see    siblings()
+     * @see    contents()
+     * @see    children()
+     * @since  2.1
+     * @author eabrand
+     */
+    public function prevUntil($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->previousSibling)) {
+                $m = $m->previousSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (null !== $selector && QueryPath::with($m, null, $this->options)->is($selector)) {
+                        break;
+                    }
+
+                    $found->attach($m);
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get all ancestors of each element in the DOMQuery until the selector is reached.
+     *
+     * If a selector is present, only matching ancestors will be retrieved.
+     *
+     * @param string $selector
+     *  A valid CSS 3 Selector.
+     *
+     * @return DOMQuery
+     *  A DOMNode object containing the matching ancestors.
+     * @throws Exception
+     * @see    siblings()
+     * @see    children()
+     * @since  2.1
+     * @author eabrand
+     * @see    parent()
+     */
+    public function parentsUntil($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
+                $m = $m->parentNode;
+                // Is there any case where parent node is not an element?
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                            break;
+                        }
+                        $found->attach($m);
+                    } else {
+                        $found->attach($m);
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Reduce the matched set to just one.
+     *
+     * This will take a matched set and reduce it to just one item -- the item
+     * at the index specified. This is a destructive operation, and can be undone
+     * with {@link end()}.
+     *
+     * @param $index
+     *  The index of the element to keep. The rest will be
+     *  discarded.
+     *
+     * @return DOMQuery
+     * @throws ParseException
+     * @see is()
+     * @see end()
+     * @see get()
+     */
+    public function eq($index): Query
+    {
+        return $this->inst($this->getNthMatch($index), null);
+    }
+
+    /**
+     * Filter a list to contain only items that do NOT match.
+     *
+     * @param string $selector
+     *  A selector to use as a negation filter. If the filter is matched, the
+     *  element will be removed from the list.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object with matching items filtered out.
+     * @throws ParseException
+     * @throws Exception
+     * @see find()
+     */
+    public function not($selector): Query
+    {
+        $found = new SplObjectStorage();
+        if ($selector instanceof DOMElement) {
+            foreach ($this->matches as $m) {
+                if ($m !== $selector) {
+                    $found->attach($m);
+                }
+            }
+        } elseif (is_array($selector)) {
+            foreach ($this->matches as $m) {
+                if (! in_array($m, $selector, true)) {
+                    $found->attach($m);
+                }
+            }
+        } elseif ($selector instanceof SplObjectStorage) {
+            foreach ($this->matches as $m) {
+                if ($selector->contains($m)) {
+                    $found->attach($m);
+                }
+            }
+        } else {
+            foreach ($this->matches as $m) {
+                if (! QueryPath::with($m, null, $this->options)->is($selector)) {
+                    $found->attach($m);
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Find the closest element matching the selector.
+     *
+     * This finds the closest match in the ancestry chain. It first checks the
+     * present element. If the present element does not match, this traverses up
+     * the ancestry chain (e.g. checks each parent) looking for an item that matches.
+     *
+     * It is provided for jQuery 1.3 compatibility.
+     *
+     * @param string $selector
+     *  A CSS Selector to match.
+     *
+     * @return DOMQuery
+     *  The set of matches.
+     * @throws Exception
+     * @since 2.0
+     */
+    public function closest($selector): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                $found->attach($m);
+            } else {
+                while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
+                    $m = $m->parentNode;
+                    // Is there any case where parent node is not an element?
+                    if ($m->nodeType === XML_ELEMENT_NODE && QueryPath::with(
+                        $m,
+                        null,
+                        $this->options
+                    )->is($selector) > 0) {
+                        $found->attach($m);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // XXX: Should this be an in-place modification?
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the immediate parent of each element in the DOMQuery.
+     *
+     * If a selector is passed, this will return the nearest matching parent for
+     * each element in the DOMQuery.
+     *
+     * @param string $selector
+     *  A valid CSS3 selector.
+     *
+     * @return DOMQuery
+     *  A DOMNode object wrapping the matching parents.
+     * @throws Exception
+     * @see siblings()
+     * @see parents()
+     * @see children()
+     */
+    public function parent($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
+                $m = $m->parentNode;
+                // Is there any case where parent node is not an element?
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                            $found->attach($m);
+                            break;
+                        }
+                    } else {
+                        $found->attach($m);
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get all ancestors of each element in the DOMQuery.
+     *
+     * If a selector is present, only matching ancestors will be retrieved.
+     *
+     * @param string $selector
+     *  A valid CSS 3 Selector.
+     *
+     * @return DOMQuery
+     *  A DOMNode object containing the matching ancestors.
+     * @throws ParseException
+     * @throws Exception
+     * @see children()
+     * @see parent()
+     * @see siblings()
+     */
+    public function parents($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while ($m->parentNode->nodeType !== XML_DOCUMENT_NODE) {
+                $m = $m->parentNode;
+                // Is there any case where parent node is not an element?
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                            $found->attach($m);
+                        }
+                    } else {
+                        $found->attach($m);
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the next sibling of each element in the DOMQuery.
+     *
+     * If a selector is provided, the next matching sibling will be returned.
+     *
+     * @param string $selector
+     *  A CSS3 selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object.
+     * @throws Exception
+     * @throws ParseException
+     * @see nextAll()
+     * @see prev()
+     * @see children()
+     * @see contents()
+     * @see parent()
+     * @see parents()
+     */
+    public function next($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->nextSibling)) {
+                $m = $m->nextSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                            $found->attach($m);
+                            break;
+                        }
+                    } else {
+                        $found->attach($m);
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get all siblings after an element.
+     *
+     * For each element in the DOMQuery, get all siblings that appear after
+     * it. If a selector is passed in, then only siblings that match the
+     * selector will be included.
+     *
+     * @param string $selector
+     *  A valid CSS 3 selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object, now containing the matching siblings.
+     * @throws Exception
+     * @throws ParseException
+     * @see next()
+     * @see prevAll()
+     * @see children()
+     * @see siblings()
+     */
+    public function nextAll($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->nextSibling)) {
+                $m = $m->nextSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
+                            $found->attach($m);
+                        }
+                    } else {
+                        $found->attach($m);
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the next sibling before each element in the DOMQuery.
+     *
+     * For each element in the DOMQuery, this retrieves the previous sibling
+     * (if any). If a selector is supplied, it retrieves the first matching
+     * sibling (if any is found).
+     *
+     * @param string $selector
+     *  A valid CSS 3 selector.
+     *
+     * @return DOMQuery
+     *  A DOMNode object, now containing any previous siblings that have been
+     *  found.
+     * @throws Exception
+     * @throws ParseException
+     * @see prevAll()
+     * @see next()
+     * @see siblings()
+     * @see children()
+     */
+    public function prev($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->previousSibling)) {
+                $m = $m->previousSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector)) {
+                            $found->attach($m);
+                            break;
+                        }
+                    } else {
+                        $found->attach($m);
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the previous siblings for each element in the DOMQuery.
+     *
+     * For each element in the DOMQuery, get all previous siblings. If a
+     * selector is provided, only matching siblings will be retrieved.
+     *
+     * @param string $selector
+     *  A valid CSS 3 selector.
+     *
+     * @return DOMQuery
+     *  The DOMQuery object, now wrapping previous sibling elements.
+     * @throws ParseException
+     * @throws Exception
+     * @see siblings()
+     * @see contents()
+     * @see children()
+     * @see prev()
+     * @see nextAll()
+     */
+    public function prevAll($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            while (isset($m->previousSibling)) {
+                $m = $m->previousSibling;
+                if ($m->nodeType === XML_ELEMENT_NODE) {
+                    if (! empty($selector)) {
+                        if (QueryPath::with($m, null, $this->options)->is($selector)) {
+                            $found->attach($m);
+                        }
+                    } else {
+                        $found->attach($m);
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get the children of the elements in the DOMQuery object.
+     *
+     * If a selector is provided, the list of children will be filtered through
+     * the selector.
+     *
+     * @param string $selector
+     *  A valid selector.
+     *
+     * @return DOMQuery
+     *  A DOMQuery wrapping all of the children.
+     * @throws ParseException
+     * @see parent()
+     * @see parents()
+     * @see next()
+     * @see prev()
+     * @see removeChildren()
+     */
+    public function children($selector = null): Query
+    {
+        $found  = new SplObjectStorage();
+        $filter = is_string($selector) && strlen($selector) > 0;
+
+        if ($filter) {
+            $tmp = new SplObjectStorage();
+        }
+        foreach ($this->matches as $m) {
+            foreach ($m->childNodes as $c) {
+                if ($c->nodeType === XML_ELEMENT_NODE) {
+                    // This is basically an optimized filter() just for children().
+                    if ($filter) {
+                        $tmp->attach($c);
+                        $query = new DOMTraverser($tmp, true, $c);
+                        $query->find($selector);
+                        if (count($query->matches()) > 0) {
+                            $found->attach($c);
+                        }
+                        $tmp->detach($c);
+                    } // No filter. Just attach it.
+                    else {
+                        $found->attach($c);
+                    }
+                }
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get all child nodes (not just elements) of all items in the matched set.
+     *
+     * It gets only the immediate children, not all nodes in the subtree.
+     *
+     * This does not process iframes. Xinclude processing is dependent on the
+     * DOM implementation and configuration.
+     *
+     * @return DOMQuery
+     *  A DOMNode object wrapping all child nodes for all elements in the
+     *  DOMNode object.
+     * @throws ParseException
+     * @see text()
+     * @see html()
+     * @see innerHTML()
+     * @see xml()
+     * @see innerXML()
+     * @see find()
+     */
+    public function contents(): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            if (empty($m->childNodes)) {
+                continue;
+            }
+            foreach ($m->childNodes as $c) {
+                $found->attach($c);
+            }
+        }
+
+        return $this->inst($found, null);
+    }
+
+    /**
+     * Get a list of siblings for elements currently wrapped by this object.
+     *
+     * This will compile a list of every sibling of every element in the
+     * current list of elements.
+     *
+     * Note that if two siblings are present in the DOMQuery object to begin with,
+     * then both will be returned in the matched set, since they are siblings of each
+     * other. In other words,if the matches contain a and b, and a and b are siblings of
+     * each other, than running siblings will return a set that contains
+     * both a and b.
+     *
+     * @param string $selector
+     *  If the optional selector is provided, siblings will be filtered through
+     *  this expression.
+     *
+     * @return DOMQuery
+     *  The DOMQuery containing the matched siblings.
+     * @throws ParseException
+     * @throws ParseException
+     * @see parent()
+     * @see parents()
+     * @see contents()
+     * @see children()
+     */
+    public function siblings($selector = null): Query
+    {
+        $found = new SplObjectStorage();
+        foreach ($this->matches as $m) {
+            $parent = $m->parentNode;
+            foreach ($parent->childNodes as $n) {
+                if ($n->nodeType === XML_ELEMENT_NODE && $n !== $m) {
+                    $found->attach($n);
+                }
+            }
+        }
+        if (empty($selector)) {
+            return $this->inst($found, null);
+        }
+
+        return $this->inst($found, null)->filter($selector);
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -245,7 +245,7 @@ 
 				if (isset($c)) {
 					if (is_array($c) || $c instanceof Iterable) {
 						foreach ($c as $retval) {
-							if (! is_object($retval)) {
+							if (!is_object($retval)) {
 								$tmp              = new stdClass();
 								$tmp->textContent = $retval;
 								$retval           = $tmp;
@@ -253,7 +253,7 @@ 
 							$found->attach($retval);
 						}
 					} else {
-						if (! is_object($c)) {
+						if (!is_object($c)) {
 							$tmp              = new stdClass();
 							$tmp->textContent = $c;
 							$c                = $tmp;
@@ -653,7 +653,7 @@ 
 				$m = $m->parentNode;
 				// Is there any case where parent node is not an element?
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
 							break;
 						}
@@ -714,7 +714,7 @@ 
 			}
 		} elseif (is_array($selector)) {
 			foreach ($this->matches as $m) {
-				if (! in_array($m, $selector, true)) {
+				if (!in_array($m, $selector, true)) {
 					$found->attach($m);
 				}
 			}
@@ -726,7 +726,7 @@ 
 			}
 		} else {
 			foreach ($this->matches as $m) {
-				if (! QueryPath::with($m, null, $this->options)->is($selector)) {
+				if (!QueryPath::with($m, null, $this->options)->is($selector)) {
 					$found->attach($m);
 				}
 			}
@@ -802,7 +802,7 @@ 
 				$m = $m->parentNode;
 				// Is there any case where parent node is not an element?
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
 							$found->attach($m);
 							break;
@@ -842,7 +842,7 @@ 
 				$m = $m->parentNode;
 				// Is there any case where parent node is not an element?
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
 							$found->attach($m);
 						}
@@ -882,7 +882,7 @@ 
 			while (isset($m->nextSibling)) {
 				$m = $m->nextSibling;
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
 							$found->attach($m);
 							break;
@@ -924,7 +924,7 @@ 
 			while (isset($m->nextSibling)) {
 				$m = $m->nextSibling;
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector) > 0) {
 							$found->attach($m);
 						}
@@ -965,7 +965,7 @@ 
 			while (isset($m->previousSibling)) {
 				$m = $m->previousSibling;
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector)) {
 							$found->attach($m);
 							break;
@@ -1007,7 +1007,7 @@ 
 			while (isset($m->previousSibling)) {
 				$m = $m->previousSibling;
 				if ($m->nodeType === XML_ELEMENT_NODE) {
-					if (! empty($selector)) {
+					if (!empty($selector)) {
 						if (QueryPath::with($m, null, $this->options)->is($selector)) {
 							$found->attach($m);
 						}