You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5702 lines
163 KiB
5702 lines
163 KiB
<?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'; |