If you have ever needed to manipulate a DOM document (e.g. a HTML document) in PHP, you have probably noticed that the DOMDocument class offers very limited functionality for this, and it is not so convenient. After doing some research, I found a nice overview of extensions and libraries that displays various options for manipulating and/or parsing DOM documents. I found the phpQuery library to be particularly interesting, so I decided to look further into it.
phpQuery is, as the name suggests, a PHP port of the popular JavaScript library named jQuery. The core principles from jQuery remain in phpQuery, such as method chaining as well as the fact that it is driven by CSS3 selectors. This makes extracting data from documents as well as manipulating the Document Object Model (DOM) very easy. I will present a few examples of how phpQuery can be used below, but I urge you to visit the official project page for further information about the API and installation instructions. If you are using Composer for your project, then I found that phpQuery can be installed by adding “duvanmonsa/php-query”: “dev-master” to your composer.json and then write php composer.phar update in the Terminal or Command Prompt.
Loading Documents
There are a number of functions which can be used to load documents that can then be operated upon by phpQuery. If using one of the static methods, one can operate on the document by using the pq function, which operates on the last selected document. If you have more than one document, it is possible to pass a document ID or document object to the function as a second parameter. All of this is demonstrated in the code snippet below.
Selectors
The selectors and filters available in phpQuery very much correspond to those of jQuery, as most CSS3 selectors have been implemented. Below are a few examples. For a more comprehensive overview, please see the documentation of jQuery selectors.
Please note that I am using the find method in the subsequent examples, but could just as well have used the pq method as in the previous code snippet.
Document Manipulation
The code snippet below lists some common operations to manipulate a DOM document. As with jQuery, methods can conveniently be chained to provide a fluent interface that reduces the amount of code.
Conclusion
There are many options for parsing and/or manipulating DOM documents in PHP. This article focused on the phpQuery project for a number of reasons. First of all, it allows developers to use their experience from jQuery such that they do not have to learn an entirely new library. Secondly, the syntax is extremely simple and intuitive, enabling developers to do complex logic within a single or few lines of code.
It should be noted, however, that I have not yet tried most of the other libraries and extensions that are available, so if you have any other recommendations, then you are more than welcome to leave a comment. It does seem as if the phpQuery project is no longer maintained, as the last update was a few years ago. Whether or not this is simply because it is stable and functional, I do not know. For my use cases, it has worked well, but this is something to consider depending on your use case.
There is more to phpQuery than was discussed in this article. For a complete overview of supported functionality, please refer to the official project page and the jQuery API.
<?php
require('phpQuery/phpQuery.php');
// INITIALIZE IT
// phpQuery::newDocumentHTML($markup);
// phpQuery::newDocumentXML();
// phpQuery::newDocumentFileXHTML('test.html');
// phpQuery::newDocumentFilePHP('test.php');
// phpQuery::newDocument('test.xml', 'application/rss+xml');
// this one defaults to text/html in utf8
$doc = phpQuery::newDocument('<div/>');
// FILL IT
// array syntax works like ->find() here
$doc['div']->append('<ul></ul>');
// array set changes inner html
$doc['div ul'] = '<li>1</li> <li>2</li> <li>3</li>';
// MANIPULATE IT
$li = null;
// almost everything can be a chain
$doc['ul > li']
->addClass('my-new-class')
->filter(':last')
->addClass('last-li')
// save it anywhere in the chain
->toReference($li);
// SELECT DOCUMENT
// pq(); is using selected document as default
phpQuery::selectDocument($doc);
// documents are selected when created or by above method
// query all unordered lists in last selected document
$ul = pq('ul')->insertAfter('div');
// ITERATE IT
// all direct LIs from $ul
foreach($ul['> li'] as $li) {
// iteration returns PLAIN dom nodes, NOT phpQuery objects
$tagName = $li->tagName;
$childNodes = $li->childNodes;
// so you NEED to wrap it within phpQuery, using pq();
pq($li)->addClass('my-second-new-class');
}
// PRINT OUTPUT
// 1st way
print phpQuery::getDocument($doc->getDocumentID());
// 2nd way
print phpQuery::getDocument(pq('div')->getDocumentID());
// 3rd way
print pq('div')->getDocument();
// 4th way
print $doc->htmlOuter();
// 5th way
print $doc;
// another...
print $doc['ul'];
<?php
require('phpQuery/phpQuery.php');
$file = 'test.html'; // see below for source
// loads the file
// basically think of your php script as a regular HTML page running client side with jQuery. This loads whatever file you want to be the current page
phpQuery::newDocumentFileHTML($file);
// Once the page is loaded, you can then make queries on whatever DOM is loaded.
// This example grabs the title of the currently loaded page.
$titleElement = pq('title'); // in jQuery, this would return a jQuery object. I'm guessing something similar is happening here with pq.
// You can then use any of the functionality available to that pq object. Such as getting the innerHTML like I do here.
$title = $titleElement->html();
// And output the result
echo '<h2>Title:</h2>';
echo '<p>' . htmlentities( $title) . '</p>';
<?php
/**
* phpQuery is a server-side, chainable, CSS3 selector driven
* Document Object Model (DOM) API based on jQuery JavaScript Library.
*
* @version 0.9.5
* @link http://code.google.com/p/phpquery/
* @link http://phpquery-library.blogspot.com/
* @link http://jquery.com/
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @license http://www.opensource.org/licenses/mit-license.php MIT License
* @package phpQuery
*/
// class names for instanceof
// TODO move them as class constants into phpQuery
define('DOMDOCUMENT', 'DOMDocument');
define('DOMELEMENT', 'DOMElement');
define('DOMNODELIST', 'DOMNodeList');
define('DOMNODE', 'DOMNode');
/**
* DOMEvent class.
*
* Based on
* @link http://developer.mozilla.org/En/DOM:event
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
* @todo implement ArrayAccess ?
*/
class DOMEvent {
/**
* Returns a boolean indicating whether the event bubbles up through the DOM or not.
*
* @var unknown_type
*/
public $bubbles = true;
/**
* Returns a boolean indicating whether the event is cancelable.
*
* @var unknown_type
*/
public $cancelable = true;
/**
* Returns a reference to the currently registered target for the event.
*
* @var unknown_type
*/
public $currentTarget;
/**
* Returns detail about the event, depending on the type of event.
*
* @var unknown_type
* @link http://developer.mozilla.org/en/DOM/event.detail
*/
public $detail; // ???
/**
* Used to indicate which phase of the event flow is currently being evaluated.
*
* NOT IMPLEMENTED
*
* @var unknown_type
* @link http://developer.mozilla.org/en/DOM/event.eventPhase
*/
public $eventPhase; // ???
/**
* The explicit original target of the event (Mozilla-specific).
*
* NOT IMPLEMENTED
*
* @var unknown_type
*/
public $explicitOriginalTarget; // moz only
/**
* The original target of the event, before any retargetings (Mozilla-specific).
*
* NOT IMPLEMENTED
*
* @var unknown_type
*/
public $originalTarget; // moz only
/**
* Identifies a secondary target for the event.
*
* @var unknown_type
*/
public $relatedTarget;
/**
* Returns a reference to the target to which the event was originally dispatched.
*
* @var unknown_type
*/
public $target;
/**
* Returns the time that the event was created.
*
* @var unknown_type
*/
public $timeStamp;
/**
* Returns the name of the event (case-insensitive).
*/
public $type;
public $runDefault = true;
public $data = null;
public function __construct($data) {
foreach($data as $k => $v) {
$this->$k = $v;
}
if (! $this->timeStamp)
$this->timeStamp = time();
}
/**
* Cancels the event (if it is cancelable).
*
*/
public function preventDefault() {
$this->runDefault = false;
}
/**
* Stops the propagation of events further along in the DOM.
*
*/
public function stopPropagation() {
$this->bubbles = false;
}
}
/**
* DOMDocumentWrapper class simplifies work with DOMDocument.
*
* Know bug:
* - in XHTML fragments, <br /> changes to <br clear="none" />
*
* @todo check XML catalogs compatibility
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
*/
class DOMDocumentWrapper {
/**
* @var DOMDocument
*/
public $document;
public $id;
/**
* @todo Rewrite as method and quess if null.
* @var unknown_type
*/
public $contentType = '';
public $xpath;
public $uuid = 0;
public $data = array();
public $dataNodes = array();
public $events = array();
public $eventsNodes = array();
public $eventsGlobal = array();
/**
* @TODO iframes support http://code.google.com/p/phpquery/issues/detail?id=28
* @var unknown_type
*/
public $frames = array();
/**
* Document root, by default equals to document itself.
* Used by documentFragments.
*
* @var DOMNode
*/
public $root;
public $isDocumentFragment;
public $isXML = false;
public $isXHTML = false;
public $isHTML = false;
public $charset;
public function __construct($markup = null, $contentType = null, $newDocumentID = null) {
if (isset($markup))
$this->load($markup, $contentType, $newDocumentID);
$this->id = $newDocumentID
? $newDocumentID
: md5(microtime());
}
public function load($markup, $contentType = null, $newDocumentID = null) {
// phpQuery::$documents[$id] = $this;
$this->contentType = strtolower($contentType);
if ($markup instanceof DOMDOCUMENT) {
$this->document = $markup;
$this->root = $this->document;
$this->charset = $this->document->encoding;
// TODO isDocumentFragment
} else {
$loaded = $this->loadMarkup($markup);
}
if ($loaded) {
// $this->document->formatOutput = true;
$this->document->preserveWhiteSpace = true;
$this->xpath = new DOMXPath($this->document);
$this->afterMarkupLoad();
return true;
// remember last loaded document
// return phpQuery::selectDocument($id);
}
return false;
}
protected function afterMarkupLoad() {
if ($this->isXHTML) {
$this->xpath->registerNamespace("html", "http://www.w3.org/1999/xhtml");
}
}
protected function loadMarkup($markup) {
$loaded = false;
if ($this->contentType) {
self::debug("Load markup for content type {$this->contentType}");
// content determined by contentType
list($contentType, $charset) = $this->contentTypeToArray($this->contentType);
switch($contentType) {
case 'text/html':
phpQuery::debug("Loading HTML, content type '{$this->contentType}'");
$loaded = $this->loadMarkupHTML($markup, $charset);
break;
case 'text/xml':
case 'application/xhtml+xml':
phpQuery::debug("Loading XML, content type '{$this->contentType}'");
$loaded = $this->loadMarkupXML($markup, $charset);
break;
default:
// for feeds or anything that sometimes doesn't use text/xml
if (strpos('xml', $this->contentType) !== false) {
phpQuery::debug("Loading XML, content type '{$this->contentType}'");
$loaded = $this->loadMarkupXML($markup, $charset);
} else
phpQuery::debug("Could not determine document type from content type '{$this->contentType}'");
}
} else {
// content type autodetection
if ($this->isXML($markup)) {
phpQuery::debug("Loading XML, isXML() == true");
$loaded = $this->loadMarkupXML($markup);
if (! $loaded && $this->isXHTML) {
phpQuery::debug('Loading as XML failed, trying to load as HTML, isXHTML == true');
$loaded = $this->loadMarkupHTML($markup);
}
} else {
phpQuery::debug("Loading HTML, isXML() == false");
$loaded = $this->loadMarkupHTML($markup);
}
}
return $loaded;
}
protected function loadMarkupReset() {
$this->isXML = $this->isXHTML = $this->isHTML = false;
}
protected function documentCreate($charset, $version = '1.0') {
if (! $version)
$version = '1.0';
$this->document = new DOMDocument($version, $charset);
$this->charset = $this->document->encoding;
// $this->document->encoding = $charset;
$this->document->formatOutput = true;
$this->document->preserveWhiteSpace = true;
}
protected function loadMarkupHTML($markup, $requestedCharset = null) {
if (phpQuery::$debug)
phpQuery::debug('Full markup load (HTML): '.substr($markup, 0, 250));
$this->loadMarkupReset();
$this->isHTML = true;
if (!isset($this->isDocumentFragment))
$this->isDocumentFragment = self::isDocumentFragmentHTML($markup);
$charset = null;
$documentCharset = $this->charsetFromHTML($markup);
$addDocumentCharset = false;
if ($documentCharset) {
$charset = $documentCharset;
$markup = $this->charsetFixHTML($markup);
} else if ($requestedCharset) {
$charset = $requestedCharset;
}
if (! $charset)
$charset = phpQuery::$defaultCharset;
// HTTP 1.1 says that the default charset is ISO-8859-1
// @see http://www.w3.org/International/O-HTTP-charset
if (! $documentCharset) {
$documentCharset = 'ISO-8859-1';
$addDocumentCharset = true;
}
// Should be careful here, still need 'magic encoding detection' since lots of pages have other 'default encoding'
// Worse, some pages can have mixed encodings... we'll try not to worry about that
$requestedCharset = strtoupper($requestedCharset);
$documentCharset = strtoupper($documentCharset);
phpQuery::debug("DOC: $documentCharset REQ: $requestedCharset");
if ($requestedCharset && $documentCharset && $requestedCharset !== $documentCharset) {
phpQuery::debug("CHARSET CONVERT");
// Document Encoding Conversion
// http://code.google.com/p/phpquery/issues/detail?id=86
if (function_exists('mb_detect_encoding')) {
$possibleCharsets = array($documentCharset, $requestedCharset, 'AUTO');
$docEncoding = mb_detect_encoding($markup, implode(', ', $possibleCharsets));
if (! $docEncoding)
$docEncoding = $documentCharset; // ok trust the document
phpQuery::debug("DETECTED '$docEncoding'");
// Detected does not match what document says...
if ($docEncoding !== $documentCharset) {
// Tricky..
}
if ($docEncoding !== $requestedCharset) {
phpQuery::debug("CONVERT $docEncoding => $requestedCharset");
$markup = mb_convert_encoding($markup, $requestedCharset, $docEncoding);
$markup = $this->charsetAppendToHTML($markup, $requestedCharset);
$charset = $requestedCharset;
}
} else {
phpQuery::debug("TODO: charset conversion without mbstring...");
}
}
$return = false;
if ($this->isDocumentFragment) {
phpQuery::debug("Full markup load (HTML), DocumentFragment detected, using charset '$charset'");
$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
} else {
if ($addDocumentCharset) {
phpQuery::debug("Full markup load (HTML), appending charset: '$charset'");
$markup = $this->charsetAppendToHTML($markup, $charset);
}
phpQuery::debug("Full markup load (HTML), documentCreate('$charset')");
$this->documentCreate($charset);
$return = phpQuery::$debug === 2
? $this->document->loadHTML($markup)
: @$this->document->loadHTML($markup);
if ($return)
$this->root = $this->document;
}
if ($return && ! $this->contentType)
$this->contentType = 'text/html';
return $return;
}
protected function loadMarkupXML($markup, $requestedCharset = null) {
if (phpQuery::$debug)
phpQuery::debug('Full markup load (XML): '.substr($markup, 0, 250));
$this->loadMarkupReset();
$this->isXML = true;
// check agains XHTML in contentType or markup
$isContentTypeXHTML = $this->isXHTML();
$isMarkupXHTML = $this->isXHTML($markup);
if ($isContentTypeXHTML || $isMarkupXHTML) {
self::debug('Full markup load (XML), XHTML detected');
$this->isXHTML = true;
}
// determine document fragment
if (! isset($this->isDocumentFragment))
$this->isDocumentFragment = $this->isXHTML
? self::isDocumentFragmentXHTML($markup)
: self::isDocumentFragmentXML($markup);
// this charset will be used
$charset = null;
// charset from XML declaration @var string
$documentCharset = $this->charsetFromXML($markup);
if (! $documentCharset) {
if ($this->isXHTML) {
// this is XHTML, try to get charset from content-type meta header
$documentCharset = $this->charsetFromHTML($markup);
if ($documentCharset) {
phpQuery::debug("Full markup load (XML), appending XHTML charset '$documentCharset'");
$this->charsetAppendToXML($markup, $documentCharset);
$charset = $documentCharset;
}
}
if (! $documentCharset) {
// if still no document charset...
$charset = $requestedCharset;
}
} else if ($requestedCharset) {
$charset = $requestedCharset;
}
if (! $charset) {
$charset = phpQuery::$defaultCharset;
}
if ($requestedCharset && $documentCharset && $requestedCharset != $documentCharset) {
// TODO place for charset conversion
// $charset = $requestedCharset;
}
$return = false;
if ($this->isDocumentFragment) {
phpQuery::debug("Full markup load (XML), DocumentFragment detected, using charset '$charset'");
$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
} else {
// FIXME ???
if ($isContentTypeXHTML && ! $isMarkupXHTML)
if (! $documentCharset) {
phpQuery::debug("Full markup load (XML), appending charset '$charset'");
$markup = $this->charsetAppendToXML($markup, $charset);
}
// see http://pl2.php.net/manual/en/book.dom.php#78929
// LIBXML_DTDLOAD (>= PHP 5.1)
// does XML ctalogues works with LIBXML_NONET
// $this->document->resolveExternals = true;
// TODO test LIBXML_COMPACT for performance improvement
// create document
$this->documentCreate($charset);
if (phpversion() < 5.1) {
$this->document->resolveExternals = true;
$return = phpQuery::$debug === 2
? $this->document->loadXML($markup)
: @$this->document->loadXML($markup);
} else {
/** @link http://pl2.php.net/manual/en/libxml.constants.php */
$libxmlStatic = phpQuery::$debug === 2
? LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET
: LIBXML_DTDLOAD|LIBXML_DTDATTR|LIBXML_NONET|LIBXML_NOWARNING|LIBXML_NOERROR;
$return = $this->document->loadXML($markup, $libxmlStatic);
// if (! $return)
// $return = $this->document->loadHTML($markup);
}
if ($return)
$this->root = $this->document;
}
if ($return) {
if (! $this->contentType) {
if ($this->isXHTML)
$this->contentType = 'application/xhtml+xml';
else
$this->contentType = 'text/xml';
}
return $return;
} else {
throw new Exception("Error loading XML markup");
}
}
protected function isXHTML($markup = null) {
if (! isset($markup)) {
return strpos($this->contentType, 'xhtml') !== false;
}
// XXX ok ?
return strpos($markup, "<!DOCTYPE html") !== false;
// return stripos($doctype, 'xhtml') !== false;
// $doctype = isset($dom->doctype) && is_object($dom->doctype)
// ? $dom->doctype->publicId
// : self::$defaultDoctype;
}
protected function isXML($markup) {
// return strpos($markup, '<?xml') !== false && stripos($markup, 'xhtml') === false;
return strpos(substr($markup, 0, 100), '<'.'?xml') !== false;
}
protected function contentTypeToArray($contentType) {
$matches = explode(';', trim(strtolower($contentType)));
if (isset($matches[1])) {
$matches[1] = explode('=', $matches[1]);
// strip 'charset='
$matches[1] = isset($matches[1][1]) && trim($matches[1][1])
? $matches[1][1]
: $matches[1][0];
} else
$matches[1] = null;
return $matches;
}
/**
*
* @param $markup
* @return array contentType, charset
*/
protected function contentTypeFromHTML($markup) {
$matches = array();
// find meta tag
preg_match('@<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
$markup, $matches
);
if (! isset($matches[0]))
return array(null, null);
// get attr 'content'
preg_match('@content\\s*=\\s*(["|\'])(.+?)\\1@', $matches[0], $matches);
if (! isset($matches[0]))
return array(null, null);
return $this->contentTypeToArray($matches[2]);
}
protected function charsetFromHTML($markup) {
$contentType = $this->contentTypeFromHTML($markup);
return $contentType[1];
}
protected function charsetFromXML($markup) {
$matches;
// find declaration
preg_match('@<'.'?xml[^>]+encoding\\s*=\\s*(["|\'])(.*?)\\1@i',
$markup, $matches
);
return isset($matches[2])
? strtolower($matches[2])
: null;
}
/**
* Repositions meta[type=charset] at the start of head. Bypasses DOMDocument bug.
*
* @link http://code.google.com/p/phpquery/issues/detail?id=80
* @param $html
*/
protected function charsetFixHTML($markup) {
$matches = array();
// find meta tag
preg_match('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i',
$markup, $matches, PREG_OFFSET_CAPTURE
);
if (! isset($matches[0]))
return;
$metaContentType = $matches[0][0];
$markup = substr($markup, 0, $matches[0][1])
.substr($markup, $matches[0][1]+strlen($metaContentType));
$headStart = stripos($markup, '<head>');
$markup = substr($markup, 0, $headStart+6).$metaContentType
.substr($markup, $headStart+6);
return $markup;
}
protected function charsetAppendToHTML($html, $charset, $xhtml = false) {
// remove existing meta[type=content-type]
$html = preg_replace('@\s*<meta[^>]+http-equiv\\s*=\\s*(["|\'])Content-Type\\1([^>]+?)>@i', '', $html);
$meta = '<meta http-equiv="Content-Type" content="text/html;charset='
.$charset.'" '
.($xhtml ? '/' : '')
.'>';
if (strpos($html, '<head') === false) {
if (strpos($hltml, '<html') === false) {
return $meta.$html;
} else {
return preg_replace(
'@<html(.*?)(?(?<!\?)>)@s',
"<html\\1><head>{$meta}</head>",
$html
);
}
} else {
return preg_replace(
'@<head(.*?)(?(?<!\?)>)@s',
'<head\\1>'.$meta,
$html
);
}
}
protected function charsetAppendToXML($markup, $charset) {
$declaration = '<'.'?xml version="1.0" encoding="'.$charset.'"?'.'>';
return $declaration.$markup;
}
public static function isDocumentFragmentHTML($markup) {
return stripos($markup, '<html') === false && stripos($markup, '<!doctype') === false;
}
public static function isDocumentFragmentXML($markup) {
return stripos($markup, '<'.'?xml') === false;
}
public static function isDocumentFragmentXHTML($markup) {
return self::isDocumentFragmentHTML($markup);
}
public function importAttr($value) {
// TODO
}
/**
*
* @param $source
* @param $target
* @param $sourceCharset
* @return array Array of imported nodes.
*/
public function import($source, $sourceCharset = null) {
// TODO charset conversions
$return = array();
if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
$source = array($source);
// if (is_array($source)) {
// foreach($source as $node) {
// if (is_string($node)) {
// // string markup
// $fake = $this->documentFragmentCreate($node, $sourceCharset);
// if ($fake === false)
// throw new Exception("Error loading documentFragment markup");
// else
// $return = array_merge($return,
// $this->import($fake->root->childNodes)
// );
// } else {
// $return[] = $this->document->importNode($node, true);
// }
// }
// return $return;
// } else {
// // string markup
// $fake = $this->documentFragmentCreate($source, $sourceCharset);
// if ($fake === false)
// throw new Exception("Error loading documentFragment markup");
// else
// return $this->import($fake->root->childNodes);
// }
if (is_array($source) || $source instanceof DOMNODELIST) {
// dom nodes
self::debug('Importing nodes to document');
foreach($source as $node)
$return[] = $this->document->importNode($node, true);
} else {
// string markup
$fake = $this->documentFragmentCreate($source, $sourceCharset);
if ($fake === false)
throw new Exception("Error loading documentFragment markup");
else
return $this->import($fake->root->childNodes);
}
return $return;
}
/**
* Creates new document fragment.
*
* @param $source
* @return DOMDocumentWrapper
*/
protected function documentFragmentCreate($source, $charset = null) {
$fake = new DOMDocumentWrapper();
$fake->contentType = $this->contentType;
$fake->isXML = $this->isXML;
$fake->isHTML = $this->isHTML;
$fake->isXHTML = $this->isXHTML;
$fake->root = $fake->document;
if (! $charset)
$charset = $this->charset;
// $fake->documentCreate($this->charset);
if ($source instanceof DOMNODE && !($source instanceof DOMNODELIST))
$source = array($source);
if (is_array($source) || $source instanceof DOMNODELIST) {
// dom nodes
// load fake document
if (! $this->documentFragmentLoadMarkup($fake, $charset))
return false;
$nodes = $fake->import($source);
foreach($nodes as $node)
$fake->root->appendChild($node);
} else {
// string markup
$this->documentFragmentLoadMarkup($fake, $charset, $source);
}
return $fake;
}
/**
*
* @param $document DOMDocumentWrapper
* @param $markup
* @return $document
*/
private function documentFragmentLoadMarkup($fragment, $charset, $markup = null) {
// TODO error handling
// TODO copy doctype
// tempolary turn off
$fragment->isDocumentFragment = false;
if ($fragment->isXML) {
if ($fragment->isXHTML) {
// add FAKE element to set default namespace
$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?>'
.'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
.'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
.'<fake xmlns="http://www.w3.org/1999/xhtml">'.$markup.'</fake>');
$fragment->root = $fragment->document->firstChild->nextSibling;
} else {
$fragment->loadMarkupXML('<?xml version="1.0" encoding="'.$charset.'"?><fake>'.$markup.'</fake>');
$fragment->root = $fragment->document->firstChild;
}
} else {
$markup2 = phpQuery::$defaultDoctype.'<html><head><meta http-equiv="Content-Type" content="text/html;charset='
.$charset.'"></head>';
$noBody = strpos($markup, '<body') === false;
if ($noBody)
$markup2 .= '<body>';
$markup2 .= $markup;
if ($noBody)
$markup2 .= '</body>';
$markup2 .= '</html>';
$fragment->loadMarkupHTML($markup2);
// TODO resolv body tag merging issue
$fragment->root = $noBody
? $fragment->document->firstChild->nextSibling->firstChild->nextSibling
: $fragment->document->firstChild->nextSibling->firstChild->nextSibling;
}
if (! $fragment->root)
return false;
$fragment->isDocumentFragment = true;
return true;
}
protected function documentFragmentToMarkup($fragment) {
phpQuery::debug('documentFragmentToMarkup');
$tmp = $fragment->isDocumentFragment;
$fragment->isDocumentFragment = false;
$markup = $fragment->markup();
if ($fragment->isXML) {
$markup = substr($markup, 0, strrpos($markup, '</fake>'));
if ($fragment->isXHTML) {
$markup = substr($markup, strpos($markup, '<fake')+43);
} else {
$markup = substr($markup, strpos($markup, '<fake>')+6);
}
} else {
$markup = substr($markup, strpos($markup, '<body>')+6);
$markup = substr($markup, 0, strrpos($markup, '</body>'));
}
$fragment->isDocumentFragment = $tmp;
if (phpQuery::$debug)
phpQuery::debug('documentFragmentToMarkup: '.substr($markup, 0, 150));
return $markup;
}
/**
* Return document markup, starting with optional $nodes as root.
*
* @param $nodes DOMNode|DOMNodeList
* @return string
*/
public function markup($nodes = null, $innerMarkup = false) {
if (isset($nodes) && count($nodes) == 1 && $nodes[0] instanceof DOMDOCUMENT)
$nodes = null;
if (isset($nodes)) {
$markup = '';
if (!is_array($nodes) && !($nodes instanceof DOMNODELIST) )
$nodes = array($nodes);
if ($this->isDocumentFragment && ! $innerMarkup)
foreach($nodes as $i => $node)
if ($node->isSameNode($this->root)) {
// var_dump($node);
$nodes = array_slice($nodes, 0, $i)
+ phpQuery::DOMNodeListToArray($node->childNodes)
+ array_slice($nodes, $i+1);
}
if ($this->isXML && ! $innerMarkup) {
self::debug("Getting outerXML with charset '{$this->charset}'");
// we need outerXML, so we can benefit from
// $node param support in saveXML()
foreach($nodes as $node)
$markup .= $this->document->saveXML($node);
} else {
$loop = array();
if ($innerMarkup)
foreach($nodes as $node) {
if ($node->childNodes)
foreach($node->childNodes as $child)
$loop[] = $child;
else
$loop[] = $node;
}
else
$loop = $nodes;
self::debug("Getting markup, moving selected nodes (".count($loop).") to new DocumentFragment");
$fake = $this->documentFragmentCreate($loop);
$markup = $this->documentFragmentToMarkup($fake);
}
if ($this->isXHTML) {
self::debug("Fixing XHTML");
$markup = self::markupFixXHTML($markup);
}
self::debug("Markup: ".substr($markup, 0, 250));
return $markup;
} else {
if ($this->isDocumentFragment) {
// documentFragment, html only...
self::debug("Getting markup, DocumentFragment detected");
// return $this->markup(
//// $this->document->getElementsByTagName('body')->item(0)
// $this->document->root, true
// );
$markup = $this->documentFragmentToMarkup($this);
// no need for markupFixXHTML, as it's done thought markup($nodes) method
return $markup;
} else {
self::debug("Getting markup (".($this->isXML?'XML':'HTML')."), final with charset '{$this->charset}'");
$markup = $this->isXML
? $this->document->saveXML()
: $this->document->saveHTML();
if ($this->isXHTML) {
self::debug("Fixing XHTML");
$markup = self::markupFixXHTML($markup);
}
self::debug("Markup: ".substr($markup, 0, 250));
return $markup;
}
}
}
protected static function markupFixXHTML($markup) {
$markup = self::expandEmptyTag('script', $markup);
$markup = self::expandEmptyTag('select', $markup);
$markup = self::expandEmptyTag('textarea', $markup);
return $markup;
}
public static function debug($text) {
phpQuery::debug($text);
}
/**
* expandEmptyTag
*
* @param $tag
* @param $xml
* @return unknown_type
* @author mjaque at ilkebenson dot com
* @link http://php.net/manual/en/domdocument.savehtml.php#81256
*/
public static function expandEmptyTag($tag, $xml){
$indice = 0;
while ($indice< strlen($xml)){
$pos = strpos($xml, "<$tag ", $indice);
if ($pos){
$posCierre = strpos($xml, ">", $pos);
if ($xml[$posCierre-1] == "/"){
$xml = substr_replace($xml, "></$tag>", $posCierre-1, 2);
}
$indice = $posCierre;
}
else break;
}
return $xml;
}
}
/**
* Event handling class.
*
* @author Tobiasz Cudnik
* @package phpQuery
* @static
*/
abstract class phpQueryEvents {
/**
* Trigger a type of event on every matched element.
*
* @param DOMNode|phpQueryObject|string $document
* @param unknown_type $type
* @param unknown_type $data
*
* @TODO exclusive events (with !)
* @TODO global events (test)
* @TODO support more than event in $type (space-separated)
*/
public static function trigger($document, $type, $data = array(), $node = null) {
// trigger: function(type, data, elem, donative, extra) {
$documentID = phpQuery::getDocumentID($document);
$namespace = null;
if (strpos($type, '.') !== false)
list($name, $namespace) = explode('.', $type);
else
$name = $type;
if (! $node) {
if (self::issetGlobal($documentID, $type)) {
$pq = phpQuery::getDocument($documentID);
// TODO check add($pq->document)
$pq->find('*')->add($pq->document)
->trigger($type, $data);
}
} else {
if (isset($data[0]) && $data[0] instanceof DOMEvent) {
$event = $data[0];
$event->relatedTarget = $event->target;
$event->target = $node;
$data = array_slice($data, 1);
} else {
$event = new DOMEvent(array(
'type' => $type,
'target' => $node,
'timeStamp' => time(),
));
}
$i = 0;
while($node) {
// TODO whois
phpQuery::debug("Triggering ".($i?"bubbled ":'')."event '{$type}' on "
."node \n");//.phpQueryObject::whois($node)."\n");
$event->currentTarget = $node;
$eventNode = self::getNode($documentID, $node);
if (isset($eventNode->eventHandlers)) {
foreach($eventNode->eventHandlers as $eventType => $handlers) {
$eventNamespace = null;
if (strpos($type, '.') !== false)
list($eventName, $eventNamespace) = explode('.', $eventType);
else
$eventName = $eventType;
if ($name != $eventName)
continue;
if ($namespace && $eventNamespace && $namespace != $eventNamespace)
continue;
foreach($handlers as $handler) {
phpQuery::debug("Calling event handler\n");
$event->data = $handler['data']
? $handler['data']
: null;
$params = array_merge(array($event), $data);
$return = phpQuery::callbackRun($handler['callback'], $params);
if ($return === false) {
$event->bubbles = false;
}
}
}
}
// to bubble or not to bubble...
if (! $event->bubbles)
break;
$node = $node->parentNode;
$i++;
}
}
}
/**
* Binds a handler to one or more events (like click) for each matched element.
* Can also bind custom events.
*
* @param DOMNode|phpQueryObject|string $document
* @param unknown_type $type
* @param unknown_type $data Optional
* @param unknown_type $callback
*
* @TODO support '!' (exclusive) events
* @TODO support more than event in $type (space-separated)
* @TODO support binding to global events
*/
public static function add($document, $node, $type, $data, $callback = null) {
phpQuery::debug("Binding '$type' event");
$documentID = phpQuery::getDocumentID($document);
// if (is_null($callback) && is_callable($data)) {
// $callback = $data;
// $data = null;
// }
$eventNode = self::getNode($documentID, $node);
if (! $eventNode)
$eventNode = self::setNode($documentID, $node);
if (!isset($eventNode->eventHandlers[$type]))
$eventNode->eventHandlers[$type] = array();
$eventNode->eventHandlers[$type][] = array(
'callback' => $callback,
'data' => $data,
);
}
/**
* Enter description here...
*
* @param DOMNode|phpQueryObject|string $document
* @param unknown_type $type
* @param unknown_type $callback
*
* @TODO namespace events
* @TODO support more than event in $type (space-separated)
*/
public static function remove($document, $node, $type = null, $callback = null) {
$documentID = phpQuery::getDocumentID($document);
$eventNode = self::getNode($documentID, $node);
if (is_object($eventNode) && isset($eventNode->eventHandlers[$type])) {
if ($callback) {
foreach($eventNode->eventHandlers[$type] as $k => $handler)
if ($handler['callback'] == $callback)
unset($eventNode->eventHandlers[$type][$k]);
} else {
unset($eventNode->eventHandlers[$type]);
}
}
}
protected static function getNode($documentID, $node) {
foreach(phpQuery::$documents[$documentID]->eventsNodes as $eventNode) {
if ($node->isSameNode($eventNode))
return $eventNode;
}
}
protected static function setNode($documentID, $node) {
phpQuery::$documents[$documentID]->eventsNodes[] = $node;
return phpQuery::$documents[$documentID]->eventsNodes[
count(phpQuery::$documents[$documentID]->eventsNodes)-1
];
}
protected static function issetGlobal($documentID, $type) {
return isset(phpQuery::$documents[$documentID])
? in_array($type, phpQuery::$documents[$documentID]->eventsGlobal)
: false;
}
}
interface ICallbackNamed {
function hasName();
function getName();
}
/**
* Callback class introduces currying-like pattern.
*
* Example:
* function foo($param1, $param2, $param3) {
* var_dump($param1, $param2, $param3);
* }
* $fooCurried = new Callback('foo',
* 'param1 is now statically set',
* new CallbackParam, new CallbackParam
* );
* phpQuery::callbackRun($fooCurried,
* array('param2 value', 'param3 value'
* );
*
* Callback class is supported in all phpQuery methods which accepts callbacks.
*
* @link http://code.google.com/p/phpquery/wiki/Callbacks#Param_Structures
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
*
* @TODO??? return fake forwarding function created via create_function
* @TODO honor paramStructure
*/
class Callback
implements ICallbackNamed {
public $callback = null;
public $params = null;
protected $name;
public function __construct($callback, $param1 = null, $param2 = null,
$param3 = null) {
$params = func_get_args();
$params = array_slice($params, 1);
if ($callback instanceof Callback) {
// TODO implement recurention
} else {
$this->callback = $callback;
$this->params = $params;
}
}
public function getName() {
return 'Callback: '.$this->name;
}
public function hasName() {
return isset($this->name) && $this->name;
}
public function setName($name) {
$this->name = $name;
return $this;
}
// TODO test me
// public function addParams() {
// $params = func_get_args();
// return new Callback($this->callback, $this->params+$params);
// }
}
/**
* Shorthand for new Callback(create_function(...), ...);
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
*/
class CallbackBody extends Callback {
public function __construct($paramList, $code, $param1 = null, $param2 = null,
$param3 = null) {
$params = func_get_args();
$params = array_slice($params, 2);
$this->callback = create_function($paramList, $code);
$this->params = $params;
}
}
/**
* Callback type which on execution returns reference passed during creation.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
*/
class CallbackReturnReference extends Callback
implements ICallbackNamed {
protected $reference;
public function __construct(&$reference, $name = null){
$this->reference =& $reference;
$this->callback = array($this, 'callback');
}
public function callback() {
return $this->reference;
}
public function getName() {
return 'Callback: '.$this->name;
}
public function hasName() {
return isset($this->name) && $this->name;
}
}
/**
* Callback type which on execution returns value passed during creation.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
*/
class CallbackReturnValue extends Callback
implements ICallbackNamed {
protected $value;
protected $name;
public function __construct($value, $name = null){
$this->value =& $value;
$this->name = $name;
$this->callback = array($this, 'callback');
}
public function callback() {
return $this->value;
}
public function __toString() {
return $this->getName();
}
public function getName() {
return 'Callback: '.$this->name;
}
public function hasName() {
return isset($this->name) && $this->name;
}
}
/**
* CallbackParameterToReference can be used when we don't really want a callback,
* only parameter passed to it. CallbackParameterToReference takes first
* parameter's value and passes it to reference.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
*/
class CallbackParameterToReference extends Callback {
/**
* @param $reference
* @TODO implement $paramIndex;
* param index choose which callback param will be passed to reference
*/
public function __construct(&$reference){
$this->callback =& $reference;
}
}
//class CallbackReference extends Callback {
// /**
// *
// * @param $reference
// * @param $paramIndex
// * @todo implement $paramIndex; param index choose which callback param will be passed to reference
// */
// public function __construct(&$reference, $name = null){
// $this->callback =& $reference;
// }
//}
class CallbackParam {}
/**
* Class representing phpQuery objects.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
* @method phpQueryObject clone() clone()
* @method phpQueryObject empty() empty()
* @method phpQueryObject next() next($selector = null)
* @method phpQueryObject prev() prev($selector = null)
* @property Int $length
*/
class phpQueryObject
implements Iterator, Countable, ArrayAccess {
public $documentID = null;
/**
* DOMDocument class.
*
* @var DOMDocument
*/
public $document = null;
public $charset = null;
/**
*
* @var DOMDocumentWrapper
*/
public $documentWrapper = null;
/**
* XPath interface.
*
* @var DOMXPath
*/
public $xpath = null;
/**
* Stack of selected elements.
* @TODO refactor to ->nodes
* @var array
*/
public $elements = array();
/**
* @access private
*/
protected $elementsBackup = array();
/**
* @access private
*/
protected $previous = null;
/**
* @access private
* @TODO deprecate
*/
protected $root = array();
/**
* Indicated if doument is just a fragment (no <html> tag).
*
* Every document is realy a full document, so even documentFragments can
* be queried against <html>, but getDocument(id)->htmlOuter() will return
* only contents of <body>.
*
* @var bool
*/
public $documentFragment = true;
/**
* Iterator interface helper
* @access private
*/
protected $elementsInterator = array();
/**
* Iterator interface helper
* @access private
*/
protected $valid = false;
/**
* Iterator interface helper
* @access private
*/
protected $current = null;
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function __construct($documentID) {
// if ($documentID instanceof self)
// var_dump($documentID->getDocumentID());
$id = $documentID instanceof self
? $documentID->getDocumentID()
: $documentID;
// var_dump($id);
if (! isset(phpQuery::$documents[$id] )) {
// var_dump(phpQuery::$documents);
throw new Exception("Document with ID '{$id}' isn't loaded. Use phpQuery::newDocument(\$html) or phpQuery::newDocumentFile(\$file) first.");
}
$this->documentID = $id;
$this->documentWrapper =& phpQuery::$documents[$id];
$this->document =& $this->documentWrapper->document;
$this->xpath =& $this->documentWrapper->xpath;
$this->charset =& $this->documentWrapper->charset;
$this->documentFragment =& $this->documentWrapper->isDocumentFragment;
// TODO check $this->DOM->documentElement;
// $this->root = $this->document->documentElement;
$this->root =& $this->documentWrapper->root;
// $this->toRoot();
$this->elements = array($this->root);
}
/**
*
* @access private
* @param $attr
* @return unknown_type
*/
public function __get($attr) {
switch($attr) {
// FIXME doesnt work at all ?
case 'length':
return $this->size();
break;
default:
return $this->$attr;
}
}
/**
* Saves actual object to $var by reference.
* Useful when need to break chain.
* @param phpQueryObject $var
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function toReference(&$var) {
return $var = $this;
}
public function documentFragment($state = null) {
if ($state) {
phpQuery::$documents[$this->getDocumentID()]['documentFragment'] = $state;
return $this;
}
return $this->documentFragment;
}
/**
* @access private
* @TODO documentWrapper
*/
protected function isRoot( $node) {
// return $node instanceof DOMDOCUMENT || $node->tagName == 'html';
return $node instanceof DOMDOCUMENT
|| ($node instanceof DOMELEMENT && $node->tagName == 'html')
|| $this->root->isSameNode($node);
}
/**
* @access private
*/
protected function stackIsRoot() {
return $this->size() == 1 && $this->isRoot($this->elements[0]);
}
/**
* Enter description here...
* NON JQUERY METHOD
*
* Watch out, it doesn't creates new instance, can be reverted with end().
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function toRoot() {
$this->elements = array($this->root);
return $this;
// return $this->newInstance(array($this->root));
}
/**
* Saves object's DocumentID to $var by reference.
* <code>
* $myDocumentId;
* phpQuery::newDocument('<div/>')
* ->getDocumentIDRef($myDocumentId)
* ->find('div')->...
* </code>
*
* @param unknown_type $domId
* @see phpQuery::newDocument
* @see phpQuery::newDocumentFile
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function getDocumentIDRef(&$documentID) {
$documentID = $this->getDocumentID();
return $this;
}
/**
* Returns object with stack set to document root.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function getDocument() {
return phpQuery::getDocument($this->getDocumentID());
}
/**
*
* @return DOMDocument
*/
public function getDOMDocument() {
return $this->document;
}
/**
* Get object's Document ID.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function getDocumentID() {
return $this->documentID;
}
/**
* Unloads whole document from memory.
* CAUTION! None further operations will be possible on this document.
* All objects refering to it will be useless.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function unloadDocument() {
phpQuery::unloadDocuments($this->getDocumentID());
}
public function isHTML() {
return $this->documentWrapper->isHTML;
}
public function isXHTML() {
return $this->documentWrapper->isXHTML;
}
public function isXML() {
return $this->documentWrapper->isXML;
}
/**
* Enter description here...
*
* @link http://docs.jquery.com/Ajax/serialize
* @return string
*/
public function serialize() {
return phpQuery::param($this->serializeArray());
}
/**
* Enter description here...
*
* @link http://docs.jquery.com/Ajax/serializeArray
* @return array
*/
public function serializeArray($submit = null) {
$source = $this->filter('form, input, select, textarea')
->find('input, select, textarea')
->andSelf()
->not('form');
$return = array();
// $source->dumpDie();
foreach($source as $input) {
$input = phpQuery::pq($input);
if ($input->is('[disabled]'))
continue;
if (!$input->is('[name]'))
continue;
if ($input->is('[type=checkbox]') && !$input->is('[checked]'))
continue;
// jquery diff
if ($submit && $input->is('[type=submit]')) {
if ($submit instanceof DOMELEMENT && ! $input->elements[0]->isSameNode($submit))
continue;
else if (is_string($submit) && $input->attr('name') != $submit)
continue;
}
$return[] = array(
'name' => $input->attr('name'),
'value' => $input->val(),
);
}
return $return;
}
/**
* @access private
*/
protected function debug($in) {
if (! phpQuery::$debug )
return;
print('<pre>');
print_r($in);
// file debug
// file_put_contents(dirname(__FILE__).'/phpQuery.log', print_r($in, true)."\n", FILE_APPEND);
// quite handy debug trace
// if ( is_array($in))
// print_r(array_slice(debug_backtrace(), 3));
print("</pre>\n");
}
/**
* @access private
*/
protected function isRegexp($pattern) {
return in_array(
$pattern[ mb_strlen($pattern)-1 ],
array('^','*','$')
);
}
/**
* Determines if $char is really a char.
*
* @param string $char
* @return bool
* @todo rewrite me to charcode range ! ;)
* @access private
*/
protected function isChar($char) {
return extension_loaded('mbstring') && phpQuery::$mbstringSupport
? mb_eregi('\w', $char)
: preg_match('@\w@', $char);
}
/**
* @access private
*/
protected function parseSelector($query) {
// clean spaces
// TODO include this inside parsing ?
$query = trim(
preg_replace('@\s+@', ' ',
preg_replace('@\s*(>|\\+|~)\s*@', '\\1', $query)
)
);
$queries = array(array());
if (! $query)
return $queries;
$return =& $queries[0];
$specialChars = array('>',' ');
// $specialCharsMapping = array('/' => '>');
$specialCharsMapping = array();
$strlen = mb_strlen($query);
$classChars = array('.', '-');
$pseudoChars = array('-');
$tagChars = array('*', '|', '-');
// split multibyte string
// http://code.google.com/p/phpquery/issues/detail?id=76
$_query = array();
for ($i=0; $i<$strlen; $i++)
$_query[] = mb_substr($query, $i, 1);
$query = $_query;
// it works, but i dont like it...
$i = 0;
while( $i < $strlen) {
$c = $query[$i];
$tmp = '';
// TAG
if ($this->isChar($c) || in_array($c, $tagChars)) {
while(isset($query[$i])
&& ($this->isChar($query[$i]) || in_array($query[$i], $tagChars))) {
$tmp .= $query[$i];
$i++;
}
$return[] = $tmp;
// IDs
} else if ( $c == '#') {
$i++;
while( isset($query[$i]) && ($this->isChar($query[$i]) || $query[$i] == '-')) {
$tmp .= $query[$i];
$i++;
}
$return[] = '#'.$tmp;
// SPECIAL CHARS
} else if (in_array($c, $specialChars)) {
$return[] = $c;
$i++;
// MAPPED SPECIAL MULTICHARS
// } else if ( $c.$query[$i+1] == '//') {
// $return[] = ' ';
// $i = $i+2;
// MAPPED SPECIAL CHARS
} else if ( isset($specialCharsMapping[$c])) {
$return[] = $specialCharsMapping[$c];
$i++;
// COMMA
} else if ( $c == ',') {
$queries[] = array();
$return =& $queries[ count($queries)-1 ];
$i++;
while( isset($query[$i]) && $query[$i] == ' ')
$i++;
// CLASSES
} else if ($c == '.') {
while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $classChars))) {
$tmp .= $query[$i];
$i++;
}
$return[] = $tmp;
// ~ General Sibling Selector
} else if ($c == '~') {
$spaceAllowed = true;
$tmp .= $query[$i++];
while( isset($query[$i])
&& ($this->isChar($query[$i])
|| in_array($query[$i], $classChars)
|| $query[$i] == '*'
|| ($query[$i] == ' ' && $spaceAllowed)
)) {
if ($query[$i] != ' ')
$spaceAllowed = false;
$tmp .= $query[$i];
$i++;
}
$return[] = $tmp;
// + Adjacent sibling selectors
} else if ($c == '+') {
$spaceAllowed = true;
$tmp .= $query[$i++];
while( isset($query[$i])
&& ($this->isChar($query[$i])
|| in_array($query[$i], $classChars)
|| $query[$i] == '*'
|| ($spaceAllowed && $query[$i] == ' ')
)) {
if ($query[$i] != ' ')
$spaceAllowed = false;
$tmp .= $query[$i];
$i++;
}
$return[] = $tmp;
// ATTRS
} else if ($c == '[') {
$stack = 1;
$tmp .= $c;
while( isset($query[++$i])) {
$tmp .= $query[$i];
if ( $query[$i] == '[') {
$stack++;
} else if ( $query[$i] == ']') {
$stack--;
if (! $stack )
break;
}
}
$return[] = $tmp;
$i++;
// PSEUDO CLASSES
} else if ($c == ':') {
$stack = 1;
$tmp .= $query[$i++];
while( isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $pseudoChars))) {
$tmp .= $query[$i];
$i++;
}
// with arguments ?
if ( isset($query[$i]) && $query[$i] == '(') {
$tmp .= $query[$i];
$stack = 1;
while( isset($query[++$i])) {
$tmp .= $query[$i];
if ( $query[$i] == '(') {
$stack++;
} else if ( $query[$i] == ')') {
$stack--;
if (! $stack )
break;
}
}
$return[] = $tmp;
$i++;
} else {
$return[] = $tmp;
}
} else {
$i++;
}
}
foreach($queries as $k => $q) {
if (isset($q[0])) {
if (isset($q[0][0]) && $q[0][0] == ':')
array_unshift($queries[$k], '*');
if ($q[0] != '>')
array_unshift($queries[$k], ' ');
}
}
return $queries;
}
/**
* Return matched DOM nodes.
*
* @param int $index
* @return array|DOMElement Single DOMElement or array of DOMElement.
*/
public function get($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
$return = isset($index)
? (isset($this->elements[$index]) ? $this->elements[$index] : null)
: $this->elements;
// pass thou callbacks
$args = func_get_args();
$args = array_slice($args, 1);
foreach($args as $callback) {
if (is_array($return))
foreach($return as $k => $v)
$return[$k] = phpQuery::callbackRun($callback, array($v));
else
$return = phpQuery::callbackRun($callback, array($return));
}
return $return;
}
/**
* Return matched DOM nodes.
* jQuery difference.
*
* @param int $index
* @return array|string Returns string if $index != null
* @todo implement callbacks
* @todo return only arrays ?
* @todo maybe other name...
*/
public function getString($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
if ($index)
$return = $this->eq($index)->text();
else {
$return = array();
for($i = 0; $i < $this->size(); $i++) {
$return[] = $this->eq($i)->text();
}
}
// pass thou callbacks
$args = func_get_args();
$args = array_slice($args, 1);
foreach($args as $callback) {
$return = phpQuery::callbackRun($callback, array($return));
}
return $return;
}
/**
* Return matched DOM nodes.
* jQuery difference.
*
* @param int $index
* @return array|string Returns string if $index != null
* @todo implement callbacks
* @todo return only arrays ?
* @todo maybe other name...
*/
public function getStrings($index = null, $callback1 = null, $callback2 = null, $callback3 = null) {
if ($index)
$return = $this->eq($index)->text();
else {
$return = array();
for($i = 0; $i < $this->size(); $i++) {
$return[] = $this->eq($i)->text();
}
// pass thou callbacks
$args = func_get_args();
$args = array_slice($args, 1);
}
foreach($args as $callback) {
if (is_array($return))
foreach($return as $k => $v)
$return[$k] = phpQuery::callbackRun($callback, array($v));
else
$return = phpQuery::callbackRun($callback, array($return));
}
return $return;
}
/**
* Returns new instance of actual class.
*
* @param array $newStack Optional. Will replace old stack with new and move old one to history.c
*/
public function newInstance($newStack = null) {
$class = get_class($this);
// support inheritance by passing old object to overloaded constructor
$new = $class != 'phpQuery'
? new $class($this, $this->getDocumentID())
: new phpQueryObject($this->getDocumentID());
$new->previous = $this;
if (is_null($newStack)) {
$new->elements = $this->elements;
if ($this->elementsBackup)
$this->elements = $this->elementsBackup;
} else if (is_string($newStack)) {
$new->elements = phpQuery::pq($newStack, $this->getDocumentID())->stack();
} else {
$new->elements = $newStack;
}
return $new;
}
/**
* Enter description here...
*
* In the future, when PHP will support XLS 2.0, then we would do that this way:
* contains(tokenize(@class, '\s'), "something")
* @param unknown_type $class
* @param unknown_type $node
* @return boolean
* @access private
*/
protected function matchClasses($class, $node) {
// multi-class
if ( mb_strpos($class, '.', 1)) {
$classes = explode('.', substr($class, 1));
$classesCount = count( $classes );
$nodeClasses = explode(' ', $node->getAttribute('class') );
$nodeClassesCount = count( $nodeClasses );
if ( $classesCount > $nodeClassesCount )
return false;
$diff = count(
array_diff(
$classes,
$nodeClasses
)
);
if (! $diff )
return true;
// single-class
} else {
return in_array(
// strip leading dot from class name
substr($class, 1),
// get classes for element as array
explode(' ', $node->getAttribute('class') )
);
}
}
/**
* @access private
*/
protected function runQuery($XQuery, $selector = null, $compare = null) {
if ($compare && ! method_exists($this, $compare))
return false;
$stack = array();
if (! $this->elements)
$this->debug('Stack empty, skipping...');
// var_dump($this->elements[0]->nodeType);
// element, document
foreach($this->stack(array(1, 9, 13)) as $k => $stackNode) {
$detachAfter = false;
// to work on detached nodes we need temporary place them somewhere
// thats because context xpath queries sucks ;]
$testNode = $stackNode;
while ($testNode) {
if (! $testNode->parentNode && ! $this->isRoot($testNode)) {
$this->root->appendChild($testNode);
$detachAfter = $testNode;
break;
}
$testNode = isset($testNode->parentNode)
? $testNode->parentNode
: null;
}
// XXX tmp ?
$xpath = $this->documentWrapper->isXHTML
? $this->getNodeXpath($stackNode, 'html')
: $this->getNodeXpath($stackNode);
// FIXME pseudoclasses-only query, support XML
$query = $XQuery == '//' && $xpath == '/html[1]'
? '//*'
: $xpath.$XQuery;
$this->debug("XPATH: {$query}");
// run query, get elements
$nodes = $this->xpath->query($query);
$this->debug("QUERY FETCHED");
if (! $nodes->length )
$this->debug('Nothing found');
$debug = array();
foreach($nodes as $node) {
$matched = false;
if ( $compare) {
phpQuery::$debug ?
$this->debug("Found: ".$this->whois( $node ).", comparing with {$compare}()")
: null;
$phpQueryDebug = phpQuery::$debug;
phpQuery::$debug = false;
// TODO ??? use phpQuery::callbackRun()
if (call_user_func_array(array($this, $compare), array($selector, $node)))
$matched = true;
phpQuery::$debug = $phpQueryDebug;
} else {
$matched = true;
}
if ( $matched) {
if (phpQuery::$debug)
$debug[] = $this->whois( $node );
$stack[] = $node;
}
}
if (phpQuery::$debug) {
$this->debug("Matched ".count($debug).": ".implode(', ', $debug));
}
if ($detachAfter)
$this->root->removeChild($detachAfter);
}
$this->elements = $stack;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function find($selectors, $context = null, $noHistory = false) {
if (!$noHistory)
// backup last stack /for end()/
$this->elementsBackup = $this->elements;
// allow to define context
// TODO combine code below with phpQuery::pq() context guessing code
// as generic function
if ($context) {
if (! is_array($context) && $context instanceof DOMELEMENT)
$this->elements = array($context);
else if (is_array($context)) {
$this->elements = array();
foreach ($context as $c)
if ($c instanceof DOMELEMENT)
$this->elements[] = $c;
} else if ( $context instanceof self )
$this->elements = $context->elements;
}
$queries = $this->parseSelector($selectors);
$this->debug(array('FIND', $selectors, $queries));
$XQuery = '';
// remember stack state because of multi-queries
$oldStack = $this->elements;
// here we will be keeping found elements
$stack = array();
foreach($queries as $selector) {
$this->elements = $oldStack;
$delimiterBefore = false;
foreach($selector as $s) {
// TAG
$isTag = extension_loaded('mbstring') && phpQuery::$mbstringSupport
? mb_ereg_match('^[\w|\||-]+$', $s) || $s == '*'
: preg_match('@^[\w|\||-]+$@', $s) || $s == '*';
if ($isTag) {
if ($this->isXML()) {
// namespace support
if (mb_strpos($s, '|') !== false) {
$ns = $tag = null;
list($ns, $tag) = explode('|', $s);
$XQuery .= "$ns:$tag";
} else if ($s == '*') {
$XQuery .= "*";
} else {
$XQuery .= "*[local-name()='$s']";
}
} else {
$XQuery .= $s;
}
// ID
} else if ($s[0] == '#') {
if ($delimiterBefore)
$XQuery .= '*';
$XQuery .= "[@id='".substr($s, 1)."']";
// ATTRIBUTES
} else if ($s[0] == '[') {
if ($delimiterBefore)
$XQuery .= '*';
// strip side brackets
$attr = trim($s, '][');
$execute = false;
// attr with specifed value
if (mb_strpos($s, '=')) {
$value = null;
list($attr, $value) = explode('=', $attr);
$value = trim($value, "'\"");
if ($this->isRegexp($attr)) {
// cut regexp character
$attr = substr($attr, 0, -1);
$execute = true;
$XQuery .= "[@{$attr}]";
} else {
$XQuery .= "[@{$attr}='{$value}']";
}
// attr without specified value
} else {
$XQuery .= "[@{$attr}]";
}
if ($execute) {
$this->runQuery($XQuery, $s, 'is');
$XQuery = '';
if (! $this->length())
break;
}
// CLASSES
} else if ($s[0] == '.') {
// TODO use return $this->find("./self::*[contains(concat(\" \",@class,\" \"), \" $class \")]");
// thx wizDom ;)
if ($delimiterBefore)
$XQuery .= '*';
$XQuery .= '[@class]';
$this->runQuery($XQuery, $s, 'matchClasses');
$XQuery = '';
if (! $this->length() )
break;
// ~ General Sibling Selector
} else if ($s[0] == '~') {
$this->runQuery($XQuery);
$XQuery = '';
$this->elements = $this
->siblings(
substr($s, 1)
)->elements;
if (! $this->length() )
break;
// + Adjacent sibling selectors
} else if ($s[0] == '+') {
// TODO /following-sibling::
$this->runQuery($XQuery);
$XQuery = '';
$subSelector = substr($s, 1);
$subElements = $this->elements;
$this->elements = array();
foreach($subElements as $node) {
// search first DOMElement sibling
$test = $node->nextSibling;
while($test && ! ($test instanceof DOMELEMENT))
$test = $test->nextSibling;
if ($test && $this->is($subSelector, $test))
$this->elements[] = $test;
}
if (! $this->length() )
break;
// PSEUDO CLASSES
} else if ($s[0] == ':') {
// TODO optimization for :first :last
if ($XQuery) {
$this->runQuery($XQuery);
$XQuery = '';
}
if (! $this->length())
break;
$this->pseudoClasses($s);
if (! $this->length())
break;
// DIRECT DESCENDANDS
} else if ($s == '>') {
$XQuery .= '/';
$delimiterBefore = 2;
// ALL DESCENDANDS
} else if ($s == ' ') {
$XQuery .= '//';
$delimiterBefore = 2;
// ERRORS
} else {
phpQuery::debug("Unrecognized token '$s'");
}
$delimiterBefore = $delimiterBefore === 2;
}
// run query if any
if ($XQuery && $XQuery != '//') {
$this->runQuery($XQuery);
$XQuery = '';
}
foreach($this->elements as $node)
if (! $this->elementsContainsNode($node, $stack))
$stack[] = $node;
}
$this->elements = $stack;
return $this->newInstance();
}
/**
* @todo create API for classes with pseudoselectors
* @access private
*/
protected function pseudoClasses($class) {
// TODO clean args parsing ?
$class = ltrim($class, ':');
$haveArgs = mb_strpos($class, '(');
if ($haveArgs !== false) {
$args = substr($class, $haveArgs+1, -1);
$class = substr($class, 0, $haveArgs);
}
switch($class) {
case 'even':
case 'odd':
$stack = array();
foreach($this->elements as $i => $node) {
if ($class == 'even' && ($i%2) == 0)
$stack[] = $node;
else if ( $class == 'odd' && $i % 2 )
$stack[] = $node;
}
$this->elements = $stack;
break;
case 'eq':
$k = intval($args);
$this->elements = isset( $this->elements[$k] )
? array( $this->elements[$k] )
: array();
break;
case 'gt':
$this->elements = array_slice($this->elements, $args+1);
break;
case 'lt':
$this->elements = array_slice($this->elements, 0, $args+1);
break;
case 'first':
if (isset($this->elements[0]))
$this->elements = array($this->elements[0]);
break;
case 'last':
if ($this->elements)
$this->elements = array($this->elements[count($this->elements)-1]);
break;
/*case 'parent':
$stack = array();
foreach($this->elements as $node) {
if ( $node->childNodes->length )
$stack[] = $node;
}
$this->elements = $stack;
break;*/
case 'contains':
$text = trim($args, "\"'");
$stack = array();
foreach($this->elements as $node) {
if (mb_stripos($node->textContent, $text) === false)
continue;
$stack[] = $node;
}
$this->elements = $stack;
break;
case 'not':
$selector = self::unQuote($args);
$this->elements = $this->not($selector)->stack();
break;
case 'slice':
// TODO jQuery difference ?
$args = explode(',',
str_replace(', ', ',', trim($args, "\"'"))
);
$start = $args[0];
$end = isset($args[1])
? $args[1]
: null;
if ($end > 0)
$end = $end-$start;
$this->elements = array_slice($this->elements, $start, $end);
break;
case 'has':
$selector = trim($args, "\"'");
$stack = array();
foreach($this->stack(1) as $el) {
if ($this->find($selector, $el, true)->length)
$stack[] = $el;
}
$this->elements = $stack;
break;
case 'submit':
case 'reset':
$this->elements = phpQuery::merge(
$this->map(array($this, 'is'),
"input[type=$class]", new CallbackParam()
),
$this->map(array($this, 'is'),
"button[type=$class]", new CallbackParam()
)
);
break;
// $stack = array();
// foreach($this->elements as $node)
// if ($node->is('input[type=submit]') || $node->is('button[type=submit]'))
// $stack[] = $el;
// $this->elements = $stack;
case 'input':
$this->elements = $this->map(
array($this, 'is'),
'input', new CallbackParam()
)->elements;
break;
case 'password':
case 'checkbox':
case 'radio':
case 'hidden':
case 'image':
case 'file':
$this->elements = $this->map(
array($this, 'is'),
"input[type=$class]", new CallbackParam()
)->elements;
break;
case 'parent':
$this->elements = $this->map(
create_function('$node', '
return $node instanceof DOMELEMENT && $node->childNodes->length
? $node : null;')
)->elements;
break;
case 'empty':
$this->elements = $this->map(
create_function('$node', '
return $node instanceof DOMELEMENT && $node->childNodes->length
? null : $node;')
)->elements;
break;
case 'disabled':
case 'selected':
case 'checked':
$this->elements = $this->map(
array($this, 'is'),
"[$class]", new CallbackParam()
)->elements;
break;
case 'enabled':
$this->elements = $this->map(
create_function('$node', '
return pq($node)->not(":disabled") ? $node : null;')
)->elements;
break;
case 'header':
$this->elements = $this->map(
create_function('$node',
'$isHeader = isset($node->tagName) && in_array($node->tagName, array(
"h1", "h2", "h3", "h4", "h5", "h6", "h7"
));
return $isHeader
? $node
: null;')
)->elements;
// $this->elements = $this->map(
// create_function('$node', '$node = pq($node);
// return $node->is("h1")
// || $node->is("h2")
// || $node->is("h3")
// || $node->is("h4")
// || $node->is("h5")
// || $node->is("h6")
// || $node->is("h7")
// ? $node
// : null;')
// )->elements;
break;
case 'only-child':
$this->elements = $this->map(
create_function('$node',
'return pq($node)->siblings()->size() == 0 ? $node : null;')
)->elements;
break;
case 'first-child':
$this->elements = $this->map(
create_function('$node', 'return pq($node)->prevAll()->size() == 0 ? $node : null;')
)->elements;
break;
case 'last-child':
$this->elements = $this->map(
create_function('$node', 'return pq($node)->nextAll()->size() == 0 ? $node : null;')
)->elements;
break;
case 'nth-child':
$param = trim($args, "\"'");
if (! $param)
break;
// nth-child(n+b) to nth-child(1n+b)
if ($param[0] == 'n')
$param = '1'.$param;
// :nth-child(index/even/odd/equation)
if ($param == 'even' || $param == 'odd')
$mapped = $this->map(
create_function('$node, $param',
'$index = pq($node)->prevAll()->size()+1;
if ($param == "even" && ($index%2) == 0)
return $node;
else if ($param == "odd" && $index%2 == 1)
return $node;
else
return null;'),
new CallbackParam(), $param
);
else if (mb_strlen($param) > 1 && $param[1] == 'n')
// an+b
$mapped = $this->map(
create_function('$node, $param',
'$prevs = pq($node)->prevAll()->size();
$index = 1+$prevs;
$b = mb_strlen($param) > 3
? $param{3}
: 0;
$a = $param{0};
if ($b && $param{2} == "-")
$b = -$b;
if ($a > 0) {
return ($index-$b)%$a == 0
? $node
: null;
phpQuery::debug($a."*".floor($index/$a)."+$b-1 == ".($a*floor($index/$a)+$b-1)." ?= $prevs");
return $a*floor($index/$a)+$b-1 == $prevs
? $node
: null;
} else if ($a == 0)
return $index == $b
? $node
: null;
else
// negative value
return $index <= $b
? $node
: null;
// if (! $b)
// return $index%$a == 0
// ? $node
// : null;
// else
// return ($index-$b)%$a == 0
// ? $node
// : null;
'),
new CallbackParam(), $param
);
else
// index
$mapped = $this->map(
create_function('$node, $index',
'$prevs = pq($node)->prevAll()->size();
if ($prevs && $prevs == $index-1)
return $node;
else if (! $prevs && $index == 1)
return $node;
else
return null;'),
new CallbackParam(), $param
);
$this->elements = $mapped->elements;
break;
default:
$this->debug("Unknown pseudoclass '{$class}', skipping...");
}
}
/**
* @access private
*/
protected function __pseudoClassParam($paramsString) {
// TODO;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function is($selector, $nodes = null) {
phpQuery::debug(array("Is:", $selector));
if (! $selector)
return false;
$oldStack = $this->elements;
$returnArray = false;
if ($nodes && is_array($nodes)) {
$this->elements = $nodes;
} else if ($nodes)
$this->elements = array($nodes);
$this->filter($selector, true);
$stack = $this->elements;
$this->elements = $oldStack;
if ($nodes)
return $stack ? $stack : null;
return (bool)count($stack);
}
/**
* Enter description here...
* jQuery difference.
*
* Callback:
* - $index int
* - $node DOMNode
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @link http://docs.jquery.com/Traversing/filter
*/
public function filterCallback($callback, $_skipHistory = false) {
if (! $_skipHistory) {
$this->elementsBackup = $this->elements;
$this->debug("Filtering by callback");
}
$newStack = array();
foreach($this->elements as $index => $node) {
$result = phpQuery::callbackRun($callback, array($index, $node));
if (is_null($result) || (! is_null($result) && $result))
$newStack[] = $node;
}
$this->elements = $newStack;
return $_skipHistory
? $this
: $this->newInstance();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @link http://docs.jquery.com/Traversing/filter
*/
public function filter($selectors, $_skipHistory = false) {
if ($selectors instanceof Callback OR $selectors instanceof Closure)
return $this->filterCallback($selectors, $_skipHistory);
if (! $_skipHistory)
$this->elementsBackup = $this->elements;
$notSimpleSelector = array(' ', '>', '~', '+', '/');
if (! is_array($selectors))
$selectors = $this->parseSelector($selectors);
if (! $_skipHistory)
$this->debug(array("Filtering:", $selectors));
$finalStack = array();
foreach($selectors as $selector) {
$stack = array();
if (! $selector)
break;
// avoid first space or /
if (in_array($selector[0], $notSimpleSelector))
$selector = array_slice($selector, 1);
// PER NODE selector chunks
foreach($this->stack() as $node) {
$break = false;
foreach($selector as $s) {
if (!($node instanceof DOMELEMENT)) {
// all besides DOMElement
if ( $s[0] == '[') {
$attr = trim($s, '[]');
if ( mb_strpos($attr, '=')) {
list( $attr, $val ) = explode('=', $attr);
if ($attr == 'nodeType' && $node->nodeType != $val)
$break = true;
}
} else
$break = true;
} else {
// DOMElement only
// ID
if ( $s[0] == '#') {
if ( $node->getAttribute('id') != substr($s, 1) )
$break = true;
// CLASSES
} else if ( $s[0] == '.') {
if (! $this->matchClasses( $s, $node ) )
$break = true;
// ATTRS
} else if ( $s[0] == '[') {
// strip side brackets
$attr = trim($s, '[]');
if (mb_strpos($attr, '=')) {
list($attr, $val) = explode('=', $attr);
$val = self::unQuote($val);
if ($attr == 'nodeType') {
if ($val != $node->nodeType)
$break = true;
} else if ($this->isRegexp($attr)) {
$val = extension_loaded('mbstring') && phpQuery::$mbstringSupport
? quotemeta(trim($val, '"\''))
: preg_quote(trim($val, '"\''), '@');
// switch last character
switch( substr($attr, -1)) {
// quotemeta used insted of preg_quote
// http://code.google.com/p/phpquery/issues/detail?id=76
case '^':
$pattern = '^'.$val;
break;
case '*':
$pattern = '.*'.$val.'.*';
break;
case '$':
$pattern = '.*'.$val.'$';
break;
}
// cut last character
$attr = substr($attr, 0, -1);
$isMatch = extension_loaded('mbstring') && phpQuery::$mbstringSupport
? mb_ereg_match($pattern, $node->getAttribute($attr))
: preg_match("@{$pattern}@", $node->getAttribute($attr));
if (! $isMatch)
$break = true;
} else if ($node->getAttribute($attr) != $val)
$break = true;
} else if (! $node->hasAttribute($attr))
$break = true;
// PSEUDO CLASSES
} else if ( $s[0] == ':') {
// skip
// TAG
} else if (trim($s)) {
if ($s != '*') {
// TODO namespaces
if (isset($node->tagName)) {
if ($node->tagName != $s)
$break = true;
} else if ($s == 'html' && ! $this->isRoot($node))
$break = true;
}
// AVOID NON-SIMPLE SELECTORS
} else if (in_array($s, $notSimpleSelector)) {
$break = true;
$this->debug(array('Skipping non simple selector', $selector));
}
}
if ($break)
break;
}
// if element passed all chunks of selector - add it to new stack
if (! $break )
$stack[] = $node;
}
$tmpStack = $this->elements;
$this->elements = $stack;
// PER ALL NODES selector chunks
foreach($selector as $s)
// PSEUDO CLASSES
if ($s[0] == ':')
$this->pseudoClasses($s);
foreach($this->elements as $node)
// XXX it should be merged without duplicates
// but jQuery doesnt do that
$finalStack[] = $node;
$this->elements = $tmpStack;
}
$this->elements = $finalStack;
if ($_skipHistory) {
return $this;
} else {
$this->debug("Stack length after filter(): ".count($finalStack));
return $this->newInstance();
}
}
/**
*
* @param $value
* @return unknown_type
* @TODO implement in all methods using passed parameters
*/
protected static function unQuote($value) {
return $value[0] == '\'' || $value[0] == '"'
? substr($value, 1, -1)
: $value;
}
/**
* Enter description here...
*
* @link http://docs.jquery.com/Ajax/load
* @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo Support $selector
*/
public function load($url, $data = null, $callback = null) {
if ($data && ! is_array($data)) {
$callback = $data;
$data = null;
}
if (mb_strpos($url, ' ') !== false) {
$matches = null;
if (extension_loaded('mbstring') && phpQuery::$mbstringSupport)
mb_ereg('^([^ ]+) (.*)$', $url, $matches);
else
preg_match('^([^ ]+) (.*)$', $url, $matches);
$url = $matches[1];
$selector = $matches[2];
// FIXME this sucks, pass as callback param
$this->_loadSelector = $selector;
}
$ajax = array(
'url' => $url,
'type' => $data ? 'POST' : 'GET',
'data' => $data,
'complete' => $callback,
'success' => array($this, '__loadSuccess')
);
phpQuery::ajax($ajax);
return $this;
}
/**
* @access private
* @param $html
* @return unknown_type
*/
public function __loadSuccess($html) {
if ($this->_loadSelector) {
$html = phpQuery::newDocument($html)->find($this->_loadSelector);
unset($this->_loadSelector);
}
foreach($this->stack(1) as $node) {
phpQuery::pq($node, $this->getDocumentID())
->markup($html);
}
}
/**
* Enter description here...
*
* @return phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo
*/
public function css() {
// TODO
return $this;
}
/**
* @todo
*
*/
public function show(){
// TODO
return $this;
}
/**
* @todo
*
*/
public function hide(){
// TODO
return $this;
}
/**
* Trigger a type of event on every matched element.
*
* @param unknown_type $type
* @param unknown_type $data
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @TODO support more than event in $type (space-separated)
*/
public function trigger($type, $data = array()) {
foreach($this->elements as $node)
phpQueryEvents::trigger($this->getDocumentID(), $type, $data, $node);
return $this;
}
/**
* This particular method triggers all bound event handlers on an element (for a specific event type) WITHOUT executing the browsers default actions.
*
* @param unknown_type $type
* @param unknown_type $data
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @TODO
*/
public function triggerHandler($type, $data = array()) {
// TODO;
}
/**
* Binds a handler to one or more events (like click) for each matched element.
* Can also bind custom events.
*
* @param unknown_type $type
* @param unknown_type $data Optional
* @param unknown_type $callback
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @TODO support '!' (exclusive) events
* @TODO support more than event in $type (space-separated)
*/
public function bind($type, $data, $callback = null) {
// TODO check if $data is callable, not using is_callable
if (! isset($callback)) {
$callback = $data;
$data = null;
}
foreach($this->elements as $node)
phpQueryEvents::add($this->getDocumentID(), $node, $type, $data, $callback);
return $this;
}
/**
* Enter description here...
*
* @param unknown_type $type
* @param unknown_type $callback
* @return unknown
* @TODO namespace events
* @TODO support more than event in $type (space-separated)
*/
public function unbind($type = null, $callback = null) {
foreach($this->elements as $node)
phpQueryEvents::remove($this->getDocumentID(), $node, $type, $callback);
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function change($callback = null) {
if ($callback)
return $this->bind('change', $callback);
return $this->trigger('change');
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function submit($callback = null) {
if ($callback)
return $this->bind('submit', $callback);
return $this->trigger('submit');
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function click($callback = null) {
if ($callback)
return $this->bind('click', $callback);
return $this->trigger('click');
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapAllOld($wrapper) {
$wrapper = pq($wrapper)->_clone();
if (! $wrapper->length() || ! $this->length() )
return $this;
$wrapper->insertBefore($this->elements[0]);
$deepest = $wrapper->elements[0];
while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
$deepest = $deepest->firstChild;
pq($deepest)->append($this);
return $this;
}
/**
* Enter description here...
*
* TODO testme...
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapAll($wrapper) {
if (! $this->length())
return $this;
return phpQuery::pq($wrapper, $this->getDocumentID())
->clone()
->insertBefore($this->get(0))
->map(array($this, '___wrapAllCallback'))
->append($this);
}
/**
*
* @param $node
* @return unknown_type
* @access private
*/
public function ___wrapAllCallback($node) {
$deepest = $node;
while($deepest->firstChild && $deepest->firstChild instanceof DOMELEMENT)
$deepest = $deepest->firstChild;
return $deepest;
}
/**
* Enter description here...
* NON JQUERY METHOD
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapAllPHP($codeBefore, $codeAfter) {
return $this
->slice(0, 1)
->beforePHP($codeBefore)
->end()
->slice(-1)
->afterPHP($codeAfter)
->end();
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrap($wrapper) {
foreach($this->stack() as $node)
phpQuery::pq($node, $this->getDocumentID())->wrapAll($wrapper);
return $this;
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapPHP($codeBefore, $codeAfter) {
foreach($this->stack() as $node)
phpQuery::pq($node, $this->getDocumentID())->wrapAllPHP($codeBefore, $codeAfter);
return $this;
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapInner($wrapper) {
foreach($this->stack() as $node)
phpQuery::pq($node, $this->getDocumentID())->contents()->wrapAll($wrapper);
return $this;
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function wrapInnerPHP($codeBefore, $codeAfter) {
foreach($this->stack(1) as $node)
phpQuery::pq($node, $this->getDocumentID())->contents()
->wrapAllPHP($codeBefore, $codeAfter);
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @testme Support for text nodes
*/
public function contents() {
$stack = array();
foreach($this->stack(1) as $el) {
// FIXME (fixed) http://code.google.com/p/phpquery/issues/detail?id=56
// if (! isset($el->childNodes))
// continue;
foreach($el->childNodes as $node) {
$stack[] = $node;
}
}
return $this->newInstance($stack);
}
/**
* Enter description here...
*
* jQuery difference.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function contentsUnwrap() {
foreach($this->stack(1) as $node) {
if (! $node->parentNode )
continue;
$childNodes = array();
// any modification in DOM tree breaks childNodes iteration, so cache them first
foreach($node->childNodes as $chNode )
$childNodes[] = $chNode;
foreach($childNodes as $chNode )
// $node->parentNode->appendChild($chNode);
$node->parentNode->insertBefore($chNode, $node);
$node->parentNode->removeChild($node);
}
return $this;
}
/**
* Enter description here...
*
* jQuery difference.
*/
public function switchWith($markup) {
$markup = pq($markup, $this->getDocumentID());
$content = null;
foreach($this->stack(1) as $node) {
pq($node)
->contents()->toReference($content)->end()
->replaceWith($markup->clone()->append($content));
}
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function eq($num) {
$oldStack = $this->elements;
$this->elementsBackup = $this->elements;
$this->elements = array();
if ( isset($oldStack[$num]) )
$this->elements[] = $oldStack[$num];
return $this->newInstance();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function size() {
return count($this->elements);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @deprecated Use length as attribute
*/
public function length() {
return $this->size();
}
public function count() {
return $this->size();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo $level
*/
public function end($level = 1) {
// $this->elements = array_pop( $this->history );
// return $this;
// $this->previous->DOM = $this->DOM;
// $this->previous->XPath = $this->XPath;
return $this->previous
? $this->previous
: $this;
}
/**
* Enter description here...
* Normal use ->clone() .
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @access private
*/
public function _clone() {
$newStack = array();
//pr(array('copy... ', $this->whois()));
//$this->dumpHistory('copy');
$this->elementsBackup = $this->elements;
foreach($this->elements as $node) {
$newStack[] = $node->cloneNode(true);
}
$this->elements = $newStack;
return $this->newInstance();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function replaceWithPHP($code) {
return $this->replaceWith(phpQuery::php($code));
}
/**
* Enter description here...
*
* @param String|phpQuery $content
* @link http://docs.jquery.com/Manipulation/replaceWith#content
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function replaceWith($content) {
return $this->after($content)->remove();
}
/**
* Enter description here...
*
* @param String $selector
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo this works ?
*/
public function replaceAll($selector) {
foreach(phpQuery::pq($selector, $this->getDocumentID()) as $node)
phpQuery::pq($node, $this->getDocumentID())
->after($this->_clone())
->remove();
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function remove($selector = null) {
$loop = $selector
? $this->filter($selector)->elements
: $this->elements;
foreach($loop as $node) {
if (! $node->parentNode )
continue;
if (isset($node->tagName))
$this->debug("Removing '{$node->tagName}'");
$node->parentNode->removeChild($node);
// Mutation event
$event = new DOMEvent(array(
'target' => $node,
'type' => 'DOMNodeRemoved'
));
phpQueryEvents::trigger($this->getDocumentID(),
$event->type, array($event), $node
);
}
return $this;
}
protected function markupEvents($newMarkup, $oldMarkup, $node) {
if ($node->tagName == 'textarea' && $newMarkup != $oldMarkup) {
$event = new DOMEvent(array(
'target' => $node,
'type' => 'change'
));
phpQueryEvents::trigger($this->getDocumentID(),
$event->type, array($event), $node
);
}
}
/**
* jQuey difference
*
* @param $markup
* @return unknown_type
* @TODO trigger change event for textarea
*/
public function markup($markup = null, $callback1 = null, $callback2 = null, $callback3 = null) {
$args = func_get_args();
if ($this->documentWrapper->isXML)
return call_user_func_array(array($this, 'xml'), $args);
else
return call_user_func_array(array($this, 'html'), $args);
}
/**
* jQuey difference
*
* @param $markup
* @return unknown_type
*/
public function markupOuter($callback1 = null, $callback2 = null, $callback3 = null) {
$args = func_get_args();
if ($this->documentWrapper->isXML)
return call_user_func_array(array($this, 'xmlOuter'), $args);
else
return call_user_func_array(array($this, 'htmlOuter'), $args);
}
/**
* Enter description here...
*
* @param unknown_type $html
* @return string|phpQuery|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @TODO force html result
*/
public function html($html = null, $callback1 = null, $callback2 = null, $callback3 = null) {
if (isset($html)) {
// INSERT
$nodes = $this->documentWrapper->import($html);
$this->empty();
foreach($this->stack(1) as $alreadyAdded => $node) {
// for now, limit events for textarea
if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
$oldHtml = pq($node, $this->getDocumentID())->markup();
foreach($nodes as $newNode) {
$node->appendChild($alreadyAdded
? $newNode->cloneNode(true)
: $newNode
);
}
// for now, limit events for textarea
if (($this->isXHTML() || $this->isHTML()) && $node->tagName == 'textarea')
$this->markupEvents($html, $oldHtml, $node);
}
return $this;
} else {
// FETCH
$return = $this->documentWrapper->markup($this->elements, true);
$args = func_get_args();
foreach(array_slice($args, 1) as $callback) {
$return = phpQuery::callbackRun($callback, array($return));
}
return $return;
}
}
/**
* @TODO force xml result
*/
public function xml($xml = null, $callback1 = null, $callback2 = null, $callback3 = null) {
$args = func_get_args();
return call_user_func_array(array($this, 'html'), $args);
}
/**
* Enter description here...
* @TODO force html result
*
* @return String
*/
public function htmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
$markup = $this->documentWrapper->markup($this->elements);
// pass thou callbacks
$args = func_get_args();
foreach($args as $callback) {
$markup = phpQuery::callbackRun($callback, array($markup));
}
return $markup;
}
/**
* @TODO force xml result
*/
public function xmlOuter($callback1 = null, $callback2 = null, $callback3 = null) {
$args = func_get_args();
return call_user_func_array(array($this, 'htmlOuter'), $args);
}
public function __toString() {
return $this->markupOuter();
}
/**
* Just like html(), but returns markup with VALID (dangerous) PHP tags.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo support returning markup with PHP tags when called without param
*/
public function php($code = null) {
return $this->markupPHP($code);
}
/**
* Enter description here...
*
* @param $code
* @return unknown_type
*/
public function markupPHP($code = null) {
return isset($code)
? $this->markup(phpQuery::php($code))
: phpQuery::markupToPHP($this->markup());
}
/**
* Enter description here...
*
* @param $code
* @return unknown_type
*/
public function markupOuterPHP() {
return phpQuery::markupToPHP($this->markupOuter());
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function children($selector = null) {
$stack = array();
foreach($this->stack(1) as $node) {
// foreach($node->getElementsByTagName('*') as $newNode) {
foreach($node->childNodes as $newNode) {
if ($newNode->nodeType != 1)
continue;
if ($selector && ! $this->is($selector, $newNode))
continue;
if ($this->elementsContainsNode($newNode, $stack))
continue;
$stack[] = $newNode;
}
}
$this->elementsBackup = $this->elements;
$this->elements = $stack;
return $this->newInstance();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function ancestors($selector = null) {
return $this->children( $selector );
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function append( $content) {
return $this->insert($content, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function appendPHP( $content) {
return $this->insert("<php><!-- {$content} --></php>", 'append');
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function appendTo( $seletor) {
return $this->insert($seletor, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function prepend( $content) {
return $this->insert($content, __FUNCTION__);
}
/**
* Enter description here...
*
* @todo accept many arguments, which are joined, arrays maybe also
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function prependPHP( $content) {
return $this->insert("<php><!-- {$content} --></php>", 'prepend');
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function prependTo( $seletor) {
return $this->insert($seletor, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function before($content) {
return $this->insert($content, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function beforePHP( $content) {
return $this->insert("<php><!-- {$content} --></php>", 'before');
}
/**
* Enter description here...
*
* @param String|phpQuery
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function insertBefore( $seletor) {
return $this->insert($seletor, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function after( $content) {
return $this->insert($content, __FUNCTION__);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function afterPHP( $content) {
return $this->insert("<php><!-- {$content} --></php>", 'after');
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function insertAfter( $seletor) {
return $this->insert($seletor, __FUNCTION__);
}
/**
* Internal insert method. Don't use it.
*
* @param unknown_type $target
* @param unknown_type $type
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @access private
*/
public function insert($target, $type) {
$this->debug("Inserting data with '{$type}'");
$to = false;
switch( $type) {
case 'appendTo':
case 'prependTo':
case 'insertBefore':
case 'insertAfter':
$to = true;
}
switch(gettype($target)) {
case 'string':
$insertFrom = $insertTo = array();
if ($to) {
// INSERT TO
$insertFrom = $this->elements;
if (phpQuery::isMarkup($target)) {
// $target is new markup, import it
$insertTo = $this->documentWrapper->import($target);
// insert into selected element
} else {
// $tagret is a selector
$thisStack = $this->elements;
$this->toRoot();
$insertTo = $this->find($target)->elements;
$this->elements = $thisStack;
}
} else {
// INSERT FROM
$insertTo = $this->elements;
$insertFrom = $this->documentWrapper->import($target);
}
break;
case 'object':
$insertFrom = $insertTo = array();
// phpQuery
if ($target instanceof self) {
if ($to) {
$insertTo = $target->elements;
if ($this->documentFragment && $this->stackIsRoot())
// get all body children
// $loop = $this->find('body > *')->elements;
// TODO test it, test it hard...
// $loop = $this->newInstance($this->root)->find('> *')->elements;
$loop = $this->root->childNodes;
else
$loop = $this->elements;
// import nodes if needed
$insertFrom = $this->getDocumentID() == $target->getDocumentID()
? $loop
: $target->documentWrapper->import($loop);
} else {
$insertTo = $this->elements;
if ( $target->documentFragment && $target->stackIsRoot() )
// get all body children
// $loop = $target->find('body > *')->elements;
$loop = $target->root->childNodes;
else
$loop = $target->elements;
// import nodes if needed
$insertFrom = $this->getDocumentID() == $target->getDocumentID()
? $loop
: $this->documentWrapper->import($loop);
}
// DOMNODE
} elseif ($target instanceof DOMNODE) {
// import node if needed
// if ( $target->ownerDocument != $this->DOM )
// $target = $this->DOM->importNode($target, true);
if ( $to) {
$insertTo = array($target);
if ($this->documentFragment && $this->stackIsRoot())
// get all body children
$loop = $this->root->childNodes;
// $loop = $this->find('body > *')->elements;
else
$loop = $this->elements;
foreach($loop as $fromNode)
// import nodes if needed
$insertFrom[] = ! $fromNode->ownerDocument->isSameNode($target->ownerDocument)
? $target->ownerDocument->importNode($fromNode, true)
: $fromNode;
} else {
// import node if needed
if (! $target->ownerDocument->isSameNode($this->document))
$target = $this->document->importNode($target, true);
$insertTo = $this->elements;
$insertFrom[] = $target;
}
}
break;
}
phpQuery::debug("From ".count($insertFrom)."; To ".count($insertTo)." nodes");
foreach($insertTo as $insertNumber => $toNode) {
// we need static relative elements in some cases
switch( $type) {
case 'prependTo':
case 'prepend':
$firstChild = $toNode->firstChild;
break;
case 'insertAfter':
case 'after':
$nextSibling = $toNode->nextSibling;
break;
}
foreach($insertFrom as $fromNode) {
// clone if inserted already before
$insert = $insertNumber
? $fromNode->cloneNode(true)
: $fromNode;
switch($type) {
case 'appendTo':
case 'append':
// $toNode->insertBefore(
// $fromNode,
// $toNode->lastChild->nextSibling
// );
$toNode->appendChild($insert);
$eventTarget = $insert;
break;
case 'prependTo':
case 'prepend':
$toNode->insertBefore(
$insert,
$firstChild
);
break;
case 'insertBefore':
case 'before':
if (! $toNode->parentNode)
throw new Exception("No parentNode, can't do {$type}()");
else
$toNode->parentNode->insertBefore(
$insert,
$toNode
);
break;
case 'insertAfter':
case 'after':
if (! $toNode->parentNode)
throw new Exception("No parentNode, can't do {$type}()");
else
$toNode->parentNode->insertBefore(
$insert,
$nextSibling
);
break;
}
// Mutation event
$event = new DOMEvent(array(
'target' => $insert,
'type' => 'DOMNodeInserted'
));
phpQueryEvents::trigger($this->getDocumentID(),
$event->type, array($event), $insert
);
}
}
return $this;
}
/**
* Enter description here...
*
* @return Int
*/
public function index($subject) {
$index = -1;
$subject = $subject instanceof phpQueryObject
? $subject->elements[0]
: $subject;
foreach($this->newInstance() as $k => $node) {
if ($node->isSameNode($subject))
$index = $k;
}
return $index;
}
/**
* Enter description here...
*
* @param unknown_type $start
* @param unknown_type $end
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @testme
*/
public function slice($start, $end = null) {
// $last = count($this->elements)-1;
// $end = $end
// ? min($end, $last)
// : $last;
// if ($start < 0)
// $start = $last+$start;
// if ($start > $last)
// return array();
if ($end > 0)
$end = $end-$start;
return $this->newInstance(
array_slice($this->elements, $start, $end)
);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function reverse() {
$this->elementsBackup = $this->elements;
$this->elements = array_reverse($this->elements);
return $this->newInstance();
}
/**
* Return joined text content.
* @return String
*/
public function text($text = null, $callback1 = null, $callback2 = null, $callback3 = null) {
if (isset($text))
return $this->html(htmlspecialchars($text));
$args = func_get_args();
$args = array_slice($args, 1);
$return = '';
foreach($this->elements as $node) {
$text = $node->textContent;
if (count($this->elements) > 1 && $text)
$text .= "\n";
foreach($args as $callback) {
$text = phpQuery::callbackRun($callback, array($text));
}
$return .= $text;
}
return $return;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function plugin($class, $file = null) {
phpQuery::plugin($class, $file);
return $this;
}
/**
* Deprecated, use $pq->plugin() instead.
*
* @deprecated
* @param $class
* @param $file
* @return unknown_type
*/
public static function extend($class, $file = null) {
return $this->plugin($class, $file);
}
/**
*
* @access private
* @param $method
* @param $args
* @return unknown_type
*/
public function __call($method, $args) {
$aliasMethods = array('clone', 'empty');
if (isset(phpQuery::$extendMethods[$method])) {
array_unshift($args, $this);
return phpQuery::callbackRun(
phpQuery::$extendMethods[$method], $args
);
} else if (isset(phpQuery::$pluginsMethods[$method])) {
array_unshift($args, $this);
$class = phpQuery::$pluginsMethods[$method];
$realClass = "phpQueryObjectPlugin_$class";
$return = call_user_func_array(
array($realClass, $method),
$args
);
// XXX deprecate ?
return is_null($return)
? $this
: $return;
} else if (in_array($method, $aliasMethods)) {
return call_user_func_array(array($this, '_'.$method), $args);
} else
throw new Exception("Method '{$method}' doesnt exist");
}
/**
* Safe rename of next().
*
* Use it ONLY when need to call next() on an iterated object (in same time).
* Normaly there is no need to do such thing ;)
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @access private
*/
public function _next($selector = null) {
return $this->newInstance(
$this->getElementSiblings('nextSibling', $selector, true)
);
}
/**
* Use prev() and next().
*
* @deprecated
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @access private
*/
public function _prev($selector = null) {
return $this->prev($selector);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function prev($selector = null) {
return $this->newInstance(
$this->getElementSiblings('previousSibling', $selector, true)
);
}
/**
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo
*/
public function prevAll($selector = null) {
return $this->newInstance(
$this->getElementSiblings('previousSibling', $selector)
);
}
/**
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo FIXME: returns source elements insted of next siblings
*/
public function nextAll($selector = null) {
return $this->newInstance(
$this->getElementSiblings('nextSibling', $selector)
);
}
/**
* @access private
*/
protected function getElementSiblings($direction, $selector = null, $limitToOne = false) {
$stack = array();
$count = 0;
foreach($this->stack() as $node) {
$test = $node;
while( isset($test->{$direction}) && $test->{$direction}) {
$test = $test->{$direction};
if (! $test instanceof DOMELEMENT)
continue;
$stack[] = $test;
if ($limitToOne)
break;
}
}
if ($selector) {
$stackOld = $this->elements;
$this->elements = $stack;
$stack = $this->filter($selector, true)->stack();
$this->elements = $stackOld;
}
return $stack;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function siblings($selector = null) {
$stack = array();
$siblings = array_merge(
$this->getElementSiblings('previousSibling', $selector),
$this->getElementSiblings('nextSibling', $selector)
);
foreach($siblings as $node) {
if (! $this->elementsContainsNode($node, $stack))
$stack[] = $node;
}
return $this->newInstance($stack);
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function not($selector = null) {
if (is_string($selector))
phpQuery::debug(array('not', $selector));
else
phpQuery::debug('not');
$stack = array();
if ($selector instanceof self || $selector instanceof DOMNODE) {
foreach($this->stack() as $node) {
if ($selector instanceof self) {
$matchFound = false;
foreach($selector->stack() as $notNode) {
if ($notNode->isSameNode($node))
$matchFound = true;
}
if (! $matchFound)
$stack[] = $node;
} else if ($selector instanceof DOMNODE) {
if (! $selector->isSameNode($node))
$stack[] = $node;
} else {
if (! $this->is($selector))
$stack[] = $node;
}
}
} else {
$orgStack = $this->stack();
$matched = $this->filter($selector, true)->stack();
// $matched = array();
// // simulate OR in filter() instead of AND 5y
// foreach($this->parseSelector($selector) as $s) {
// $matched = array_merge($matched,
// $this->filter(array($s))->stack()
// );
// }
foreach($orgStack as $node)
if (! $this->elementsContainsNode($node, $matched))
$stack[] = $node;
}
return $this->newInstance($stack);
}
/**
* Enter description here...
*
* @param string|phpQueryObject
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function add($selector = null) {
if (! $selector)
return $this;
$stack = array();
$this->elementsBackup = $this->elements;
$found = phpQuery::pq($selector, $this->getDocumentID());
$this->merge($found->elements);
return $this->newInstance();
}
/**
* @access private
*/
protected function merge() {
foreach(func_get_args() as $nodes)
foreach($nodes as $newNode )
if (! $this->elementsContainsNode($newNode) )
$this->elements[] = $newNode;
}
/**
* @access private
* TODO refactor to stackContainsNode
*/
protected function elementsContainsNode($nodeToCheck, $elementsStack = null) {
$loop = ! is_null($elementsStack)
? $elementsStack
: $this->elements;
foreach($loop as $node) {
if ( $node->isSameNode( $nodeToCheck ) )
return true;
}
return false;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function parent($selector = null) {
$stack = array();
foreach($this->elements as $node )
if ( $node->parentNode && ! $this->elementsContainsNode($node->parentNode, $stack) )
$stack[] = $node->parentNode;
$this->elementsBackup = $this->elements;
$this->elements = $stack;
if ( $selector )
$this->filter($selector, true);
return $this->newInstance();
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function parents($selector = null) {
$stack = array();
if (! $this->elements )
$this->debug('parents() - stack empty');
foreach($this->elements as $node) {
$test = $node;
while( $test->parentNode) {
$test = $test->parentNode;
if ($this->isRoot($test))
break;
if (! $this->elementsContainsNode($test, $stack)) {
$stack[] = $test;
continue;
}
}
}
$this->elementsBackup = $this->elements;
$this->elements = $stack;
if ( $selector )
$this->filter($selector, true);
return $this->newInstance();
}
/**
* Internal stack iterator.
*
* @access private
*/
public function stack($nodeTypes = null) {
if (!isset($nodeTypes))
return $this->elements;
if (!is_array($nodeTypes))
$nodeTypes = array($nodeTypes);
$return = array();
foreach($this->elements as $node) {
if (in_array($node->nodeType, $nodeTypes))
$return[] = $node;
}
return $return;
}
// TODO phpdoc; $oldAttr is result of hasAttribute, before any changes
protected function attrEvents($attr, $oldAttr, $oldValue, $node) {
// skip events for XML documents
if (! $this->isXHTML() && ! $this->isHTML())
return;
$event = null;
// identify
$isInputValue = $node->tagName == 'input'
&& (
in_array($node->getAttribute('type'),
array('text', 'password', 'hidden'))
|| !$node->getAttribute('type')
);
$isRadio = $node->tagName == 'input'
&& $node->getAttribute('type') == 'radio';
$isCheckbox = $node->tagName == 'input'
&& $node->getAttribute('type') == 'checkbox';
$isOption = $node->tagName == 'option';
if ($isInputValue && $attr == 'value' && $oldValue != $node->getAttribute($attr)) {
$event = new DOMEvent(array(
'target' => $node,
'type' => 'change'
));
} else if (($isRadio || $isCheckbox) && $attr == 'checked' && (
// check
(! $oldAttr && $node->hasAttribute($attr))
// un-check
|| (! $node->hasAttribute($attr) && $oldAttr)
)) {
$event = new DOMEvent(array(
'target' => $node,
'type' => 'change'
));
} else if ($isOption && $node->parentNode && $attr == 'selected' && (
// select
(! $oldAttr && $node->hasAttribute($attr))
// un-select
|| (! $node->hasAttribute($attr) && $oldAttr)
)) {
$event = new DOMEvent(array(
'target' => $node->parentNode,
'type' => 'change'
));
}
if ($event) {
phpQueryEvents::trigger($this->getDocumentID(),
$event->type, array($event), $node
);
}
}
public function attr($attr = null, $value = null) {
foreach($this->stack(1) as $node) {
if (! is_null($value)) {
$loop = $attr == '*'
? $this->getNodeAttrs($node)
: array($attr);
foreach($loop as $a) {
$oldValue = $node->getAttribute($a);
$oldAttr = $node->hasAttribute($a);
// TODO raises an error when charset other than UTF-8
// while document's charset is also not UTF-8
@$node->setAttribute($a, $value);
$this->attrEvents($a, $oldAttr, $oldValue, $node);
}
} else if ($attr == '*') {
// jQuery difference
$return = array();
foreach($node->attributes as $n => $v)
$return[$n] = $v->value;
return $return;
} else
return $node->hasAttribute($attr)
? $node->getAttribute($attr)
: null;
}
return is_null($value)
? '' : $this;
}
/**
* @access private
*/
protected function getNodeAttrs($node) {
$return = array();
foreach($node->attributes as $n => $o)
$return[] = $n;
return $return;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo check CDATA ???
*/
public function attrPHP($attr, $code) {
if (! is_null($code)) {
$value = '<'.'?php '.$code.' ?'.'>';
// TODO tempolary solution
// http://code.google.com/p/phpquery/issues/detail?id=17
// if (function_exists('mb_detect_encoding') && mb_detect_encoding($value) == 'ASCII')
// $value = mb_convert_encoding($value, 'UTF-8', 'HTML-ENTITIES');
}
foreach($this->stack(1) as $node) {
if (! is_null($code)) {
// $attrNode = $this->DOM->createAttribute($attr);
$node->setAttribute($attr, $value);
// $attrNode->value = $value;
// $node->appendChild($attrNode);
} else if ( $attr == '*') {
// jQuery diff
$return = array();
foreach($node->attributes as $n => $v)
$return[$n] = $v->value;
return $return;
} else
return $node->getAttribute($attr);
}
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function removeAttr($attr) {
foreach($this->stack(1) as $node) {
$loop = $attr == '*'
? $this->getNodeAttrs($node)
: array($attr);
foreach($loop as $a) {
$oldValue = $node->getAttribute($a);
$node->removeAttribute($a);
$this->attrEvents($a, $oldValue, null, $node);
}
}
return $this;
}
/**
* Return form element value.
*
* @return String Fields value.
*/
public function val($val = null) {
if (! isset($val)) {
if ($this->eq(0)->is('select')) {
$selected = $this->eq(0)->find('option[selected=selected]');
if ($selected->is('[value]'))
return $selected->attr('value');
else
return $selected->text();
} else if ($this->eq(0)->is('textarea'))
return $this->eq(0)->markup();
else
return $this->eq(0)->attr('value');
} else {
$_val = null;
foreach($this->stack(1) as $node) {
$node = pq($node, $this->getDocumentID());
if (is_array($val) && in_array($node->attr('type'), array('checkbox', 'radio'))) {
$isChecked = in_array($node->attr('value'), $val)
|| in_array($node->attr('name'), $val);
if ($isChecked)
$node->attr('checked', 'checked');
else
$node->removeAttr('checked');
} else if ($node->get(0)->tagName == 'select') {
if (! isset($_val)) {
$_val = array();
if (! is_array($val))
$_val = array((string)$val);
else
foreach($val as $v)
$_val[] = $v;
}
foreach($node['option']->stack(1) as $option) {
$option = pq($option, $this->getDocumentID());
$selected = false;
// XXX: workaround for string comparsion, see issue #96
// http://code.google.com/p/phpquery/issues/detail?id=96
$selected = is_null($option->attr('value'))
? in_array($option->markup(), $_val)
: in_array($option->attr('value'), $_val);
// $optionValue = $option->attr('value');
// $optionText = $option->text();
// $optionTextLenght = mb_strlen($optionText);
// foreach($_val as $v)
// if ($optionValue == $v)
// $selected = true;
// else if ($optionText == $v && $optionTextLenght == mb_strlen($v))
// $selected = true;
if ($selected)
$option->attr('selected', 'selected');
else
$option->removeAttr('selected');
}
} else if ($node->get(0)->tagName == 'textarea')
$node->markup($val);
else
$node->attr('value', $val);
}
}
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function andSelf() {
if ( $this->previous )
$this->elements = array_merge($this->elements, $this->previous->elements);
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function addClass( $className) {
if (! $className)
return $this;
foreach($this->stack(1) as $node) {
if (! $this->is(".$className", $node))
$node->setAttribute(
'class',
trim($node->getAttribute('class').' '.$className)
);
}
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function addClassPHP( $className) {
foreach($this->stack(1) as $node) {
$classes = $node->getAttribute('class');
$newValue = $classes
? $classes.' <'.'?php '.$className.' ?'.'>'
: '<'.'?php '.$className.' ?'.'>';
$node->setAttribute('class', $newValue);
}
return $this;
}
/**
* Enter description here...
*
* @param string $className
* @return bool
*/
public function hasClass($className) {
foreach($this->stack(1) as $node) {
if ( $this->is(".$className", $node))
return true;
}
return false;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function removeClass($className) {
foreach($this->stack(1) as $node) {
$classes = explode( ' ', $node->getAttribute('class'));
if ( in_array($className, $classes)) {
$classes = array_diff($classes, array($className));
if ( $classes )
$node->setAttribute('class', implode(' ', $classes));
else
$node->removeAttribute('class');
}
}
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function toggleClass($className) {
foreach($this->stack(1) as $node) {
if ( $this->is( $node, '.'.$className ))
$this->removeClass($className);
else
$this->addClass($className);
}
return $this;
}
/**
* Proper name without underscore (just ->empty()) also works.
*
* Removes all child nodes from the set of matched elements.
*
* Example:
* pq("p")._empty()
*
* HTML:
* <p>Hello, <span>Person</span> <a href="#">and person</a></p>
*
* Result:
* [ <p></p> ]
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @access private
*/
public function _empty() {
foreach($this->stack(1) as $node) {
// thx to 'dave at dgx dot cz'
$node->nodeValue = '';
}
return $this;
}
/**
* Enter description here...
*
* @param array|string $callback Expects $node as first param, $index as second
* @param array $scope External variables passed to callback. Use compact('varName1', 'varName2'...) and extract($scope)
* @param array $arg1 Will ba passed as third and futher args to callback.
* @param array $arg2 Will ba passed as fourth and futher args to callback, and so on...
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function each($callback, $param1 = null, $param2 = null, $param3 = null) {
$paramStructure = null;
if (func_num_args() > 1) {
$paramStructure = func_get_args();
$paramStructure = array_slice($paramStructure, 1);
}
foreach($this->elements as $v)
phpQuery::callbackRun($callback, array($v), $paramStructure);
return $this;
}
/**
* Run callback on actual object.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function callback($callback, $param1 = null, $param2 = null, $param3 = null) {
$params = func_get_args();
$params[0] = $this;
phpQuery::callbackRun($callback, $params);
return $this;
}
/**
* Enter description here...
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @todo add $scope and $args as in each() ???
*/
public function map($callback, $param1 = null, $param2 = null, $param3 = null) {
// $stack = array();
//// foreach($this->newInstance() as $node) {
// foreach($this->newInstance() as $node) {
// $result = call_user_func($callback, $node);
// if ($result)
// $stack[] = $result;
// }
$params = func_get_args();
array_unshift($params, $this->elements);
return $this->newInstance(
call_user_func_array(array('phpQuery', 'map'), $params)
// phpQuery::map($this->elements, $callback)
);
}
/**
* Enter description here...
*
* @param <type> $key
* @param <type> $value
*/
public function data($key, $value = null) {
if (! isset($value)) {
// TODO? implement specific jQuery behavior od returning parent values
// is child which we look up doesn't exist
return phpQuery::data($this->get(0), $key, $value, $this->getDocumentID());
} else {
foreach($this as $node)
phpQuery::data($node, $key, $value, $this->getDocumentID());
return $this;
}
}
/**
* Enter description here...
*
* @param <type> $key
*/
public function removeData($key) {
foreach($this as $node)
phpQuery::removeData($node, $key, $this->getDocumentID());
return $this;
}
// INTERFACE IMPLEMENTATIONS
// ITERATOR INTERFACE
/**
* @access private
*/
public function rewind(){
$this->debug('iterating foreach');
// phpQuery::selectDocument($this->getDocumentID());
$this->elementsBackup = $this->elements;
$this->elementsInterator = $this->elements;
$this->valid = isset( $this->elements[0] )
? 1 : 0;
// $this->elements = $this->valid
// ? array($this->elements[0])
// : array();
$this->current = 0;
}
/**
* @access private
*/
public function current(){
return $this->elementsInterator[ $this->current ];
}
/**
* @access private
*/
public function key(){
return $this->current;
}
/**
* Double-function method.
*
* First: main iterator interface method.
* Second: Returning next sibling, alias for _next().
*
* Proper functionality is choosed automagicaly.
*
* @see phpQueryObject::_next()
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public function next($cssSelector = null){
// if ($cssSelector || $this->valid)
// return $this->_next($cssSelector);
$this->valid = isset( $this->elementsInterator[ $this->current+1 ] )
? true
: false;
if (! $this->valid && $this->elementsInterator) {
$this->elementsInterator = null;
} else if ($this->valid) {
$this->current++;
} else {
return $this->_next($cssSelector);
}
}
/**
* @access private
*/
public function valid(){
return $this->valid;
}
// ITERATOR INTERFACE END
// ARRAYACCESS INTERFACE
/**
* @access private
*/
public function offsetExists($offset) {
return $this->find($offset)->size() > 0;
}
/**
* @access private
*/
public function offsetGet($offset) {
return $this->find($offset);
}
/**
* @access private
*/
public function offsetSet($offset, $value) {
// $this->find($offset)->replaceWith($value);
$this->find($offset)->html($value);
}
/**
* @access private
*/
public function offsetUnset($offset) {
// empty
throw new Exception("Can't do unset, use array interface only for calling queries and replacing HTML.");
}
// ARRAYACCESS INTERFACE END
/**
* Returns node's XPath.
*
* @param unknown_type $oneNode
* @return string
* @TODO use native getNodePath is avaible
* @access private
*/
protected function getNodeXpath($oneNode = null, $namespace = null) {
$return = array();
$loop = $oneNode
? array($oneNode)
: $this->elements;
// if ($namespace)
// $namespace .= ':';
foreach($loop as $node) {
if ($node instanceof DOMDOCUMENT) {
$return[] = '';
continue;
}
$xpath = array();
while(! ($node instanceof DOMDOCUMENT)) {
$i = 1;
$sibling = $node;
while($sibling->previousSibling) {
$sibling = $sibling->previousSibling;
$isElement = $sibling instanceof DOMELEMENT;
if ($isElement && $sibling->tagName == $node->tagName)
$i++;
}
$xpath[] = $this->isXML()
? "*[local-name()='{$node->tagName}'][{$i}]"
: "{$node->tagName}[{$i}]";
$node = $node->parentNode;
}
$xpath = join('/', array_reverse($xpath));
$return[] = '/'.$xpath;
}
return $oneNode
? $return[0]
: $return;
}
// HELPERS
public function whois($oneNode = null) {
$return = array();
$loop = $oneNode
? array( $oneNode )
: $this->elements;
foreach($loop as $node) {
if (isset($node->tagName)) {
$tag = in_array($node->tagName, array('php', 'js'))
? strtoupper($node->tagName)
: $node->tagName;
$return[] = $tag
.($node->getAttribute('id')
? '#'.$node->getAttribute('id'):'')
.($node->getAttribute('class')
? '.'.join('.', split(' ', $node->getAttribute('class'))):'')
.($node->getAttribute('name')
? '[name="'.$node->getAttribute('name').'"]':'')
.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') === false
? '[value="'.substr(str_replace("\n", '', $node->getAttribute('value')), 0, 15).'"]':'')
.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') !== false
? '[value=PHP]':'')
.($node->getAttribute('selected')
? '[selected]':'')
.($node->getAttribute('checked')
? '[checked]':'')
;
} else if ($node instanceof DOMTEXT) {
if (trim($node->textContent))
$return[] = 'Text:'.substr(str_replace("\n", ' ', $node->textContent), 0, 15);
} else {
}
}
return $oneNode && isset($return[0])
? $return[0]
: $return;
}
/**
* Dump htmlOuter and preserve chain. Usefull for debugging.
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*
*/
public function dump() {
print 'DUMP #'.(phpQuery::$dumpCount++).' ';
$debug = phpQuery::$debug;
phpQuery::$debug = false;
// print __FILE__.':'.__LINE__."\n";
var_dump($this->htmlOuter());
return $this;
}
public function dumpWhois() {
print 'DUMP #'.(phpQuery::$dumpCount++).' ';
$debug = phpQuery::$debug;
phpQuery::$debug = false;
// print __FILE__.':'.__LINE__."\n";
var_dump('whois', $this->whois());
phpQuery::$debug = $debug;
return $this;
}
public function dumpLength() {
print 'DUMP #'.(phpQuery::$dumpCount++).' ';
$debug = phpQuery::$debug;
phpQuery::$debug = false;
// print __FILE__.':'.__LINE__."\n";
var_dump('length', $this->length());
phpQuery::$debug = $debug;
return $this;
}
public function dumpTree($html = true, $title = true) {
$output = $title
? 'DUMP #'.(phpQuery::$dumpCount++)." \n" : '';
$debug = phpQuery::$debug;
phpQuery::$debug = false;
foreach($this->stack() as $node)
$output .= $this->__dumpTree($node);
phpQuery::$debug = $debug;
print $html
? nl2br(str_replace(' ', ' ', $output))
: $output;
return $this;
}
private function __dumpTree($node, $intend = 0) {
$whois = $this->whois($node);
$return = '';
if ($whois)
$return .= str_repeat(' - ', $intend).$whois."\n";
if (isset($node->childNodes))
foreach($node->childNodes as $chNode)
$return .= $this->__dumpTree($chNode, $intend+1);
return $return;
}
/**
* Dump htmlOuter and stop script execution. Usefull for debugging.
*
*/
public function dumpDie() {
print __FILE__.':'.__LINE__;
var_dump($this->htmlOuter());
die();
}
}
// -- Multibyte Compatibility functions ---------------------------------------
// http://svn.iphonewebdev.com/lace/lib/mb_compat.php
/**
* mb_internal_encoding()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_internal_encoding'))
{
function mb_internal_encoding($enc) {return true; }
}
/**
* mb_regex_encoding()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_regex_encoding'))
{
function mb_regex_encoding($enc) {return true; }
}
/**
* mb_strlen()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_strlen'))
{
function mb_strlen($str)
{
return strlen($str);
}
}
/**
* mb_strpos()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_strpos'))
{
function mb_strpos($haystack, $needle, $offset=0)
{
return strpos($haystack, $needle, $offset);
}
}
/**
* mb_stripos()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_stripos'))
{
function mb_stripos($haystack, $needle, $offset=0)
{
return stripos($haystack, $needle, $offset);
}
}
/**
* mb_substr()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_substr'))
{
function mb_substr($str, $start, $length=0)
{
return substr($str, $start, $length);
}
}
/**
* mb_substr_count()
*
* Included for mbstring pseudo-compatability.
*/
if (!function_exists('mb_substr_count'))
{
function mb_substr_count($haystack, $needle)
{
return substr_count($haystack, $needle);
}
}
/**
* Static namespace for phpQuery functions.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
*/
abstract class phpQuery {
/**
* XXX: Workaround for mbstring problems
*
* @var bool
*/
public static $mbstringSupport = true;
public static $debug = false;
public static $documents = array();
public static $defaultDocumentID = null;
// public static $defaultDoctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"';
/**
* Applies only to HTML.
*
* @var unknown_type
*/
public static $defaultDoctype = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">';
public static $defaultCharset = 'UTF-8';
/**
* Static namespace for plugins.
*
* @var object
*/
public static $plugins = array();
/**
* List of loaded plugins.
*
* @var unknown_type
*/
public static $pluginsLoaded = array();
public static $pluginsMethods = array();
public static $pluginsStaticMethods = array();
public static $extendMethods = array();
/**
* @TODO implement
*/
public static $extendStaticMethods = array();
/**
* Hosts allowed for AJAX connections.
* Dot '.' means $_SERVER['HTTP_HOST'] (if any).
*
* @var array
*/
public static $ajaxAllowedHosts = array(
'.'
);
/**
* AJAX settings.
*
* @var array
* XXX should it be static or not ?
*/
public static $ajaxSettings = array(
'url' => '',//TODO
'global' => true,
'type' => "GET",
'timeout' => null,
'contentType' => "application/x-www-form-urlencoded",
'processData' => true,
// 'async' => true,
'data' => null,
'username' => null,
'password' => null,
'accepts' => array(
'xml' => "application/xml, text/xml",
'html' => "text/html",
'script' => "text/javascript, application/javascript",
'json' => "application/json, text/javascript",
'text' => "text/plain",
'_default' => "*/*"
)
);
public static $lastModified = null;
public static $active = 0;
public static $dumpCount = 0;
/**
* Multi-purpose function.
* Use pq() as shortcut.
*
* In below examples, $pq is any result of pq(); function.
*
* 1. Import markup into existing document (without any attaching):
* - Import into selected document:
* pq('<div/>') // DOESNT accept text nodes at beginning of input string !
* - Import into document with ID from $pq->getDocumentID():
* pq('<div/>', $pq->getDocumentID())
* - Import into same document as DOMNode belongs to:
* pq('<div/>', DOMNode)
* - Import into document from phpQuery object:
* pq('<div/>', $pq)
*
* 2. Run query:
* - Run query on last selected document:
* pq('div.myClass')
* - Run query on document with ID from $pq->getDocumentID():
* pq('div.myClass', $pq->getDocumentID())
* - Run query on same document as DOMNode belongs to and use node(s)as root for query:
* pq('div.myClass', DOMNode)
* - Run query on document from phpQuery object
* and use object's stack as root node(s) for query:
* pq('div.myClass', $pq)
*
* @param string|DOMNode|DOMNodeList|array $arg1 HTML markup, CSS Selector, DOMNode or array of DOMNodes
* @param string|phpQueryObject|DOMNode $context DOM ID from $pq->getDocumentID(), phpQuery object (determines also query root) or DOMNode (determines also query root)
*
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery|QueryTemplatesPhpQuery|false
* phpQuery object or false in case of error.
*/
public static function pq($arg1, $context = null) {
if ($arg1 instanceof DOMNODE && ! isset($context)) {
foreach(phpQuery::$documents as $documentWrapper) {
$compare = $arg1 instanceof DOMDocument
? $arg1 : $arg1->ownerDocument;
if ($documentWrapper->document->isSameNode($compare))
$context = $documentWrapper->id;
}
}
if (! $context) {
$domId = self::$defaultDocumentID;
if (! $domId)
throw new Exception("Can't use last created DOM, because there isn't any. Use phpQuery::newDocument() first.");
// } else if (is_object($context) && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
} else if (is_object($context) && $context instanceof phpQueryObject)
$domId = $context->getDocumentID();
else if ($context instanceof DOMDOCUMENT) {
$domId = self::getDocumentID($context);
if (! $domId) {
//throw new Exception('Orphaned DOMDocument');
$domId = self::newDocument($context)->getDocumentID();
}
} else if ($context instanceof DOMNODE) {
$domId = self::getDocumentID($context);
if (! $domId) {
throw new Exception('Orphaned DOMNode');
// $domId = self::newDocument($context->ownerDocument);
}
} else
$domId = $context;
if ($arg1 instanceof phpQueryObject) {
// if (is_object($arg1) && (get_class($arg1) == 'phpQueryObject' || $arg1 instanceof PHPQUERY || is_subclass_of($arg1, 'phpQueryObject'))) {
/**
* Return $arg1 or import $arg1 stack if document differs:
* pq(pq('<div/>'))
*/
if ($arg1->getDocumentID() == $domId)
return $arg1;
$class = get_class($arg1);
// support inheritance by passing old object to overloaded constructor
$phpQuery = $class != 'phpQuery'
? new $class($arg1, $domId)
: new phpQueryObject($domId);
$phpQuery->elements = array();
foreach($arg1->elements as $node)
$phpQuery->elements[] = $phpQuery->document->importNode($node, true);
return $phpQuery;
} else if ($arg1 instanceof DOMNODE || (is_array($arg1) && isset($arg1[0]) && $arg1[0] instanceof DOMNODE)) {
/*
* Wrap DOM nodes with phpQuery object, import into document when needed:
* pq(array($domNode1, $domNode2))
*/
$phpQuery = new phpQueryObject($domId);
if (!($arg1 instanceof DOMNODELIST) && ! is_array($arg1))
$arg1 = array($arg1);
$phpQuery->elements = array();
foreach($arg1 as $node) {
$sameDocument = $node->ownerDocument instanceof DOMDOCUMENT
&& ! $node->ownerDocument->isSameNode($phpQuery->document);
$phpQuery->elements[] = $sameDocument
? $phpQuery->document->importNode($node, true)
: $node;
}
return $phpQuery;
} else if (self::isMarkup($arg1)) {
/**
* Import HTML:
* pq('<div/>')
*/
$phpQuery = new phpQueryObject($domId);
return $phpQuery->newInstance(
$phpQuery->documentWrapper->import($arg1)
);
} else {
/**
* Run CSS query:
* pq('div.myClass')
*/
$phpQuery = new phpQueryObject($domId);
// if ($context && ($context instanceof PHPQUERY || is_subclass_of($context, 'phpQueryObject')))
if ($context && $context instanceof phpQueryObject)
$phpQuery->elements = $context->elements;
else if ($context && $context instanceof DOMNODELIST) {
$phpQuery->elements = array();
foreach($context as $node)
$phpQuery->elements[] = $node;
} else if ($context && $context instanceof DOMNODE)
$phpQuery->elements = array($context);
return $phpQuery->find($arg1);
}
}
/**
* Sets default document to $id. Document has to be loaded prior
* to using this method.
* $id can be retrived via getDocumentID() or getDocumentIDRef().
*
* @param unknown_type $id
*/
public static function selectDocument($id) {
$id = self::getDocumentID($id);
self::debug("Selecting document '$id' as default one");
self::$defaultDocumentID = self::getDocumentID($id);
}
/**
* Returns document with id $id or last used as phpQueryObject.
* $id can be retrived via getDocumentID() or getDocumentIDRef().
* Chainable.
*
* @see phpQuery::selectDocument()
* @param unknown_type $id
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function getDocument($id = null) {
if ($id)
phpQuery::selectDocument($id);
else
$id = phpQuery::$defaultDocumentID;
return new phpQueryObject($id);
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocument($markup = null, $contentType = null) {
if (! $markup)
$markup = '';
$documentID = phpQuery::createDocumentWrapper($markup, $contentType);
return new phpQueryObject($documentID);
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentHTML($markup = null, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocument($markup, "text/html{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentXML($markup = null, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocument($markup, "text/xml{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentXHTML($markup = null, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocument($markup, "application/xhtml+xml{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentPHP($markup = null, $contentType = "text/html") {
// TODO pass charset to phpToMarkup if possible (use DOMDocumentWrapper function)
$markup = phpQuery::phpToMarkup($markup, self::$defaultCharset);
return self::newDocument($markup, $contentType);
}
public static function phpToMarkup($php, $charset = 'utf-8') {
$regexes = array(
'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)<'.'?php?(.*?)(?:\\?>)([^\']*)\'@s',
'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)<'.'?php?(.*?)(?:\\?>)([^"]*)"@s',
);
foreach($regexes as $regex)
while (preg_match($regex, $php, $matches)) {
$php = preg_replace_callback(
$regex,
// create_function('$m, $charset = "'.$charset.'"',
// 'return $m[1].$m[2]
// .htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
// .$m[5].$m[2];'
// ),
array('phpQuery', '_phpToMarkupCallback'),
$php
);
}
$regex = '@(^|>[^<]*)+?(<\?php(.*?)(\?>))@s';
//preg_match_all($regex, $php, $matches);
//var_dump($matches);
$php = preg_replace($regex, '\\1<php><!-- \\3 --></php>', $php);
return $php;
}
public static function _phpToMarkupCallback($php, $charset = 'utf-8') {
return $m[1].$m[2]
.htmlspecialchars("<"."?php".$m[4]."?".">", ENT_QUOTES|ENT_NOQUOTES, $charset)
.$m[5].$m[2];
}
public static function _markupToPHPCallback($m) {
return "<"."?php ".htmlspecialchars_decode($m[1])." ?".">";
}
/**
* Converts document markup containing PHP code generated by phpQuery::php()
* into valid (executable) PHP code syntax.
*
* @param string|phpQueryObject $content
* @return string PHP code.
*/
public static function markupToPHP($content) {
if ($content instanceof phpQueryObject)
$content = $content->markupOuter();
/* <php>...</php> to <?php...? > */
$content = preg_replace_callback(
'@<php>\s*<!--(.*?)-->\s*</php>@s',
// create_function('$m',
// 'return "<'.'?php ".htmlspecialchars_decode($m[1])." ?'.'>";'
// ),
array('phpQuery', '_markupToPHPCallback'),
$content
);
/* <node attr='< ?php ? >'> extra space added to save highlighters */
$regexes = array(
'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(\')([^\']*)(?:<|%3C)\\?(?:php)?(.*?)(?:\\?(?:>|%3E))([^\']*)\'@s',
'@(<(?!\\?)(?:[^>]|\\?>)+\\w+\\s*=\\s*)(")([^"]*)(?:<|%3C)\\?(?:php)?(.*?)(?:\\?(?:>|%3E))([^"]*)"@s',
);
foreach($regexes as $regex)
while (preg_match($regex, $content))
$content = preg_replace_callback(
$regex,
create_function('$m',
'return $m[1].$m[2].$m[3]."<?php "
.str_replace(
array("%20", "%3E", "%09", " ", "	", "%7B", "%24", "%7D", "%22", "%5B", "%5D"),
array(" ", ">", " ", "\n", " ", "{", "$", "}", \'"\', "[", "]"),
htmlspecialchars_decode($m[4])
)
." ?>".$m[5].$m[2];'
),
$content
);
return $content;
}
/**
* Creates new document from file $file.
* Chainable.
*
* @param string $file URLs allowed. See File wrapper page at php.net for more supported sources.
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentFile($file, $contentType = null) {
$documentID = self::createDocumentWrapper(
file_get_contents($file), $contentType
);
return new phpQueryObject($documentID);
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentFileHTML($file, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocumentFile($file, "text/html{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentFileXML($file, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocumentFile($file, "text/xml{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentFileXHTML($file, $charset = null) {
$contentType = $charset
? ";charset=$charset"
: '';
return self::newDocumentFile($file, "application/xhtml+xml{$contentType}");
}
/**
* Creates new document from markup.
* Chainable.
*
* @param unknown_type $markup
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
*/
public static function newDocumentFilePHP($file, $contentType = null) {
return self::newDocumentPHP(file_get_contents($file), $contentType);
}
/**
* Reuses existing DOMDocument object.
* Chainable.
*
* @param $document DOMDocument
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @TODO support DOMDocument
*/
public static function loadDocument($document) {
// TODO
die('TODO loadDocument');
}
/**
* Enter description here...
*
* @param unknown_type $html
* @param unknown_type $domId
* @return unknown New DOM ID
* @todo support PHP tags in input
* @todo support passing DOMDocument object from self::loadDocument
*/
protected static function createDocumentWrapper($html, $contentType = null, $documentID = null) {
if (function_exists('domxml_open_mem'))
throw new Exception("Old PHP4 DOM XML extension detected. phpQuery won't work until this extension is enabled.");
// $id = $documentID
// ? $documentID
// : md5(microtime());
$document = null;
if ($html instanceof DOMDOCUMENT) {
if (self::getDocumentID($html)) {
// document already exists in phpQuery::$documents, make a copy
$document = clone $html;
} else {
// new document, add it to phpQuery::$documents
$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
}
} else {
$wrapper = new DOMDocumentWrapper($html, $contentType, $documentID);
}
// $wrapper->id = $id;
// bind document
phpQuery::$documents[$wrapper->id] = $wrapper;
// remember last loaded document
phpQuery::selectDocument($wrapper->id);
return $wrapper->id;
}
/**
* Extend class namespace.
*
* @param string|array $target
* @param array $source
* @TODO support string $source
* @return unknown_type
*/
public static function extend($target, $source) {
switch($target) {
case 'phpQueryObject':
$targetRef = &self::$extendMethods;
$targetRef2 = &self::$pluginsMethods;
break;
case 'phpQuery':
$targetRef = &self::$extendStaticMethods;
$targetRef2 = &self::$pluginsStaticMethods;
break;
default:
throw new Exception("Unsupported \$target type");
}
if (is_string($source))
$source = array($source => $source);
foreach($source as $method => $callback) {
if (isset($targetRef[$method])) {
// throw new Exception
self::debug("Duplicate method '{$method}', can\'t extend '{$target}'");
continue;
}
if (isset($targetRef2[$method])) {
// throw new Exception
self::debug("Duplicate method '{$method}' from plugin '{$targetRef2[$method]}',"
." can\'t extend '{$target}'");
continue;
}
$targetRef[$method] = $callback;
}
return true;
}
/**
* Extend phpQuery with $class from $file.
*
* @param string $class Extending class name. Real class name can be prepended phpQuery_.
* @param string $file Filename to include. Defaults to "{$class}.php".
*/
public static function plugin($class, $file = null) {
// TODO $class checked agains phpQuery_$class
// if (strpos($class, 'phpQuery') === 0)
// $class = substr($class, 8);
if (in_array($class, self::$pluginsLoaded))
return true;
if (! $file)
$file = $class.'.php';
$objectClassExists = class_exists('phpQueryObjectPlugin_'.$class);
$staticClassExists = class_exists('phpQueryPlugin_'.$class);
if (! $objectClassExists && ! $staticClassExists)
require_once($file);
self::$pluginsLoaded[] = $class;
// static methods
if (class_exists('phpQueryPlugin_'.$class)) {
$realClass = 'phpQueryPlugin_'.$class;
$vars = get_class_vars($realClass);
$loop = isset($vars['phpQueryMethods'])
&& ! is_null($vars['phpQueryMethods'])
? $vars['phpQueryMethods']
: get_class_methods($realClass);
foreach($loop as $method) {
if ($method == '__initialize')
continue;
if (! is_callable(array($realClass, $method)))
continue;
if (isset(self::$pluginsStaticMethods[$method])) {
throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsStaticMethods[$method]."'");
return;
}
self::$pluginsStaticMethods[$method] = $class;
}
if (method_exists($realClass, '__initialize'))
call_user_func_array(array($realClass, '__initialize'), array());
}
// object methods
if (class_exists('phpQueryObjectPlugin_'.$class)) {
$realClass = 'phpQueryObjectPlugin_'.$class;
$vars = get_class_vars($realClass);
$loop = isset($vars['phpQueryMethods'])
&& ! is_null($vars['phpQueryMethods'])
? $vars['phpQueryMethods']
: get_class_methods($realClass);
foreach($loop as $method) {
if (! is_callable(array($realClass, $method)))
continue;
if (isset(self::$pluginsMethods[$method])) {
throw new Exception("Duplicate method '{$method}' from plugin '{$c}' conflicts with same method from plugin '".self::$pluginsMethods[$method]."'");
continue;
}
self::$pluginsMethods[$method] = $class;
}
}
return true;
}
/**
* Unloades all or specified document from memory.
*
* @param mixed $documentID @see phpQuery::getDocumentID() for supported types.
*/
public static function unloadDocuments($id = null) {
if (isset($id)) {
if ($id = self::getDocumentID($id))
unset(phpQuery::$documents[$id]);
} else {
foreach(phpQuery::$documents as $k => $v) {
unset(phpQuery::$documents[$k]);
}
}
}
/**
* Parses phpQuery object or HTML result against PHP tags and makes them active.
*
* @param phpQuery|string $content
* @deprecated
* @return string
*/
public static function unsafePHPTags($content) {
return self::markupToPHP($content);
}
public static function DOMNodeListToArray($DOMNodeList) {
$array = array();
if (! $DOMNodeList)
return $array;
foreach($DOMNodeList as $node)
$array[] = $node;
return $array;
}
/**
* Checks if $input is HTML string, which has to start with '<'.
*
* @deprecated
* @param String $input
* @return Bool
* @todo still used ?
*/
public static function isMarkup($input) {
return ! is_array($input) && substr(trim($input), 0, 1) == '<';
}
public static function debug($text) {
if (self::$debug)
print var_dump($text);
}
/**
* Make an AJAX request.
*
* @param array See $options http://docs.jquery.com/Ajax/jQuery.ajax#toptions
* Additional options are:
* 'document' - document for global events, @see phpQuery::getDocumentID()
* 'referer' - implemented
* 'requested_with' - TODO; not implemented (X-Requested-With)
* @return Zend_Http_Client
* @link http://docs.jquery.com/Ajax/jQuery.ajax
*
* @TODO $options['cache']
* @TODO $options['processData']
* @TODO $options['xhr']
* @TODO $options['data'] as string
* @TODO XHR interface
*/
public static function ajax($options = array(), $xhr = null) {
$options = array_merge(
self::$ajaxSettings, $options
);
$documentID = isset($options['document'])
? self::getDocumentID($options['document'])
: null;
if ($xhr) {
// reuse existing XHR object, but clean it up
$client = $xhr;
// $client->setParameterPost(null);
// $client->setParameterGet(null);
$client->setAuth(false);
$client->setHeaders("If-Modified-Since", null);
$client->setHeaders("Referer", null);
$client->resetParameters();
} else {
// create new XHR object
require_once('Zend/Http/Client.php');
$client = new Zend_Http_Client();
$client->setCookieJar();
}
if (isset($options['timeout']))
$client->setConfig(array(
'timeout' => $options['timeout'],
));
// 'maxredirects' => 0,
foreach(self::$ajaxAllowedHosts as $k => $host)
if ($host == '.' && isset($_SERVER['HTTP_HOST']))
self::$ajaxAllowedHosts[$k] = $_SERVER['HTTP_HOST'];
$host = parse_url($options['url'], PHP_URL_HOST);
if (! in_array($host, self::$ajaxAllowedHosts)) {
throw new Exception("Request not permitted, host '$host' not present in "
."phpQuery::\$ajaxAllowedHosts");
}
// JSONP
$jsre = "/=\\?(&|$)/";
if (isset($options['dataType']) && $options['dataType'] == 'jsonp') {
$jsonpCallbackParam = $options['jsonp']
? $options['jsonp'] : 'callback';
if (strtolower($options['type']) == 'get') {
if (! preg_match($jsre, $options['url'])) {
$sep = strpos($options['url'], '?')
? '&' : '?';
$options['url'] .= "$sep$jsonpCallbackParam=?";
}
} else if ($options['data']) {
$jsonp = false;
foreach($options['data'] as $n => $v) {
if ($v == '?')
$jsonp = true;
}
if (! $jsonp) {
$options['data'][$jsonpCallbackParam] = '?';
}
}
$options['dataType'] = 'json';
}
if (isset($options['dataType']) && $options['dataType'] == 'json') {
$jsonpCallback = 'json_'.md5(microtime());
$jsonpData = $jsonpUrl = false;
if ($options['data']) {
foreach($options['data'] as $n => $v) {
if ($v == '?')
$jsonpData = $n;
}
}
if (preg_match($jsre, $options['url']))
$jsonpUrl = true;
if ($jsonpData !== false || $jsonpUrl) {
// remember callback name for httpData()
$options['_jsonp'] = $jsonpCallback;
if ($jsonpData !== false)
$options['data'][$jsonpData] = $jsonpCallback;
if ($jsonpUrl)
$options['url'] = preg_replace($jsre, "=$jsonpCallback\\1", $options['url']);
}
}
$client->setUri($options['url']);
$client->setMethod(strtoupper($options['type']));
if (isset($options['referer']) && $options['referer'])
$client->setHeaders('Referer', $options['referer']);
$client->setHeaders(array(
// 'content-type' => $options['contentType'],
'User-Agent' => 'Mozilla/5.0 (X11; U; Linux x86; en-US; rv:1.9.0.5) Gecko'
.'/2008122010 Firefox/3.0.5',
// TODO custom charset
'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
// 'Connection' => 'keep-alive',
// 'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language' => 'en-us,en;q=0.5',
));
if ($options['username'])
$client->setAuth($options['username'], $options['password']);
if (isset($options['ifModified']) && $options['ifModified'])
$client->setHeaders("If-Modified-Since",
self::$lastModified
? self::$lastModified
: "Thu, 01 Jan 1970 00:00:00 GMT"
);
$client->setHeaders("Accept",
isset($options['dataType'])
&& isset(self::$ajaxSettings['accepts'][ $options['dataType'] ])
? self::$ajaxSettings['accepts'][ $options['dataType'] ].", */*"
: self::$ajaxSettings['accepts']['_default']
);
// TODO $options['processData']
if ($options['data'] instanceof phpQueryObject) {
$serialized = $options['data']->serializeArray($options['data']);
$options['data'] = array();
foreach($serialized as $r)
$options['data'][ $r['name'] ] = $r['value'];
}
if (strtolower($options['type']) == 'get') {
$client->setParameterGet($options['data']);
} else if (strtolower($options['type']) == 'post') {
$client->setEncType($options['contentType']);
$client->setParameterPost($options['data']);
}
if (self::$active == 0 && $options['global'])
phpQueryEvents::trigger($documentID, 'ajaxStart');
self::$active++;
// beforeSend callback
if (isset($options['beforeSend']) && $options['beforeSend'])
phpQuery::callbackRun($options['beforeSend'], array($client));
// ajaxSend event
if ($options['global'])
phpQueryEvents::trigger($documentID, 'ajaxSend', array($client, $options));
if (phpQuery::$debug) {
self::debug("{$options['type']}: {$options['url']}\n");
self::debug("Options: <pre>".var_export($options, true)."</pre>\n");
// if ($client->getCookieJar())
// self::debug("Cookies: <pre>".var_export($client->getCookieJar()->getMatchingCookies($options['url']), true)."</pre>\n");
}
// request
$response = $client->request();
if (phpQuery::$debug) {
self::debug('Status: '.$response->getStatus().' / '.$response->getMessage());
self::debug($client->getLastRequest());
self::debug($response->getHeaders());
}
if ($response->isSuccessful()) {
// XXX tempolary
self::$lastModified = $response->getHeader('Last-Modified');
$data = self::httpData($response->getBody(), $options['dataType'], $options);
if (isset($options['success']) && $options['success'])
phpQuery::callbackRun($options['success'], array($data, $response->getStatus(), $options));
if ($options['global'])
phpQueryEvents::trigger($documentID, 'ajaxSuccess', array($client, $options));
} else {
if (isset($options['error']) && $options['error'])
phpQuery::callbackRun($options['error'], array($client, $response->getStatus(), $response->getMessage()));
if ($options['global'])
phpQueryEvents::trigger($documentID, 'ajaxError', array($client, /*$response->getStatus(),*/$response->getMessage(), $options));
}
if (isset($options['complete']) && $options['complete'])
phpQuery::callbackRun($options['complete'], array($client, $response->getStatus()));
if ($options['global'])
phpQueryEvents::trigger($documentID, 'ajaxComplete', array($client, $options));
if ($options['global'] && ! --self::$active)
phpQueryEvents::trigger($documentID, 'ajaxStop');
return $client;
// if (is_null($domId))
// $domId = self::$defaultDocumentID ? self::$defaultDocumentID : false;
// return new phpQueryAjaxResponse($response, $domId);
}
protected static function httpData($data, $type, $options) {
if (isset($options['dataFilter']) && $options['dataFilter'])
$data = self::callbackRun($options['dataFilter'], array($data, $type));
if (is_string($data)) {
if ($type == "json") {
if (isset($options['_jsonp']) && $options['_jsonp']) {
$data = preg_replace('/^\s*\w+\((.*)\)\s*$/s', '$1', $data);
}
$data = self::parseJSON($data);
}
}
return $data;
}
/**
* Enter description here...
*
* @param array|phpQuery $data
*
*/
public static function param($data) {
return http_build_query($data, null, '&');
}
public static function get($url, $data = null, $callback = null, $type = null) {
if (!is_array($data)) {
$callback = $data;
$data = null;
}
// TODO some array_values on this shit
return phpQuery::ajax(array(
'type' => 'GET',
'url' => $url,
'data' => $data,
'success' => $callback,
'dataType' => $type,
));
}
public static function post($url, $data = null, $callback = null, $type = null) {
if (!is_array($data)) {
$callback = $data;
$data = null;
}
return phpQuery::ajax(array(
'type' => 'POST',
'url' => $url,
'data' => $data,
'success' => $callback,
'dataType' => $type,
));
}
public static function getJSON($url, $data = null, $callback = null) {
if (!is_array($data)) {
$callback = $data;
$data = null;
}
// TODO some array_values on this shit
return phpQuery::ajax(array(
'type' => 'GET',
'url' => $url,
'data' => $data,
'success' => $callback,
'dataType' => 'json',
));
}
public static function ajaxSetup($options) {
self::$ajaxSettings = array_merge(
self::$ajaxSettings,
$options
);
}
public static function ajaxAllowHost($host1, $host2 = null, $host3 = null) {
$loop = is_array($host1)
? $host1
: func_get_args();
foreach($loop as $host) {
if ($host && ! in_array($host, phpQuery::$ajaxAllowedHosts)) {
phpQuery::$ajaxAllowedHosts[] = $host;
}
}
}
public static function ajaxAllowURL($url1, $url2 = null, $url3 = null) {
$loop = is_array($url1)
? $url1
: func_get_args();
foreach($loop as $url)
phpQuery::ajaxAllowHost(parse_url($url, PHP_URL_HOST));
}
/**
* Returns JSON representation of $data.
*
* @static
* @param mixed $data
* @return string
*/
public static function toJSON($data) {
if (function_exists('json_encode'))
return json_encode($data);
require_once('Zend/Json/Encoder.php');
return Zend_Json_Encoder::encode($data);
}
/**
* Parses JSON into proper PHP type.
*
* @static
* @param string $json
* @return mixed
*/
public static function parseJSON($json) {
if (function_exists('json_decode')) {
$return = json_decode(trim($json), true);
// json_decode and UTF8 issues
if (isset($return))
return $return;
}
require_once('Zend/Json/Decoder.php');
return Zend_Json_Decoder::decode($json);
}
/**
* Returns source's document ID.
*
* @param $source DOMNode|phpQueryObject
* @return string
*/
public static function getDocumentID($source) {
if ($source instanceof DOMDOCUMENT) {
foreach(phpQuery::$documents as $id => $document) {
if ($source->isSameNode($document->document))
return $id;
}
} else if ($source instanceof DOMNODE) {
foreach(phpQuery::$documents as $id => $document) {
if ($source->ownerDocument->isSameNode($document->document))
return $id;
}
} else if ($source instanceof phpQueryObject)
return $source->getDocumentID();
else if (is_string($source) && isset(phpQuery::$documents[$source]))
return $source;
}
/**
* Get DOMDocument object related to $source.
* Returns null if such document doesn't exist.
*
* @param $source DOMNode|phpQueryObject|string
* @return string
*/
public static function getDOMDocument($source) {
if ($source instanceof DOMDOCUMENT)
return $source;
$source = self::getDocumentID($source);
return $source
? self::$documents[$id]['document']
: null;
}
// UTILITIES
// http://docs.jquery.com/Utilities
/**
*
* @return unknown_type
* @link http://docs.jquery.com/Utilities/jQuery.makeArray
*/
public static function makeArray($obj) {
$array = array();
if (is_object($object) && $object instanceof DOMNODELIST) {
foreach($object as $value)
$array[] = $value;
} else if (is_object($object) && ! ($object instanceof Iterator)) {
foreach(get_object_vars($object) as $name => $value)
$array[0][$name] = $value;
} else {
foreach($object as $name => $value)
$array[0][$name] = $value;
}
return $array;
}
public static function inArray($value, $array) {
return in_array($value, $array);
}
/**
*
* @param $object
* @param $callback
* @return unknown_type
* @link http://docs.jquery.com/Utilities/jQuery.each
*/
public static function each($object, $callback, $param1 = null, $param2 = null, $param3 = null) {
$paramStructure = null;
if (func_num_args() > 2) {
$paramStructure = func_get_args();
$paramStructure = array_slice($paramStructure, 2);
}
if (is_object($object) && ! ($object instanceof Iterator)) {
foreach(get_object_vars($object) as $name => $value)
phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
} else {
foreach($object as $name => $value)
phpQuery::callbackRun($callback, array($name, $value), $paramStructure);
}
}
/**
*
* @link http://docs.jquery.com/Utilities/jQuery.map
*/
public static function map($array, $callback, $param1 = null, $param2 = null, $param3 = null) {
$result = array();
$paramStructure = null;
if (func_num_args() > 2) {
$paramStructure = func_get_args();
$paramStructure = array_slice($paramStructure, 2);
}
foreach($array as $v) {
$vv = phpQuery::callbackRun($callback, array($v), $paramStructure);
// $callbackArgs = $args;
// foreach($args as $i => $arg) {
// $callbackArgs[$i] = $arg instanceof CallbackParam
// ? $v
// : $arg;
// }
// $vv = call_user_func_array($callback, $callbackArgs);
if (is_array($vv)) {
foreach($vv as $vvv)
$result[] = $vvv;
} else if ($vv !== null) {
$result[] = $vv;
}
}
return $result;
}
/**
*
* @param $callback Callback
* @param $params
* @param $paramStructure
* @return unknown_type
*/
public static function callbackRun($callback, $params = array(), $paramStructure = null) {
if (! $callback)
return;
if ($callback instanceof CallbackParameterToReference) {
// TODO support ParamStructure to select which $param push to reference
if (isset($params[0]))
$callback->callback = $params[0];
return true;
}
if ($callback instanceof Callback) {
$paramStructure = $callback->params;
$callback = $callback->callback;
}
if (! $paramStructure)
return call_user_func_array($callback, $params);
$p = 0;
foreach($paramStructure as $i => $v) {
$paramStructure[$i] = $v instanceof CallbackParam
? $params[$p++]
: $v;
}
return call_user_func_array($callback, $paramStructure);
}
/**
* Merge 2 phpQuery objects.
* @param array $one
* @param array $two
* @protected
* @todo node lists, phpQueryObject
*/
public static function merge($one, $two) {
$elements = $one->elements;
foreach($two->elements as $node) {
$exists = false;
foreach($elements as $node2) {
if ($node2->isSameNode($node))
$exists = true;
}
if (! $exists)
$elements[] = $node;
}
return $elements;
// $one = $one->newInstance();
// $one->elements = $elements;
// return $one;
}
/**
*
* @param $array
* @param $callback
* @param $invert
* @return unknown_type
* @link http://docs.jquery.com/Utilities/jQuery.grep
*/
public static function grep($array, $callback, $invert = false) {
$result = array();
foreach($array as $k => $v) {
$r = call_user_func_array($callback, array($v, $k));
if ($r === !(bool)$invert)
$result[] = $v;
}
return $result;
}
public static function unique($array) {
return array_unique($array);
}
/**
*
* @param $function
* @return unknown_type
* @TODO there are problems with non-static methods, second parameter pass it
* but doesnt verify is method is really callable
*/
public static function isFunction($function) {
return is_callable($function);
}
public static function trim($str) {
return trim($str);
}
/* PLUGINS NAMESPACE */
/**
*
* @param $url
* @param $callback
* @param $param1
* @param $param2
* @param $param3
* @return phpQueryObject
*/
public static function browserGet($url, $callback, $param1 = null, $param2 = null, $param3 = null) {
if (self::plugin('WebBrowser')) {
$params = func_get_args();
return self::callbackRun(array(self::$plugins, 'browserGet'), $params);
} else {
self::debug('WebBrowser plugin not available...');
}
}
/**
*
* @param $url
* @param $data
* @param $callback
* @param $param1
* @param $param2
* @param $param3
* @return phpQueryObject
*/
public static function browserPost($url, $data, $callback, $param1 = null, $param2 = null, $param3 = null) {
if (self::plugin('WebBrowser')) {
$params = func_get_args();
return self::callbackRun(array(self::$plugins, 'browserPost'), $params);
} else {
self::debug('WebBrowser plugin not available...');
}
}
/**
*
* @param $ajaxSettings
* @param $callback
* @param $param1
* @param $param2
* @param $param3
* @return phpQueryObject
*/
public static function browser($ajaxSettings, $callback, $param1 = null, $param2 = null, $param3 = null) {
if (self::plugin('WebBrowser')) {
$params = func_get_args();
return self::callbackRun(array(self::$plugins, 'browser'), $params);
} else {
self::debug('WebBrowser plugin not available...');
}
}
/**
*
* @param $code
* @return string
*/
public static function php($code) {
return self::code('php', $code);
}
/**
*
* @param $type
* @param $code
* @return string
*/
public static function code($type, $code) {
return "<$type><!-- ".trim($code)." --></$type>";
}
public static function __callStatic($method, $params) {
return call_user_func_array(
array(phpQuery::$plugins, $method),
$params
);
}
protected static function dataSetupNode($node, $documentID) {
// search are return if alredy exists
foreach(phpQuery::$documents[$documentID]->dataNodes as $dataNode) {
if ($node->isSameNode($dataNode))
return $dataNode;
}
// if doesn't, add it
phpQuery::$documents[$documentID]->dataNodes[] = $node;
return $node;
}
protected static function dataRemoveNode($node, $documentID) {
// search are return if alredy exists
foreach(phpQuery::$documents[$documentID]->dataNodes as $k => $dataNode) {
if ($node->isSameNode($dataNode)) {
unset(self::$documents[$documentID]->dataNodes[$k]);
unset(self::$documents[$documentID]->data[ $dataNode->dataID ]);
}
}
}
public static function data($node, $name, $data, $documentID = null) {
if (! $documentID)
// TODO check if this works
$documentID = self::getDocumentID($node);
$document = phpQuery::$documents[$documentID];
$node = self::dataSetupNode($node, $documentID);
if (! isset($node->dataID))
$node->dataID = ++phpQuery::$documents[$documentID]->uuid;
$id = $node->dataID;
if (! isset($document->data[$id]))
$document->data[$id] = array();
if (! is_null($data))
$document->data[$id][$name] = $data;
if ($name) {
if (isset($document->data[$id][$name]))
return $document->data[$id][$name];
} else
return $id;
}
public static function removeData($node, $name, $documentID) {
if (! $documentID)
// TODO check if this works
$documentID = self::getDocumentID($node);
$document = phpQuery::$documents[$documentID];
$node = self::dataSetupNode($node, $documentID);
$id = $node->dataID;
if ($name) {
if (isset($document->data[$id][$name]))
unset($document->data[$id][$name]);
$name = null;
foreach($document->data[$id] as $name)
break;
if (! $name)
self::removeData($node, $name, $documentID);
} else {
self::dataRemoveNode($node, $documentID);
}
}
}
/**
* Plugins static namespace class.
*
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
* @todo move plugin methods here (as statics)
*/
class phpQueryPlugins {
public function __call($method, $args) {
if (isset(phpQuery::$extendStaticMethods[$method])) {
$return = call_user_func_array(
phpQuery::$extendStaticMethods[$method],
$args
);
} else if (isset(phpQuery::$pluginsStaticMethods[$method])) {
$class = phpQuery::$pluginsStaticMethods[$method];
$realClass = "phpQueryPlugin_$class";
$return = call_user_func_array(
array($realClass, $method),
$args
);
return isset($return)
? $return
: $this;
} else
throw new Exception("Method '{$method}' doesnt exist");
}
}
/**
* Shortcut to phpQuery::pq($arg1, $context)
* Chainable.
*
* @see phpQuery::pq()
* @return phpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
* @package phpQuery
*/
function pq($arg1, $context = null) {
$args = func_get_args();
return call_user_func_array(
array('phpQuery', 'pq'),
$args
);
}
// add plugins dir and Zend framework to include path
set_include_path(
get_include_path()
.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/'
.PATH_SEPARATOR.dirname(__FILE__).'/phpQuery/plugins/'
);
// why ? no __call nor __get for statics in php...
// XXX __callStatic will be available in PHP 5.3
phpQuery::$plugins = new phpQueryPlugins();
// include bootstrap file (personal library config)
if (file_exists(dirname(__FILE__).'/phpQuery/bootstrap.php')) require_once dirname(__FILE__).'/phpQuery/bootstrap.php';
$document = phpQuery::newDocumentHTML('HTML markup');
$container = pq('#container'); // Operates on the document loaded above
// Explicitly specifies which document to query
$secondDocument = phpQuery::newDocumentXHTML('HTML markup');
$container = pq('#container', $secondDocument);
// Queries the document with a specific ID
$thirdDocument = phpQuery::newDocumentXHTML('HTML markup');
$container = pq('#container', $thirdDocument->getDocumentID());
// Invoking the find method on a document corresponds to the pq method
$container = $thirdDocument->find('#container');
$document = phpQuery::newDocumentHTML('HTML markup');
// Selects all elements with a given class
$matches = $document->find('.some-class');
// Selects the element with a given ID
$match = $document->find('#some-id');
// Selects all input elements
$matches = $document->find(':input');
// Selects all text input elements
$matches = $document->find(':input[type=text]');
/* Selects input elements that have a "data-city" attribute with a value of "New York" */
$matches = $document->find('input[data-city="New York"]');
// Matches the first child of each table row
$matches = $document->find('tr:first-child');
$document = phpQuery::newDocumentHTML('HTML markup');
// Gets the element's value for the "class" attribute
$class = $document->find('#container')->attr('class');
// Sets the element's "class" attribute
$document->find('#container')->attr('class', 'my-container');
// Removes the "class" attribute
$document->find('#container')->removeAttr('class');
// Adds "my-container" to the element's "class" attribute
$document->find('#container')->addClass('my-container');
// Removes "my-container" from the element's "class" attribute
$document->find('#container')->removeClass('my-container');
// Gets the HTML content of the element
$html = $document->find('#container')->html();
// Sets the HTML content of the element
$document->find('#container')->html('HTML markup');
// Gets the text content of the element
// This function is similar to PHP's strip_tags function
$text = $document->find('#container')->text();
// Sets the element's text
$document->find('#container')->text('some text');
// Append content to an element
$document->find('#container')->append('some content');
// Prepend content to an element
$document->find('#container')->prepend('some content');
// Gets the value of the "value" attribute
$username = $document->find('#username-textbox')->val();
// Sets the value of the "value" attribute
$document->find('#username-textbox')->val('some value');
// Removes all child nodes
$document->find('#container')->empty();
