6332 lines
217 KiB
PHP
6332 lines
217 KiB
PHP
<?php
|
|
/**
|
|
* NewsletterProphpQuery 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 NewsletterProphpQuery
|
|
*/
|
|
|
|
// class names for instanceof
|
|
// TODO move them as class constants into NewsletterProphpQuery
|
|
define('DOMDOCUMENT', 'DOMDocument');
|
|
define('DOMELEMENT', 'DOMElement');
|
|
define('DOMNODELIST', 'DOMNodeList');
|
|
define('DOMNODE', 'DOMNode');
|
|
|
|
/**
|
|
* NewsletterProDOMEvent class.
|
|
*
|
|
* Based on
|
|
* @link http://developer.mozilla.org/En/DOM:event
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
* @package NewsletterProphpQuery
|
|
* @todo implement ArrayAccess ?
|
|
*/
|
|
class NewsletterProDOMEvent
|
|
{
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* NewsletterProDOMDocumentWrapper 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 NewsletterProphpQuery
|
|
*/
|
|
class NewsletterProDOMDocumentWrapper
|
|
{
|
|
/**
|
|
* @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)
|
|
{
|
|
// NewsletterProphpQuery::$documents[$id] = $this;
|
|
$this->contentType = Tools::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 NewsletterProphpQuery::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':
|
|
NewsletterProphpQuery::debug("Loading HTML, content type '{$this->contentType}'");
|
|
$loaded = $this->loadMarkupHTML($markup, $charset);
|
|
break;
|
|
case 'text/xml':
|
|
case 'application/xhtml+xml':
|
|
NewsletterProphpQuery::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) {
|
|
NewsletterProphpQuery::debug("Loading XML, content type '{$this->contentType}'");
|
|
$loaded = $this->loadMarkupXML($markup, $charset);
|
|
} else {
|
|
NewsletterProphpQuery::debug("Could not determine document type from content type '{$this->contentType}'");
|
|
}
|
|
}
|
|
} else {
|
|
// content type autodetection
|
|
if ($this->isXML($markup)) {
|
|
NewsletterProphpQuery::debug("Loading XML, isXML() == true");
|
|
$loaded = $this->loadMarkupXML($markup);
|
|
if (! $loaded && $this->isXHTML) {
|
|
NewsletterProphpQuery::debug('Loading as XML failed, trying to load as HTML, isXHTML == true');
|
|
$loaded = $this->loadMarkupHTML($markup);
|
|
}
|
|
} else {
|
|
NewsletterProphpQuery::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 (NewsletterProphpQuery::$debug) {
|
|
NewsletterProphpQuery::debug('Full markup load (HTML): '.Tools::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);
|
|
} elseif ($requestedCharset) {
|
|
$charset = $requestedCharset;
|
|
}
|
|
if (! $charset) {
|
|
$charset = NewsletterProphpQuery::$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 = Tools::strtoupper($requestedCharset);
|
|
$documentCharset = Tools::strtoupper($documentCharset);
|
|
NewsletterProphpQuery::debug("DOC: $documentCharset REQ: $requestedCharset");
|
|
if ($requestedCharset && $documentCharset && $requestedCharset !== $documentCharset) {
|
|
NewsletterProphpQuery::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
|
|
NewsletterProphpQuery::debug("DETECTED '$docEncoding'");
|
|
// Detected does not match what document says...
|
|
if ($docEncoding !== $documentCharset) {
|
|
// Tricky..
|
|
}
|
|
if ($docEncoding !== $requestedCharset) {
|
|
NewsletterProphpQuery::debug("CONVERT $docEncoding => $requestedCharset");
|
|
$markup = mb_convert_encoding($markup, $requestedCharset, $docEncoding);
|
|
$markup = $this->charsetAppendToHTML($markup, $requestedCharset);
|
|
$charset = $requestedCharset;
|
|
}
|
|
} else {
|
|
NewsletterProphpQuery::debug("TODO: charset conversion without mbstring...");
|
|
}
|
|
}
|
|
$return = false;
|
|
if ($this->isDocumentFragment) {
|
|
NewsletterProphpQuery::debug("Full markup load (HTML), DocumentFragment detected, using charset '$charset'");
|
|
$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
|
|
} else {
|
|
if ($addDocumentCharset) {
|
|
NewsletterProphpQuery::debug("Full markup load (HTML), appending charset: '$charset'");
|
|
$markup = $this->charsetAppendToHTML($markup, $charset);
|
|
}
|
|
NewsletterProphpQuery::debug("Full markup load (HTML), documentCreate('$charset')");
|
|
$this->documentCreate($charset);
|
|
$return = NewsletterProphpQuery::$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 (NewsletterProphpQuery::$debug) {
|
|
NewsletterProphpQuery::debug('Full markup load (XML): '.Tools::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) {
|
|
NewsletterProphpQuery::debug("Full markup load (XML), appending XHTML charset '$documentCharset'");
|
|
$this->charsetAppendToXML($markup, $documentCharset);
|
|
$charset = $documentCharset;
|
|
}
|
|
}
|
|
if (! $documentCharset) {
|
|
// if still no document charset...
|
|
$charset = $requestedCharset;
|
|
}
|
|
} elseif ($requestedCharset) {
|
|
$charset = $requestedCharset;
|
|
}
|
|
if (! $charset) {
|
|
$charset = NewsletterProphpQuery::$defaultCharset;
|
|
}
|
|
if ($requestedCharset && $documentCharset && $requestedCharset != $documentCharset) {
|
|
// TODO place for charset conversion
|
|
// $charset = $requestedCharset;
|
|
}
|
|
$return = false;
|
|
if ($this->isDocumentFragment) {
|
|
NewsletterProphpQuery::debug("Full markup load (XML), DocumentFragment detected, using charset '$charset'");
|
|
$return = $this->documentFragmentLoadMarkup($this, $charset, $markup);
|
|
} else {
|
|
// FIXME ???
|
|
if ($isContentTypeXHTML && ! $isMarkupXHTML) {
|
|
if (! $documentCharset) {
|
|
NewsletterProphpQuery::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 = NewsletterProphpQuery::$debug === 2
|
|
? $this->document->loadXML($markup)
|
|
: @$this->document->loadXML($markup);
|
|
} else {
|
|
/** @link http://pl2.php.net/manual/en/libxml.constants.php */
|
|
$libxmlStatic = NewsletterProphpQuery::$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(Tools::substr($markup, 0, 100), '<'.'?xml') !== false;
|
|
}
|
|
protected function contentTypeToArray($contentType)
|
|
{
|
|
$matches = explode(';', trim(Tools::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 = array();
|
|
// find declaration
|
|
preg_match(
|
|
'@<'.'?xml[^>]+encoding\\s*=\\s*(["|\'])(.*?)\\1@i',
|
|
$markup,
|
|
$matches
|
|
);
|
|
return isset($matches[2])
|
|
? Tools::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 = Tools::substr($markup, 0, $matches[0][1])
|
|
.Tools::substr($markup, $matches[0][1]+Tools::strlen($metaContentType));
|
|
$headStart = stripos($markup, '<head>');
|
|
$markup = Tools::substr($markup, 0, $headStart+6).$metaContentType
|
|
.Tools::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) {
|
|
$hltml = '';
|
|
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 NewsletterProDOMDocumentWrapper
|
|
*/
|
|
protected function documentFragmentCreate($source, $charset = null)
|
|
{
|
|
$fake = new NewsletterProDOMDocumentWrapper();
|
|
$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 NewsletterProDOMDocumentWrapper
|
|
* @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 = NewsletterProphpQuery::$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)
|
|
{
|
|
NewsletterProphpQuery::debug('documentFragmentToMarkup');
|
|
$tmp = $fragment->isDocumentFragment;
|
|
$fragment->isDocumentFragment = false;
|
|
$markup = $fragment->markup();
|
|
if ($fragment->isXML) {
|
|
$markup = Tools::substr($markup, 0, strrpos($markup, '</fake>'));
|
|
if ($fragment->isXHTML) {
|
|
$markup = Tools::substr($markup, strpos($markup, '<fake')+43);
|
|
} else {
|
|
$markup = Tools::substr($markup, strpos($markup, '<fake>')+6);
|
|
}
|
|
} else {
|
|
$markup = Tools::substr($markup, strpos($markup, '<body>')+6);
|
|
$markup = Tools::substr($markup, 0, strrpos($markup, '</body>'));
|
|
}
|
|
$fragment->isDocumentFragment = $tmp;
|
|
if (NewsletterProphpQuery::$debug) {
|
|
NewsletterProphpQuery::debug('documentFragmentToMarkup: '.Tools::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)
|
|
+ NewsletterProphpQuery::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: ".Tools::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: ".Tools::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)
|
|
{
|
|
NewsletterProphpQuery::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< Tools::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 NewsletterProphpQuery
|
|
* @static
|
|
*/
|
|
abstract class NewsletterProphpQueryEvents
|
|
{
|
|
/**
|
|
* Trigger a type of event on every matched element.
|
|
*
|
|
* @param DOMNode|NewsletterProphpQueryObject|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 = NewsletterProphpQuery::getDocumentID($document);
|
|
$namespace = null;
|
|
if (strpos($type, '.') !== false) {
|
|
list($name, $namespace) = explode('.', $type);
|
|
} else {
|
|
$name = $type;
|
|
}
|
|
if (! $node) {
|
|
if (self::issetGlobal($documentID, $type)) {
|
|
$pq = NewsletterProphpQuery::getDocument($documentID);
|
|
// TODO check add($pq->document)
|
|
$pq->find('*')->add($pq->document)
|
|
->trigger($type, $data);
|
|
}
|
|
} else {
|
|
if (isset($data[0]) && $data[0] instanceof NewsletterProDOMEvent) {
|
|
$event = $data[0];
|
|
$event->relatedTarget = $event->target;
|
|
$event->target = $node;
|
|
$data = array_slice($data, 1);
|
|
} else {
|
|
$event = new NewsletterProDOMEvent(array(
|
|
'type' => $type,
|
|
'target' => $node,
|
|
'timeStamp' => time(),
|
|
));
|
|
}
|
|
$i = 0;
|
|
while ($node) {
|
|
// TODO whois
|
|
NewsletterProphpQuery::debug("Triggering ".($i?"bubbled ":'')."event '{$type}' on "
|
|
."node \n");//.NewsletterProphpQueryObject::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) {
|
|
NewsletterProphpQuery::debug("Calling event handler\n");
|
|
$event->data = $handler['data']
|
|
? $handler['data']
|
|
: null;
|
|
$params = array_merge(array($event), $data);
|
|
$return = NewsletterProphpQuery::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|NewsletterProphpQueryObject|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)
|
|
{
|
|
NewsletterProphpQuery::debug("Binding '$type' event");
|
|
$documentID = NewsletterProphpQuery::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|NewsletterProphpQueryObject|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 = NewsletterProphpQuery::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 (NewsletterProphpQuery::$documents[$documentID]->eventsNodes as $eventNode) {
|
|
if ($node->isSameNode($eventNode)) {
|
|
return $eventNode;
|
|
}
|
|
}
|
|
}
|
|
protected static function setNode($documentID, $node)
|
|
{
|
|
NewsletterProphpQuery::$documents[$documentID]->eventsNodes[] = $node;
|
|
return NewsletterProphpQuery::$documents[$documentID]->eventsNodes[
|
|
count(NewsletterProphpQuery::$documents[$documentID]->eventsNodes)-1
|
|
];
|
|
}
|
|
protected static function issetGlobal($documentID, $type)
|
|
{
|
|
return isset(NewsletterProphpQuery::$documents[$documentID])
|
|
? in_array($type, NewsletterProphpQuery::$documents[$documentID]->eventsGlobal)
|
|
: false;
|
|
}
|
|
}
|
|
|
|
|
|
interface NewsletterProICallbackNamed
|
|
{
|
|
public function hasName();
|
|
public function getName();
|
|
}
|
|
/**
|
|
* NewsletterProCallback class introduces currying-like pattern.
|
|
*
|
|
* Example:
|
|
* function foo($param1, $param2, $param3) {
|
|
* var_dump($param1, $param2, $param3);
|
|
* }
|
|
* $fooCurried = new NewsletterProCallback('foo',
|
|
* 'param1 is now statically set',
|
|
* new NewsletterProCallbackParam, new NewsletterProCallbackParam
|
|
* );
|
|
* NewsletterProphpQuery::callbackRun($fooCurried,
|
|
* array('param2 value', 'param3 value'
|
|
* );
|
|
*
|
|
* NewsletterProCallback class is supported in all NewsletterProphpQuery 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 NewsletterProCallback implements NewsletterProICallbackNamed
|
|
{
|
|
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 NewsletterProCallback) {
|
|
// TODO implement recurention
|
|
} else {
|
|
$this->callback = $callback;
|
|
$this->params = $params;
|
|
}
|
|
}
|
|
public function getName()
|
|
{
|
|
return 'NewsletterProCallback: '.$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 NewsletterProCallback($this->callback, $this->params+$params);
|
|
// }
|
|
}
|
|
/**
|
|
* Shorthand for new NewsletterProCallback(create_function(...), ...);
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
*/
|
|
class NewsletterProCallbackBody extends NewsletterProCallback
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
/**
|
|
* NewsletterProCallback type which on execution returns reference passed during creation.
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
*/
|
|
class NewsletterProCallbackReturnReference extends NewsletterProCallback implements NewsletterProICallbackNamed
|
|
{
|
|
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 'NewsletterProCallback: '.$this->name;
|
|
}
|
|
public function hasName()
|
|
{
|
|
return isset($this->name) && $this->name;
|
|
}
|
|
}
|
|
/**
|
|
* NewsletterProCallback type which on execution returns value passed during creation.
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
*/
|
|
class NewsletterProCallbackReturnValue extends NewsletterProCallback implements NewsletterProICallbackNamed
|
|
{
|
|
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 'NewsletterProCallback: '.$this->name;
|
|
}
|
|
public function hasName()
|
|
{
|
|
return isset($this->name) && $this->name;
|
|
}
|
|
}
|
|
/**
|
|
* NewsletterProCallbackParameterToReference can be used when we don't really want a callback,
|
|
* only parameter passed to it. NewsletterProCallbackParameterToReference takes first
|
|
* parameter's value and passes it to reference.
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
*/
|
|
class NewsletterProCallbackParameterToReference extends NewsletterProCallback
|
|
{
|
|
/**
|
|
* @param $reference
|
|
* @TODO implement $paramIndex;
|
|
* param index choose which callback param will be passed to reference
|
|
*/
|
|
public function __construct(&$reference)
|
|
{
|
|
$this->callback =& $reference;
|
|
}
|
|
}
|
|
//class NewsletterProCallbackReference extends NewsletterProCallback {
|
|
// /**
|
|
// *
|
|
// * @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 NewsletterProCallbackParam
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Class representing NewsletterProphpQuery objects.
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
* @package NewsletterProphpQuery
|
|
* @method NewsletterProphpQueryObject clone() clone()
|
|
* @method NewsletterProphpQueryObject empty() empty()
|
|
* @method NewsletterProphpQueryObject next() next($selector = null)
|
|
* @method NewsletterProphpQueryObject prev() prev($selector = null)
|
|
* @property Int $length
|
|
*/
|
|
class NewsletterProphpQueryObject implements Iterator, Countable, ArrayAccess
|
|
{
|
|
public $documentID = null;
|
|
/**
|
|
* DOMDocument class.
|
|
*
|
|
* @var DOMDocument
|
|
*/
|
|
public $document = null;
|
|
public $charset = null;
|
|
/**
|
|
*
|
|
* @var NewsletterProDOMDocumentWrapper
|
|
*/
|
|
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 NewsletterProphpQueryObject|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(NewsletterProphpQuery::$documents[$id])) {
|
|
// var_dump(NewsletterProphpQuery::$documents);
|
|
throw new Exception("Document with ID '{$id}' isn't loaded. Use NewsletterProphpQuery::newDocument(\$html) or NewsletterProphpQuery::newDocumentFile(\$file) first.");
|
|
}
|
|
$this->documentID = $id;
|
|
$this->documentWrapper =& NewsletterProphpQuery::$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 NewsletterProphpQueryObject $var
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function toReference(&$var)
|
|
{
|
|
return $var = $this;
|
|
}
|
|
public function documentFragment($state = null)
|
|
{
|
|
if ($state) {
|
|
NewsletterProphpQuery::$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 NewsletterProphpQueryObject|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;
|
|
* NewsletterProphpQuery::newDocument('<div/>')
|
|
* ->getDocumentIDRef($myDocumentId)
|
|
* ->find('div')->...
|
|
* </code>
|
|
*
|
|
* @param unknown_type $domId
|
|
* @see NewsletterProphpQuery::newDocument
|
|
* @see NewsletterProphpQuery::newDocumentFile
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function getDocumentIDRef(&$documentID)
|
|
{
|
|
$documentID = $this->getDocumentID();
|
|
return $this;
|
|
}
|
|
/**
|
|
* Returns object with stack set to document root.
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function getDocument()
|
|
{
|
|
return NewsletterProphpQuery::getDocument($this->getDocumentID());
|
|
}
|
|
/**
|
|
*
|
|
* @return DOMDocument
|
|
*/
|
|
public function getDOMDocument()
|
|
{
|
|
return $this->document;
|
|
}
|
|
/**
|
|
* Get object's Document ID.
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function unloadDocument()
|
|
{
|
|
NewsletterProphpQuery::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 NewsletterProphpQuery::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 = NewsletterProphpQuery::pq_newsletterpro($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;
|
|
} elseif (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 (! NewsletterProphpQuery::$debug) {
|
|
return;
|
|
}
|
|
print('<pre>');
|
|
print_r($in);
|
|
// file debug
|
|
// file_put_contents(dirname(__FILE__).'/NewsletterProphpQuery.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') && NewsletterProphpQuery::$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
|
|
} elseif ($c == '#') {
|
|
$i++;
|
|
while (isset($query[$i]) && ($this->isChar($query[$i]) || $query[$i] == '-')) {
|
|
$tmp .= $query[$i];
|
|
$i++;
|
|
}
|
|
$return[] = '#'.$tmp;
|
|
// SPECIAL CHARS
|
|
} elseif (in_array($c, $specialChars)) {
|
|
$return[] = $c;
|
|
$i++;
|
|
// MAPPED SPECIAL MULTICHARS
|
|
// } else if ( $c.$query[$i+1] == '//') {
|
|
// $return[] = ' ';
|
|
// $i = $i+2;
|
|
// MAPPED SPECIAL CHARS
|
|
} elseif (isset($specialCharsMapping[$c])) {
|
|
$return[] = $specialCharsMapping[$c];
|
|
$i++;
|
|
// COMMA
|
|
} elseif ($c == ',') {
|
|
$queries[] = array();
|
|
$return =& $queries[ count($queries)-1 ];
|
|
$i++;
|
|
while (isset($query[$i]) && $query[$i] == ' ') {
|
|
$i++;
|
|
}
|
|
// CLASSES
|
|
} elseif ($c == '.') {
|
|
while (isset($query[$i]) && ($this->isChar($query[$i]) || in_array($query[$i], $classChars))) {
|
|
$tmp .= $query[$i];
|
|
$i++;
|
|
}
|
|
$return[] = $tmp;
|
|
// ~ General Sibling Selector
|
|
} elseif ($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
|
|
} elseif ($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
|
|
} elseif ($c == '[') {
|
|
$stack = 1;
|
|
$tmp .= $c;
|
|
while (isset($query[++$i])) {
|
|
$tmp .= $query[$i];
|
|
if ($query[$i] == '[') {
|
|
$stack++;
|
|
} elseif ($query[$i] == ']') {
|
|
$stack--;
|
|
if (! $stack) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
$return[] = $tmp;
|
|
$i++;
|
|
// PSEUDO CLASSES
|
|
} elseif ($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++;
|
|
} elseif ($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] = NewsletterProphpQuery::callbackRun($callback, array($v));
|
|
}
|
|
} else {
|
|
$return = NewsletterProphpQuery::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 = NewsletterProphpQuery::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] = NewsletterProphpQuery::callbackRun($callback, array($v));
|
|
}
|
|
} else {
|
|
$return = NewsletterProphpQuery::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 != 'NewsletterProphpQuery'
|
|
? new $class($this, $this->getDocumentID())
|
|
: new NewsletterProphpQueryObject($this->getDocumentID());
|
|
$new->previous = $this;
|
|
if (is_null($newStack)) {
|
|
$new->elements = $this->elements;
|
|
if ($this->elementsBackup) {
|
|
$this->elements = $this->elementsBackup;
|
|
}
|
|
} elseif (is_string($newStack)) {
|
|
$new->elements = NewsletterProphpQuery::pq_newsletterpro($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('.', Tools::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
|
|
Tools::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) {
|
|
NewsletterProphpQuery::$debug ?
|
|
$this->debug("Found: ".$this->whois($node).", comparing with {$compare}()")
|
|
: null;
|
|
$phpQueryDebug = NewsletterProphpQuery::$debug;
|
|
NewsletterProphpQuery::$debug = false;
|
|
// TODO ??? use NewsletterProphpQuery::callbackRun()
|
|
if (call_user_func_array(array($this, $compare), array($selector, $node))) {
|
|
$matched = true;
|
|
}
|
|
NewsletterProphpQuery::$debug = $phpQueryDebug;
|
|
} else {
|
|
$matched = true;
|
|
}
|
|
if ($matched) {
|
|
if (NewsletterProphpQuery::$debug) {
|
|
$debug[] = $this->whois($node);
|
|
}
|
|
$stack[] = $node;
|
|
}
|
|
}
|
|
if (NewsletterProphpQuery::$debug) {
|
|
$this->debug("Matched ".count($debug).": ".implode(', ', $debug));
|
|
}
|
|
if ($detachAfter) {
|
|
$this->root->removeChild($detachAfter);
|
|
}
|
|
}
|
|
$this->elements = $stack;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQuery::pq_newsletterpro() context guessing code
|
|
// as generic function
|
|
if ($context) {
|
|
if (! is_array($context) && $context instanceof DOMELEMENT) {
|
|
$this->elements = array($context);
|
|
} elseif (is_array($context)) {
|
|
$this->elements = array();
|
|
foreach ($context as $c) {
|
|
if ($c instanceof DOMELEMENT) {
|
|
$this->elements[] = $c;
|
|
}
|
|
}
|
|
} elseif ($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') && NewsletterProphpQuery::$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";
|
|
} elseif ($s == '*') {
|
|
$XQuery .= "*";
|
|
} else {
|
|
$XQuery .= "*[local-name()='$s']";
|
|
}
|
|
} else {
|
|
$XQuery .= $s;
|
|
}
|
|
// ID
|
|
} elseif ($s[0] == '#') {
|
|
if ($delimiterBefore) {
|
|
$XQuery .= '*';
|
|
}
|
|
$XQuery .= "[@id='".Tools::substr($s, 1)."']";
|
|
// ATTRIBUTES
|
|
} elseif ($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 = Tools::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
|
|
} elseif ($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
|
|
} elseif ($s[0] == '~') {
|
|
$this->runQuery($XQuery);
|
|
$XQuery = '';
|
|
$this->elements = $this
|
|
->siblings(
|
|
Tools::substr($s, 1)
|
|
)->elements;
|
|
if (! $this->length()) {
|
|
break;
|
|
}
|
|
// + Adjacent sibling selectors
|
|
} elseif ($s[0] == '+') {
|
|
// TODO /following-sibling::
|
|
$this->runQuery($XQuery);
|
|
$XQuery = '';
|
|
$subSelector = Tools::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
|
|
} elseif ($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
|
|
} elseif ($s == '>') {
|
|
$XQuery .= '/';
|
|
$delimiterBefore = 2;
|
|
// ALL DESCENDANDS
|
|
} elseif ($s == ' ') {
|
|
$XQuery .= '//';
|
|
$delimiterBefore = 2;
|
|
// ERRORS
|
|
} else {
|
|
NewsletterProphpQuery::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 = Tools::substr($class, $haveArgs+1, -1);
|
|
$class = Tools::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;
|
|
} elseif ($class == 'odd' && $i % 2) {
|
|
$stack[] = $node;
|
|
}
|
|
}
|
|
$this->elements = $stack;
|
|
break;
|
|
case 'eq':
|
|
$k = (int)$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 = NewsletterProphpQuery::merge(
|
|
$this->map(
|
|
array($this, 'is'),
|
|
"input[type=$class]",
|
|
new NewsletterProCallbackParam()
|
|
),
|
|
$this->map(
|
|
array($this, 'is'),
|
|
"button[type=$class]",
|
|
new NewsletterProCallbackParam()
|
|
)
|
|
);
|
|
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 NewsletterProCallbackParam()
|
|
)->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 NewsletterProCallbackParam()
|
|
)->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 NewsletterProCallbackParam()
|
|
)->elements;
|
|
break;
|
|
case 'enabled':
|
|
$this->elements = $this->map(
|
|
create_function('$node', '
|
|
return pq_newsletterpro($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_newsletterpro($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_newsletterpro($node)->siblings()->size() == 0 ? $node : null;'
|
|
)
|
|
)->elements;
|
|
break;
|
|
case 'first-child':
|
|
$this->elements = $this->map(
|
|
create_function('$node', 'return pq_newsletterpro($node)->prevAll()->size() == 0 ? $node : null;')
|
|
)->elements;
|
|
break;
|
|
case 'last-child':
|
|
$this->elements = $this->map(
|
|
create_function('$node', 'return pq_newsletterpro($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_newsletterpro($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 NewsletterProCallbackParam(),
|
|
$param
|
|
);
|
|
} elseif (mb_strlen($param) > 1 && $param[1] == 'n') {
|
|
// an+b
|
|
$mapped = $this->map(
|
|
create_function(
|
|
'$node, $param',
|
|
'$prevs = pq_newsletterpro($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;
|
|
NewsletterProphpQuery::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 NewsletterProCallbackParam(),
|
|
$param
|
|
);
|
|
} else {
|
|
// index
|
|
$mapped = $this->map(
|
|
create_function(
|
|
'$node, $index',
|
|
'$prevs = pq_newsletterpro($node)->prevAll()->size();
|
|
if ($prevs && $prevs == $index-1)
|
|
return $node;
|
|
else if (! $prevs && $index == 1)
|
|
return $node;
|
|
else
|
|
return null;'
|
|
),
|
|
new NewsletterProCallbackParam(),
|
|
$param
|
|
);
|
|
}
|
|
$this->elements = $mapped->elements;
|
|
break;
|
|
default:
|
|
$this->debug("Unknown pseudoclass '{$class}', skipping...");
|
|
}
|
|
}
|
|
/**
|
|
* @access private
|
|
*/
|
|
protected function __pseudoClassParam($paramsString)
|
|
{
|
|
// TODO;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function is($selector, $nodes = null)
|
|
{
|
|
NewsletterProphpQuery::debug(array("Is:", $selector));
|
|
if (! $selector) {
|
|
return false;
|
|
}
|
|
$oldStack = $this->elements;
|
|
$returnArray = false;
|
|
if ($nodes && is_array($nodes)) {
|
|
$this->elements = $nodes;
|
|
} elseif ($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.
|
|
*
|
|
* NewsletterProCallback:
|
|
* - $index int
|
|
* - $node DOMNode
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 = NewsletterProphpQuery::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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @link http://docs.jquery.com/Traversing/filter
|
|
*/
|
|
public function filter($selectors, $_skipHistory = false)
|
|
{
|
|
if ($selectors instanceof NewsletterProCallback 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') != Tools::substr($s, 1)) {
|
|
$break = true;
|
|
}
|
|
// CLASSES
|
|
} elseif ($s[0] == '.') {
|
|
if (! $this->matchClasses($s, $node)) {
|
|
$break = true;
|
|
}
|
|
// ATTRS
|
|
} elseif ($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;
|
|
}
|
|
} elseif ($this->isRegexp($attr)) {
|
|
$val = extension_loaded('mbstring') && NewsletterProphpQuery::$mbstringSupport
|
|
? quotemeta(trim($val, '"\''))
|
|
: preg_quote(trim($val, '"\''), '@');
|
|
// switch last character
|
|
switch (Tools::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 = Tools::substr($attr, 0, -1);
|
|
$isMatch = extension_loaded('mbstring') && NewsletterProphpQuery::$mbstringSupport
|
|
? mb_ereg_match($pattern, $node->getAttribute($attr))
|
|
: preg_match("@{$pattern}@", $node->getAttribute($attr));
|
|
if (! $isMatch) {
|
|
$break = true;
|
|
}
|
|
} elseif ($node->getAttribute($attr) != $val) {
|
|
$break = true;
|
|
}
|
|
} elseif (! $node->hasAttribute($attr)) {
|
|
$break = true;
|
|
}
|
|
// PSEUDO CLASSES
|
|
} elseif ($s[0] == ':') {
|
|
// skip
|
|
// TAG
|
|
} elseif (trim($s)) {
|
|
if ($s != '*') {
|
|
// TODO namespaces
|
|
if (isset($node->tagName)) {
|
|
if ($node->tagName != $s) {
|
|
$break = true;
|
|
}
|
|
} elseif ($s == 'html' && ! $this->isRoot($node)) {
|
|
$break = true;
|
|
}
|
|
}
|
|
// AVOID NON-SIMPLE SELECTORS
|
|
} elseif (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] == '"'
|
|
? Tools::substr($value, 1, -1)
|
|
: $value;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @link http://docs.jquery.com/Ajax/load
|
|
* @return NewsletterProphpQuery|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') && NewsletterProphpQuery::$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')
|
|
);
|
|
NewsletterProphpQuery::ajax($ajax);
|
|
return $this;
|
|
}
|
|
/**
|
|
* @access private
|
|
* @param $html
|
|
* @return unknown_type
|
|
*/
|
|
public function __loadSuccess($html)
|
|
{
|
|
if ($this->_loadSelector) {
|
|
$html = NewsletterProphpQuery::newDocument($html)->find($this->_loadSelector);
|
|
unset($this->_loadSelector);
|
|
}
|
|
foreach ($this->stack(1) as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())
|
|
->markup($html);
|
|
}
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQuery|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @TODO support more than event in $type (space-separated)
|
|
*/
|
|
public function trigger($type, $data = array())
|
|
{
|
|
foreach ($this->elements as $node) {
|
|
NewsletterProphpQueryEvents::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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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) {
|
|
NewsletterProphpQueryEvents::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) {
|
|
NewsletterProphpQueryEvents::remove($this->getDocumentID(), $node, $type, $callback);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function change($callback = null)
|
|
{
|
|
if ($callback) {
|
|
return $this->bind('change', $callback);
|
|
}
|
|
return $this->trigger('change');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function submit($callback = null)
|
|
{
|
|
if ($callback) {
|
|
return $this->bind('submit', $callback);
|
|
}
|
|
return $this->trigger('submit');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function click($callback = null)
|
|
{
|
|
if ($callback) {
|
|
return $this->bind('click', $callback);
|
|
}
|
|
return $this->trigger('click');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrapAllOld($wrapper)
|
|
{
|
|
$wrapper = pq_newsletterpro($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_newsletterpro($deepest)->append($this);
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* TODO testme...
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrapAll($wrapper)
|
|
{
|
|
if (! $this->length()) {
|
|
return $this;
|
|
}
|
|
return NewsletterProphpQuery::pq_newsletterpro($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|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|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|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrap($wrapper)
|
|
{
|
|
foreach ($this->stack() as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())->wrapAll($wrapper);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrapPHP($codeBefore, $codeAfter)
|
|
{
|
|
foreach ($this->stack() as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())->wrapAllPHP($codeBefore, $codeAfter);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrapInner($wrapper)
|
|
{
|
|
foreach ($this->stack() as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())->contents()->wrapAll($wrapper);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function wrapInnerPHP($codeBefore, $codeAfter)
|
|
{
|
|
foreach ($this->stack(1) as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())->contents()
|
|
->wrapAllPHP($codeBefore, $codeAfter);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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_newsletterpro($markup, $this->getDocumentID());
|
|
$content = null;
|
|
foreach ($this->stack(1) as $node) {
|
|
pq_newsletterpro($node)
|
|
->contents()->toReference($content)->end()
|
|
->replaceWith($markup->clone()->append($content));
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function size()
|
|
{
|
|
return count($this->elements);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @deprecated Use length as attribute
|
|
*/
|
|
public function length()
|
|
{
|
|
return $this->size();
|
|
}
|
|
public function count()
|
|
{
|
|
return $this->size();
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function replaceWithPHP($code)
|
|
{
|
|
return $this->replaceWith(NewsletterProphpQuery::php($code));
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery $content
|
|
* @link http://docs.jquery.com/Manipulation/replaceWith#content
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function replaceWith($content)
|
|
{
|
|
return $this->after($content)->remove();
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String $selector
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @todo this works ?
|
|
*/
|
|
public function replaceAll($selector)
|
|
{
|
|
foreach (NewsletterProphpQuery::pq_newsletterpro($selector, $this->getDocumentID()) as $node) {
|
|
NewsletterProphpQuery::pq_newsletterpro($node, $this->getDocumentID())
|
|
->after($this->_clone())
|
|
->remove();
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProDOMEvent(array(
|
|
'target' => $node,
|
|
'type' => 'DOMNodeRemoved'
|
|
));
|
|
NewsletterProphpQueryEvents::trigger(
|
|
$this->getDocumentID(),
|
|
$event->type,
|
|
array($event),
|
|
$node
|
|
);
|
|
}
|
|
return $this;
|
|
}
|
|
protected function markupEvents($newMarkup, $oldMarkup, $node)
|
|
{
|
|
if ($node->tagName == 'textarea' && $newMarkup != $oldMarkup) {
|
|
$event = new NewsletterProDOMEvent(array(
|
|
'target' => $node,
|
|
'type' => 'change'
|
|
));
|
|
NewsletterProphpQueryEvents::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|NewsletterProphpQuery|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_newsletterpro($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 = NewsletterProphpQuery::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 = NewsletterProphpQuery::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 NewsletterProphpQueryObject|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(NewsletterProphpQuery::php($code))
|
|
: NewsletterProphpQuery::markupToPHP($this->markup());
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param $code
|
|
* @return unknown_type
|
|
*/
|
|
public function markupOuterPHP()
|
|
{
|
|
return NewsletterProphpQuery::markupToPHP($this->markupOuter());
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function ancestors($selector = null)
|
|
{
|
|
return $this->children($selector);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function append($content)
|
|
{
|
|
return $this->insert($content, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function appendPHP($content)
|
|
{
|
|
return $this->insert("<php><!-- {$content} --></php>", 'append');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function appendTo($seletor)
|
|
{
|
|
return $this->insert($seletor, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function prependPHP($content)
|
|
{
|
|
return $this->insert("<php><!-- {$content} --></php>", 'prepend');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function prependTo($seletor)
|
|
{
|
|
return $this->insert($seletor, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function before($content)
|
|
{
|
|
return $this->insert($content, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function beforePHP($content)
|
|
{
|
|
return $this->insert("<php><!-- {$content} --></php>", 'before');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param String|NewsletterProphpQuery
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function insertBefore($seletor)
|
|
{
|
|
return $this->insert($seletor, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function after($content)
|
|
{
|
|
return $this->insert($content, __FUNCTION__);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function afterPHP($content)
|
|
{
|
|
return $this->insert("<php><!-- {$content} --></php>", 'after');
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 (NewsletterProphpQuery::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();
|
|
// NewsletterProphpQuery
|
|
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;
|
|
}
|
|
NewsletterProphpQuery::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 NewsletterProDOMEvent(array(
|
|
'target' => $insert,
|
|
'type' => 'DOMNodeInserted'
|
|
));
|
|
NewsletterProphpQueryEvents::trigger(
|
|
$this->getDocumentID(),
|
|
$event->type,
|
|
array($event),
|
|
$insert
|
|
);
|
|
}
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return Int
|
|
*/
|
|
public function index($subject)
|
|
{
|
|
$index = -1;
|
|
$subject = $subject instanceof NewsletterProphpQueryObject
|
|
? $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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 = NewsletterProphpQuery::callbackRun($callback, array($text));
|
|
}
|
|
$return .= $text;
|
|
}
|
|
return $return;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function plugin($class, $file = null)
|
|
{
|
|
NewsletterProphpQuery::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(NewsletterProphpQuery::$extendMethods[$method])) {
|
|
array_unshift($args, $this);
|
|
return NewsletterProphpQuery::callbackRun(
|
|
NewsletterProphpQuery::$extendMethods[$method],
|
|
$args
|
|
);
|
|
} elseif (isset(NewsletterProphpQuery::$pluginsMethods[$method])) {
|
|
array_unshift($args, $this);
|
|
$class = NewsletterProphpQuery::$pluginsMethods[$method];
|
|
$realClass = "phpQueryObjectPlugin_$class";
|
|
$return = call_user_func_array(
|
|
array($realClass, $method),
|
|
$args
|
|
);
|
|
// XXX deprecate ?
|
|
return is_null($return)
|
|
? $this
|
|
: $return;
|
|
} elseif (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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @access private
|
|
*/
|
|
public function _next($selector = null)
|
|
{
|
|
return $this->newInstance(
|
|
$this->getElementSiblings('nextSibling', $selector, true)
|
|
);
|
|
}
|
|
/**
|
|
* Use prev() and next().
|
|
*
|
|
* @deprecated
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @access private
|
|
*/
|
|
public function _prev($selector = null)
|
|
{
|
|
return $this->prev($selector);
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function prev($selector = null)
|
|
{
|
|
return $this->newInstance(
|
|
$this->getElementSiblings('previousSibling', $selector, true)
|
|
);
|
|
}
|
|
/**
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @todo
|
|
*/
|
|
public function prevAll($selector = null)
|
|
{
|
|
return $this->newInstance(
|
|
$this->getElementSiblings('previousSibling', $selector)
|
|
);
|
|
}
|
|
/**
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function not($selector = null)
|
|
{
|
|
if (is_string($selector)) {
|
|
NewsletterProphpQuery::debug(array('not', $selector));
|
|
} else {
|
|
NewsletterProphpQuery::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;
|
|
}
|
|
} elseif ($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|NewsletterProphpQueryObject
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function add($selector = null)
|
|
{
|
|
if (! $selector) {
|
|
return $this;
|
|
}
|
|
$stack = array();
|
|
$this->elementsBackup = $this->elements;
|
|
$found = NewsletterProphpQuery::pq_newsletterpro($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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProDOMEvent(array(
|
|
'target' => $node,
|
|
'type' => 'change'
|
|
));
|
|
} elseif (($isRadio || $isCheckbox) && $attr == 'checked' && (
|
|
// check
|
|
(! $oldAttr && $node->hasAttribute($attr))
|
|
// un-check
|
|
|| (! $node->hasAttribute($attr) && $oldAttr)
|
|
)) {
|
|
$event = new NewsletterProDOMEvent(array(
|
|
'target' => $node,
|
|
'type' => 'change'
|
|
));
|
|
} elseif ($isOption && $node->parentNode && $attr == 'selected' && (
|
|
// select
|
|
(! $oldAttr && $node->hasAttribute($attr))
|
|
// un-select
|
|
|| (! $node->hasAttribute($attr) && $oldAttr)
|
|
)) {
|
|
$event = new NewsletterProDOMEvent(array(
|
|
'target' => $node->parentNode,
|
|
'type' => 'change'
|
|
));
|
|
}
|
|
if ($event) {
|
|
NewsletterProphpQueryEvents::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);
|
|
}
|
|
} elseif ($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 NewsletterProphpQueryObject|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);
|
|
} elseif ($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 NewsletterProphpQueryObject|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();
|
|
}
|
|
} elseif ($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_newsletterpro($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');
|
|
}
|
|
} elseif ($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_newsletterpro($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');
|
|
}
|
|
}
|
|
} elseif ($node->get(0)->tagName == 'textarea') {
|
|
$node->markup($val);
|
|
} else {
|
|
$node->attr('value', $val);
|
|
}
|
|
}
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function andSelf()
|
|
{
|
|
if ($this->previous) {
|
|
$this->elements = array_merge($this->elements, $this->previous->elements);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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_newsletterpro("p")._empty()
|
|
*
|
|
* HTML:
|
|
* <p>Hello, <span>Person</span> <a href="#">and person</a></p>
|
|
*
|
|
* Result:
|
|
* [ <p></p> ]
|
|
*
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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) {
|
|
NewsletterProphpQuery::callbackRun($callback, array($v), $paramStructure);
|
|
}
|
|
return $this;
|
|
}
|
|
/**
|
|
* Run callback on actual object.
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public function callback($callback, $param1 = null, $param2 = null, $param3 = null)
|
|
{
|
|
$params = func_get_args();
|
|
$params[0] = $this;
|
|
NewsletterProphpQuery::callbackRun($callback, $params);
|
|
return $this;
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @todo add $scope and $args as in each() ???
|
|
*/
|
|
public function map($callback, $param1 = null, $param2 = null, $param3 = null)
|
|
{
|
|
$params = func_get_args();
|
|
array_unshift($params, $this->elements);
|
|
return $this->newInstance(
|
|
call_user_func_array(array('NewsletterProphpQuery', 'map'), $params)
|
|
);
|
|
}
|
|
/**
|
|
* 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 NewsletterProphpQuery::data($this->get(0), $key, $value, $this->getDocumentID());
|
|
} else {
|
|
foreach ($this as $node) {
|
|
NewsletterProphpQuery::data($node, $key, $value, $this->getDocumentID());
|
|
}
|
|
return $this;
|
|
}
|
|
}
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @param <type> $key
|
|
*/
|
|
public function removeData($key)
|
|
{
|
|
foreach ($this as $node) {
|
|
NewsletterProphpQuery::removeData($node, $key, $this->getDocumentID());
|
|
}
|
|
return $this;
|
|
}
|
|
// INTERFACE IMPLEMENTATIONS
|
|
|
|
// ITERATOR INTERFACE
|
|
/**
|
|
* @access private
|
|
*/
|
|
public function rewind()
|
|
{
|
|
$this->debug('iterating foreach');
|
|
// NewsletterProphpQuery::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 NewsletterProphpQueryObject::_next()
|
|
* @return NewsletterProphpQueryObject|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;
|
|
} elseif ($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'))
|
|
? Tools::strtoupper($node->tagName)
|
|
: $node->tagName;
|
|
$return[] = $tag
|
|
.($node->getAttribute('id')
|
|
? '#'.$node->getAttribute('id'):'')
|
|
.($node->getAttribute('class')
|
|
? '.'.join('.', preg_split('/ /', $node->getAttribute('class'))):'')
|
|
.($node->getAttribute('name')
|
|
? '[name="'.$node->getAttribute('name').'"]':'')
|
|
.($node->getAttribute('value') && strpos($node->getAttribute('value'), '<'.'?php') === false
|
|
? '[value="'.Tools::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]':'')
|
|
;
|
|
} elseif ($node instanceof DOMTEXT) {
|
|
if (trim($node->textContent)) {
|
|
$return[] = 'Text:'.Tools::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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*
|
|
*/
|
|
public function dump()
|
|
{
|
|
print 'DUMP #'.(NewsletterProphpQuery::$dumpCount++).' ';
|
|
$debug = NewsletterProphpQuery::$debug;
|
|
NewsletterProphpQuery::$debug = false;
|
|
// print __FILE__.':'.__LINE__."\n";
|
|
var_dump($this->htmlOuter());
|
|
return $this;
|
|
}
|
|
public function dumpWhois()
|
|
{
|
|
print 'DUMP #'.(NewsletterProphpQuery::$dumpCount++).' ';
|
|
$debug = NewsletterProphpQuery::$debug;
|
|
NewsletterProphpQuery::$debug = false;
|
|
// print __FILE__.':'.__LINE__."\n";
|
|
var_dump('whois', $this->whois());
|
|
NewsletterProphpQuery::$debug = $debug;
|
|
return $this;
|
|
}
|
|
public function dumpLength()
|
|
{
|
|
print 'DUMP #'.(NewsletterProphpQuery::$dumpCount++).' ';
|
|
$debug = NewsletterProphpQuery::$debug;
|
|
NewsletterProphpQuery::$debug = false;
|
|
// print __FILE__.':'.__LINE__."\n";
|
|
var_dump('length', $this->length());
|
|
NewsletterProphpQuery::$debug = $debug;
|
|
return $this;
|
|
}
|
|
public function dumpTree($html = true, $title = true)
|
|
{
|
|
$output = $title
|
|
? 'DUMP #'.(NewsletterProphpQuery::$dumpCount++)." \n" : '';
|
|
$debug = NewsletterProphpQuery::$debug;
|
|
NewsletterProphpQuery::$debug = false;
|
|
foreach ($this->stack() as $node) {
|
|
$output .= $this->__dumpTree($node);
|
|
}
|
|
NewsletterProphpQuery::$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 Tools::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 Tools::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 NewsletterProphpQuery functions.
|
|
*
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
* @package NewsletterProphpQuery
|
|
*/
|
|
abstract class NewsletterProphpQuery
|
|
{
|
|
/**
|
|
* 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_newsletterpro() as shortcut.
|
|
*
|
|
* In below examples, $pq is any result of pq_newsletterpro(); function.
|
|
*
|
|
* 1. Import markup into existing document (without any attaching):
|
|
* - Import into selected document:
|
|
* pq_newsletterpro('<div/>') // DOESNT accept text nodes at beginning of input string !
|
|
* - Import into document with ID from $pq->getDocumentID():
|
|
* pq_newsletterpro('<div/>', $pq->getDocumentID())
|
|
* - Import into same document as DOMNode belongs to:
|
|
* pq_newsletterpro('<div/>', DOMNode)
|
|
* - Import into document from NewsletterProphpQuery object:
|
|
* pq_newsletterpro('<div/>', $pq)
|
|
*
|
|
* 2. Run query:
|
|
* - Run query on last selected document:
|
|
* pq_newsletterpro('div.myClass')
|
|
* - Run query on document with ID from $pq->getDocumentID():
|
|
* pq_newsletterpro('div.myClass', $pq->getDocumentID())
|
|
* - Run query on same document as DOMNode belongs to and use node(s)as root for query:
|
|
* pq_newsletterpro('div.myClass', DOMNode)
|
|
* - Run query on document from NewsletterProphpQuery object
|
|
* and use object's stack as root node(s) for query:
|
|
* pq_newsletterpro('div.myClass', $pq)
|
|
*
|
|
* @param string|DOMNode|DOMNodeList|array $arg1 HTML markup, CSS Selector, DOMNode or array of DOMNodes
|
|
* @param string|NewsletterProphpQueryObject|DOMNode $context DOM ID from $pq->getDocumentID(), NewsletterProphpQuery object (determines also query root) or DOMNode (determines also query root)
|
|
*
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery|QueryTemplatesPhpQuery|false
|
|
* NewsletterProphpQuery object or false in case of error.
|
|
*/
|
|
public static function pq_newsletterpro($arg1, $context = null)
|
|
{
|
|
if ($arg1 instanceof DOMNODE && ! isset($context)) {
|
|
foreach (NewsletterProphpQuery::$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 NewsletterProphpQuery::newDocument() first.");
|
|
}
|
|
// } else if (is_object($context) && ($context instanceof PHPQUERY || is_subclass_of($context, 'NewsletterProphpQueryObject')))
|
|
} elseif (is_object($context) && $context instanceof NewsletterProphpQueryObject) {
|
|
$domId = $context->getDocumentID();
|
|
} elseif ($context instanceof DOMDOCUMENT) {
|
|
$domId = self::getDocumentID($context);
|
|
if (! $domId) {
|
|
//throw new Exception('Orphaned DOMDocument');
|
|
$domId = self::newDocument($context)->getDocumentID();
|
|
}
|
|
} elseif ($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 NewsletterProphpQueryObject) {
|
|
// if (is_object($arg1) && (get_class($arg1) == 'NewsletterProphpQueryObject' || $arg1 instanceof PHPQUERY || is_subclass_of($arg1, 'NewsletterProphpQueryObject'))) {
|
|
/**
|
|
* Return $arg1 or import $arg1 stack if document differs:
|
|
* pq_newsletterpro(pq_newsletterpro('<div/>'))
|
|
*/
|
|
if ($arg1->getDocumentID() == $domId) {
|
|
return $arg1;
|
|
}
|
|
$class = get_class($arg1);
|
|
// support inheritance by passing old object to overloaded constructor
|
|
$NewsletterProphpQuery = $class != 'NewsletterProphpQuery'
|
|
? new $class($arg1, $domId)
|
|
: new NewsletterProphpQueryObject($domId);
|
|
$NewsletterProphpQuery->elements = array();
|
|
foreach ($arg1->elements as $node) {
|
|
$NewsletterProphpQuery->elements[] = $NewsletterProphpQuery->document->importNode($node, true);
|
|
}
|
|
return $NewsletterProphpQuery;
|
|
} elseif ($arg1 instanceof DOMNODE || (is_array($arg1) && isset($arg1[0]) && $arg1[0] instanceof DOMNODE)) {
|
|
/*
|
|
* Wrap DOM nodes with NewsletterProphpQuery object, import into document when needed:
|
|
* pq_newsletterpro(array($domNode1, $domNode2))
|
|
*/
|
|
$NewsletterProphpQuery = new NewsletterProphpQueryObject($domId);
|
|
if (!($arg1 instanceof DOMNODELIST) && ! is_array($arg1)) {
|
|
$arg1 = array($arg1);
|
|
}
|
|
$NewsletterProphpQuery->elements = array();
|
|
foreach ($arg1 as $node) {
|
|
$sameDocument = $node->ownerDocument instanceof DOMDOCUMENT
|
|
&& ! $node->ownerDocument->isSameNode($NewsletterProphpQuery->document);
|
|
$NewsletterProphpQuery->elements[] = $sameDocument
|
|
? $NewsletterProphpQuery->document->importNode($node, true)
|
|
: $node;
|
|
}
|
|
return $NewsletterProphpQuery;
|
|
} elseif (self::isMarkup($arg1)) {
|
|
/**
|
|
* Import HTML:
|
|
* pq_newsletterpro('<div/>')
|
|
*/
|
|
$NewsletterProphpQuery = new NewsletterProphpQueryObject($domId);
|
|
return $NewsletterProphpQuery->newInstance(
|
|
$NewsletterProphpQuery->documentWrapper->import($arg1)
|
|
);
|
|
} else {
|
|
/**
|
|
* Run CSS query:
|
|
* pq_newsletterpro('div.myClass')
|
|
*/
|
|
$NewsletterProphpQuery = new NewsletterProphpQueryObject($domId);
|
|
// if ($context && ($context instanceof PHPQUERY || is_subclass_of($context, 'NewsletterProphpQueryObject')))
|
|
if ($context && $context instanceof NewsletterProphpQueryObject) {
|
|
$NewsletterProphpQuery->elements = $context->elements;
|
|
} elseif ($context && $context instanceof DOMNODELIST) {
|
|
$NewsletterProphpQuery->elements = array();
|
|
foreach ($context as $node) {
|
|
$NewsletterProphpQuery->elements[] = $node;
|
|
}
|
|
} elseif ($context && $context instanceof DOMNODE) {
|
|
$NewsletterProphpQuery->elements = array($context);
|
|
}
|
|
return $NewsletterProphpQuery->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 NewsletterProphpQueryObject.
|
|
* $id can be retrived via getDocumentID() or getDocumentIDRef().
|
|
* Chainable.
|
|
*
|
|
* @see NewsletterProphpQuery::selectDocument()
|
|
* @param unknown_type $id
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public static function getDocument($id = null)
|
|
{
|
|
if ($id) {
|
|
NewsletterProphpQuery::selectDocument($id);
|
|
} else {
|
|
$id = NewsletterProphpQuery::$defaultDocumentID;
|
|
}
|
|
return new NewsletterProphpQueryObject($id);
|
|
}
|
|
/**
|
|
* Creates new document from markup.
|
|
* Chainable.
|
|
*
|
|
* @param unknown_type $markup
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public static function newDocument($markup = null, $contentType = null)
|
|
{
|
|
if (! $markup) {
|
|
$markup = '';
|
|
}
|
|
$documentID = NewsletterProphpQuery::createDocumentWrapper($markup, $contentType);
|
|
return new NewsletterProphpQueryObject($documentID);
|
|
}
|
|
/**
|
|
* Creates new document from markup.
|
|
* Chainable.
|
|
*
|
|
* @param unknown_type $markup
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public static function newDocumentPHP($markup = null, $contentType = "text/html")
|
|
{
|
|
// TODO pass charset to phpToMarkup if possible (use NewsletterProDOMDocumentWrapper function)
|
|
$markup = NewsletterProphpQuery::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('NewsletterProphpQuery', '_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 NewsletterProphpQuery::php()
|
|
* into valid (executable) PHP code syntax.
|
|
*
|
|
* @param string|NewsletterProphpQueryObject $content
|
|
* @return string PHP code.
|
|
*/
|
|
public static function markupToPHP($content)
|
|
{
|
|
if ($content instanceof NewsletterProphpQueryObject) {
|
|
$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('NewsletterProphpQuery', '_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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public static function newDocumentFile($file, $contentType = null)
|
|
{
|
|
$documentID = self::createDocumentWrapper(
|
|
Tools::file_get_contents($file),
|
|
$contentType
|
|
);
|
|
return new NewsletterProphpQueryObject($documentID);
|
|
}
|
|
/**
|
|
* Creates new document from markup.
|
|
* Chainable.
|
|
*
|
|
* @param unknown_type $markup
|
|
* @return NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|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 NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
*/
|
|
public static function newDocumentFilePHP($file, $contentType = null)
|
|
{
|
|
return self::newDocumentPHP(Tools::file_get_contents($file), $contentType);
|
|
}
|
|
/**
|
|
* Reuses existing DOMDocument object.
|
|
* Chainable.
|
|
*
|
|
* @param $document DOMDocument
|
|
* @return NewsletterProphpQueryObject|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. NewsletterProphpQuery 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 NewsletterProphpQuery::$documents, make a copy
|
|
$document = clone $html;
|
|
} else {
|
|
// new document, add it to NewsletterProphpQuery::$documents
|
|
$wrapper = new NewsletterProDOMDocumentWrapper($html, $contentType, $documentID);
|
|
}
|
|
} else {
|
|
$wrapper = new NewsletterProDOMDocumentWrapper($html, $contentType, $documentID);
|
|
}
|
|
// $wrapper->id = $id;
|
|
// bind document
|
|
NewsletterProphpQuery::$documents[$wrapper->id] = $wrapper;
|
|
// remember last loaded document
|
|
NewsletterProphpQuery::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 'NewsletterProphpQueryObject':
|
|
$targetRef = &self::$extendMethods;
|
|
$targetRef2 = &self::$pluginsMethods;
|
|
break;
|
|
case 'NewsletterProphpQuery':
|
|
$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 NewsletterProphpQuery 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, 'NewsletterProphpQuery') === 0)
|
|
// $class = Tools::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 NewsletterProphpQuery::getDocumentID() for supported types.
|
|
*/
|
|
public static function unloadDocuments($id = null)
|
|
{
|
|
if (isset($id)) {
|
|
if ($id = self::getDocumentID($id)) {
|
|
unset(NewsletterProphpQuery::$documents[$id]);
|
|
}
|
|
} else {
|
|
foreach (NewsletterProphpQuery::$documents as $k => $v) {
|
|
unset(NewsletterProphpQuery::$documents[$k]);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Parses NewsletterProphpQuery object or HTML result against PHP tags and makes them active.
|
|
*
|
|
* @param NewsletterProphpQuery|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) && Tools::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 NewsletterProphpQuery::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 "
|
|
."NewsletterProphpQuery::\$ajaxAllowedHosts");
|
|
}
|
|
// JSONP
|
|
$jsre = "/=\\?(&|$)/";
|
|
if (isset($options['dataType']) && $options['dataType'] == 'jsonp') {
|
|
$jsonpCallbackParam = $options['jsonp']
|
|
? $options['jsonp'] : 'callback';
|
|
if (Tools::strtolower($options['type']) == 'get') {
|
|
if (! preg_match($jsre, $options['url'])) {
|
|
$sep = strpos($options['url'], '?')
|
|
? '&' : '?';
|
|
$options['url'] .= "$sep$jsonpCallbackParam=?";
|
|
}
|
|
} elseif ($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(Tools::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 NewsletterProphpQueryObject) {
|
|
$serialized = $options['data']->serializeArray($options['data']);
|
|
$options['data'] = array();
|
|
foreach ($serialized as $r) {
|
|
$options['data'][ $r['name'] ] = $r['value'];
|
|
}
|
|
}
|
|
if (Tools::strtolower($options['type']) == 'get') {
|
|
$client->setParameterGet($options['data']);
|
|
} elseif (Tools::strtolower($options['type']) == 'post') {
|
|
$client->setEncType($options['contentType']);
|
|
$client->setParameterPost($options['data']);
|
|
}
|
|
if (self::$active == 0 && $options['global']) {
|
|
NewsletterProphpQueryEvents::trigger($documentID, 'ajaxStart');
|
|
}
|
|
self::$active++;
|
|
// beforeSend callback
|
|
if (isset($options['beforeSend']) && $options['beforeSend']) {
|
|
NewsletterProphpQuery::callbackRun($options['beforeSend'], array($client));
|
|
}
|
|
// ajaxSend event
|
|
if ($options['global']) {
|
|
NewsletterProphpQueryEvents::trigger($documentID, 'ajaxSend', array($client, $options));
|
|
}
|
|
if (NewsletterProphpQuery::$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 (NewsletterProphpQuery::$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']) {
|
|
NewsletterProphpQuery::callbackRun($options['success'], array($data, $response->getStatus(), $options));
|
|
}
|
|
if ($options['global']) {
|
|
NewsletterProphpQueryEvents::trigger($documentID, 'ajaxSuccess', array($client, $options));
|
|
}
|
|
} else {
|
|
if (isset($options['error']) && $options['error']) {
|
|
NewsletterProphpQuery::callbackRun($options['error'], array($client, $response->getStatus(), $response->getMessage()));
|
|
}
|
|
if ($options['global']) {
|
|
NewsletterProphpQueryEvents::trigger($documentID, 'ajaxError', array($client, /*$response->getStatus(),*/$response->getMessage(), $options));
|
|
}
|
|
}
|
|
if (isset($options['complete']) && $options['complete']) {
|
|
NewsletterProphpQuery::callbackRun($options['complete'], array($client, $response->getStatus()));
|
|
}
|
|
if ($options['global']) {
|
|
NewsletterProphpQueryEvents::trigger($documentID, 'ajaxComplete', array($client, $options));
|
|
}
|
|
if ($options['global'] && ! --self::$active) {
|
|
NewsletterProphpQueryEvents::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|NewsletterProphpQuery $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 NewsletterProphpQuery::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 NewsletterProphpQuery::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 NewsletterProphpQuery::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, NewsletterProphpQuery::$ajaxAllowedHosts)) {
|
|
NewsletterProphpQuery::$ajaxAllowedHosts[] = $host;
|
|
}
|
|
}
|
|
}
|
|
public static function ajaxAllowURL($url1, $url2 = null, $url3 = null)
|
|
{
|
|
$loop = is_array($url1)
|
|
? $url1
|
|
: func_get_args();
|
|
foreach ($loop as $url) {
|
|
NewsletterProphpQuery::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 Tools::jsonEncode($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 = Tools::jsonDecode(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|NewsletterProphpQueryObject
|
|
* @return string
|
|
*/
|
|
public static function getDocumentID($source)
|
|
{
|
|
if ($source instanceof DOMDOCUMENT) {
|
|
foreach (NewsletterProphpQuery::$documents as $id => $document) {
|
|
if ($source->isSameNode($document->document)) {
|
|
return $id;
|
|
}
|
|
}
|
|
} elseif ($source instanceof DOMNODE) {
|
|
foreach (NewsletterProphpQuery::$documents as $id => $document) {
|
|
if ($source->ownerDocument->isSameNode($document->document)) {
|
|
return $id;
|
|
}
|
|
}
|
|
} elseif ($source instanceof NewsletterProphpQueryObject) {
|
|
return $source->getDocumentID();
|
|
} elseif (is_string($source) && isset(NewsletterProphpQuery::$documents[$source])) {
|
|
return $source;
|
|
}
|
|
}
|
|
/**
|
|
* Get DOMDocument object related to $source.
|
|
* Returns null if such document doesn't exist.
|
|
*
|
|
* @param $source DOMNode|NewsletterProphpQueryObject|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;
|
|
}
|
|
} elseif (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) {
|
|
NewsletterProphpQuery::callbackRun($callback, array($name, $value), $paramStructure);
|
|
}
|
|
} else {
|
|
foreach ($object as $name => $value) {
|
|
NewsletterProphpQuery::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 = NewsletterProphpQuery::callbackRun($callback, array($v), $paramStructure);
|
|
// $callbackArgs = $args;
|
|
// foreach($args as $i => $arg) {
|
|
// $callbackArgs[$i] = $arg instanceof NewsletterProCallbackParam
|
|
// ? $v
|
|
// : $arg;
|
|
// }
|
|
// $vv = call_user_func_array($callback, $callbackArgs);
|
|
if (is_array($vv)) {
|
|
foreach ($vv as $vvv) {
|
|
$result[] = $vvv;
|
|
}
|
|
} elseif ($vv !== null) {
|
|
$result[] = $vv;
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
/**
|
|
*
|
|
* @param $callback NewsletterProCallback
|
|
* @param $params
|
|
* @param $paramStructure
|
|
* @return unknown_type
|
|
*/
|
|
public static function callbackRun($callback, $params = array(), $paramStructure = null)
|
|
{
|
|
if (! $callback) {
|
|
return;
|
|
}
|
|
if ($callback instanceof NewsletterProCallbackParameterToReference) {
|
|
// TODO support ParamStructure to select which $param push to reference
|
|
if (isset($params[0])) {
|
|
$callback->callback = $params[0];
|
|
}
|
|
return true;
|
|
}
|
|
if ($callback instanceof NewsletterProCallback) {
|
|
$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 NewsletterProCallbackParam
|
|
? $params[$p++]
|
|
: $v;
|
|
}
|
|
return call_user_func_array($callback, $paramStructure);
|
|
}
|
|
/**
|
|
* Merge 2 NewsletterProphpQuery objects.
|
|
* @param array $one
|
|
* @param array $two
|
|
* @protected
|
|
* @todo node lists, NewsletterProphpQueryObject
|
|
*/
|
|
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 NewsletterProphpQueryObject
|
|
*/
|
|
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 NewsletterProphpQueryObject
|
|
*/
|
|
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 NewsletterProphpQueryObject
|
|
*/
|
|
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(NewsletterProphpQuery::$plugins, $method),
|
|
$params
|
|
);
|
|
}
|
|
protected static function dataSetupNode($node, $documentID)
|
|
{
|
|
// search are return if alredy exists
|
|
foreach (NewsletterProphpQuery::$documents[$documentID]->dataNodes as $dataNode) {
|
|
if ($node->isSameNode($dataNode)) {
|
|
return $dataNode;
|
|
}
|
|
}
|
|
// if doesn't, add it
|
|
NewsletterProphpQuery::$documents[$documentID]->dataNodes[] = $node;
|
|
return $node;
|
|
}
|
|
protected static function dataRemoveNode($node, $documentID)
|
|
{
|
|
// search are return if alredy exists
|
|
foreach (NewsletterProphpQuery::$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 = NewsletterProphpQuery::$documents[$documentID];
|
|
$node = self::dataSetupNode($node, $documentID);
|
|
if (! isset($node->dataID)) {
|
|
$node->dataID = ++NewsletterProphpQuery::$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 = NewsletterProphpQuery::$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 NewsletterProphpQuery
|
|
* @todo move plugin methods here (as statics)
|
|
*/
|
|
class NewsletterProphpQueryPlugins
|
|
{
|
|
public function __call($method, $args)
|
|
{
|
|
if (isset(NewsletterProphpQuery::$extendStaticMethods[$method])) {
|
|
$return = call_user_func_array(
|
|
NewsletterProphpQuery::$extendStaticMethods[$method],
|
|
$args
|
|
);
|
|
} elseif (isset(NewsletterProphpQuery::$pluginsStaticMethods[$method])) {
|
|
$class = NewsletterProphpQuery::$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 NewsletterProphpQuery::pq_newsletterpro($arg1, $context)
|
|
* Chainable.
|
|
*
|
|
* @see NewsletterProphpQuery::pq_newsletterpro()
|
|
* @return NewsletterProphpQueryObject|QueryTemplatesSource|QueryTemplatesParse|QueryTemplatesSourceQuery
|
|
* @author Tobiasz Cudnik <tobiasz.cudnik/gmail.com>
|
|
* @package NewsletterProphpQuery
|
|
*/
|
|
function pq_newsletterpro($arg1, $context = null)
|
|
{
|
|
$args = func_get_args();
|
|
return call_user_func_array(
|
|
array('NewsletterProphpQuery', 'pq_newsletterpro'),
|
|
$args
|
|
);
|
|
}
|
|
// add plugins dir and Zend framework to include path
|
|
set_include_path(
|
|
get_include_path()
|
|
.PATH_SEPARATOR.dirname(__FILE__).'/NewsletterProphpQuery/'
|
|
.PATH_SEPARATOR.dirname(__FILE__).'/NewsletterProphpQuery/plugins/'
|
|
);
|
|
// why ? no __call nor __get for statics in php...
|
|
// XXX __callStatic will be available in PHP 5.3
|
|
NewsletterProphpQuery::$plugins = new NewsletterProphpQueryPlugins();
|
|
// include bootstrap file (personal library config)
|
|
if (file_exists(dirname(__FILE__).'/NewsletterProphpQuery/bootstrap.php')) {
|
|
require_once dirname(__FILE__).'/NewsletterProphpQuery/bootstrap.php';
|
|
}
|