From 8a30c5bec21dfd738e02157c1ece0df62cb930cd Mon Sep 17 00:00:00 2001 From: nicolasconnault Date: Mon, 13 Oct 2008 12:09:44 +0000 Subject: [PATCH] MDL-16780 Adding missing file --- lib/pear/HTML/AJAX.php | 1076 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1076 insertions(+) create mode 100755 lib/pear/HTML/AJAX.php diff --git a/lib/pear/HTML/AJAX.php b/lib/pear/HTML/AJAX.php new file mode 100755 index 00000000000..c17520f6ecd --- /dev/null +++ b/lib/pear/HTML/AJAX.php @@ -0,0 +1,1076 @@ + + * @author Arpad Ray + * @author David Coallier + * @author Elizabeth Smith + * @copyright 2005-2008 Joshua Eichorn, Arpad Ray, David Coallier, Elizabeth Smith + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL + * @version Release: 0.5.6 + * @link http://pear.php.net/package/HTML_AJAX + */ + +/** + * This is a quick hack, loading serializers as needed doesn't work in php5 + */ +require_once "HTML/AJAX/Serializer/JSON.php"; +require_once "HTML/AJAX/Serializer/Null.php"; +require_once "HTML/AJAX/Serializer/Error.php"; +require_once "HTML/AJAX/Serializer/XML.php"; +require_once "HTML/AJAX/Serializer/PHP.php"; +require_once 'HTML/AJAX/Debug.php'; + +/** + * OO AJAX Implementation for PHP + * + * @category HTML + * @package AJAX + * @author Joshua Eichorn + * @author Arpad Ray + * @author David Coallier + * @author Elizabeth Smith + * @copyright 2005-2008 Joshua Eichorn, Arpad Ray, David Coallier, Elizabeth Smith + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL + * @version Release: 0.5.6 + * @link http://pear.php.net/package/HTML_AJAX + */ +class HTML_AJAX +{ + /** + * An array holding the instances were exporting + * + * key is the exported name + * + * row format is + * + * array('className'=>'','exportedName'=>'','instance'=>'','exportedMethods=>'') + * + * + * @var object + * @access private + */ + var $_exportedInstances = array(); + + /** + * Set the server url in the generated stubs to this value + * If set to false, serverUrl will not be set + * @var false|string + */ + var $serverUrl = false; + + /** + * What encoding your going to use for serializing data + * from php being sent to javascript. + * + * @var string JSON|PHP|Null + */ + var $serializer = 'JSON'; + + /** + * What encoding your going to use for unserializing data sent from javascript + * @var string JSON|PHP|Null + */ + var $unserializer = 'JSON'; + + /** + * Option to use loose typing for JSON encoding + * @var bool + * @access public + */ + var $jsonLooseType = true; + + /** + * Content-type map + * + * Used in to automatically choose serializers as needed + */ + var $contentTypeMap = array( + 'JSON' => 'application/json', + 'XML' => 'application/xml', + 'Null' => 'text/plain', + 'Error' => 'application/error', + 'PHP' => 'application/php-serialized', + 'Urlencoded' => 'application/x-www-form-urlencoded' + ); + + /** + * This is the debug variable that we will be passing the + * HTML_AJAX_Debug instance to. + * + * @param object HTML_AJAX_Debug + */ + var $debug; + + /** + * This is to tell if debug is enabled or not. If so, then + * debug is called, instantiated then saves the file and such. + */ + var $debugEnabled = false; + + /** + * This puts the error into a session variable is set to true. + * set to false by default. + * + * @access public + */ + var $debugSession = false; + + /** + * Boolean telling if the Content-Length header should be sent. + * + * If your using a gzip handler on an output buffer, or run into + * any compatability problems, try disabling this. + * + * @access public + * @var boolean + */ + var $sendContentLength = true; + + /** + * Make Generated code compatible with php4 by lowercasing all + * class/method names before exporting to JavaScript. + * + * If you have code that works on php4 but not on php5 then setting + * this flag can fix the problem. The recommended solution is too + * specify the class and method names when registering the class + * letting you have function case in php4 as well + * + * @access public + * @var boolean + */ + var $php4CompatCase = false; + + /** + * Automatically pack all generated JavaScript making it smaller + * + * If your using output compression this might not make sense + */ + var $packJavaScript = false; + + /** + * Holds current payload info + * + * @access private + * @var string + */ + var $_payload; + + /** + * Holds iframe id IF this is an iframe xmlhttprequest + * + * @access private + * @var string + */ + var $_iframe; + + /** + * Holds the list of classes permitted to be unserialized + * + * @access private + * @var array + */ + var $_allowedClasses = array(); + + /** + * Holds serializer instances + */ + var $_serializers = array(); + + /** + * PHP callbacks we're exporting + */ + var $_validCallbacks = array(); + + /** + * Interceptor instance + */ + var $_interceptor = false; + + /** + * Set a class to handle requests + * + * @param object &$instance An instance to export + * @param mixed $exportedName Name used for the javascript class, + * if false the name of the php class is used + * @param mixed $exportedMethods If false all functions without a _ prefix + * are exported, if an array only the methods + * listed in the array are exported + * + * @return void + */ + function registerClass(&$instance, $exportedName = false, + $exportedMethods = false) + { + $className = strtolower(get_class($instance)); + + if ($exportedName === false) { + $exportedName = get_class($instance); + if ($this->php4CompatCase) { + $exportedName = strtolower($exportedName); + } + } + + if ($exportedMethods === false) { + $exportedMethods = $this->_getMethodsToExport($className); + } + + + $index = strtolower($exportedName); + $this->_exportedInstances[$index] = array(); + $this->_exportedInstances[$index]['className'] = $className; + $this->_exportedInstances[$index]['exportedName'] = $exportedName; + $this->_exportedInstances[$index]['instance'] =& $instance; + $this->_exportedInstances[$index]['exportedMethods'] = $exportedMethods; + } + + /** + * Get a list of methods in a class to export + * + * This function uses get_class_methods to get a list of callable methods, + * so if you're on PHP5 extending this class with a class you want to export + * should export its protected methods, while normally only its public methods + * would be exported. All methods starting with _ are removed from the export list. + * This covers PHP4 style private by naming as well as magic methods in either PHP4 or PHP5 + * + * @param string $className Name of the class + * + * @return array all methods of the class that are public + * @access private + */ + function _getMethodsToExport($className) + { + $funcs = get_class_methods($className); + + foreach ($funcs as $key => $func) { + if (strtolower($func) === $className || substr($func, 0, 1) === '_') { + unset($funcs[$key]); + } else if ($this->php4CompatCase) { + $funcs[$key] = strtolower($func); + } + } + return $funcs; + } + + /** + * Generate the client Javascript code + * + * @return string generated javascript client code + */ + function generateJavaScriptClient() + { + $client = ''; + + $names = array_keys($this->_exportedInstances); + foreach ($names as $name) { + $client .= $this->generateClassStub($name); + } + return $client; + } + + /** + * Return the stub for a class + * + * @param string $name name of the class to generated the stub for, + * note that this is the exported name not the php class name + * + * @return string javascript proxy stub code for a single class + */ + function generateClassStub($name) + { + if (!isset($this->_exportedInstances[$name])) { + return ''; + } + + $client = "// Client stub for the {$this->_exportedInstances[$name]['exportedName']} PHP Class\n"; + $client .= "function {$this->_exportedInstances[$name]['exportedName']}(callback) {\n"; + $client .= "\tmode = 'sync';\n"; + $client .= "\tif (callback) { mode = 'async'; }\n"; + $client .= "\tthis.className = '{$this->_exportedInstances[$name]['exportedName']}';\n"; + if ($this->serverUrl) { + $client .= "\tthis.dispatcher = new HTML_AJAX_Dispatcher(this.className,mode,callback,'{$this->serverUrl}','{$this->unserializer}');\n}\n"; + } else { + $client .= "\tthis.dispatcher = new HTML_AJAX_Dispatcher(this.className,mode,callback,false,'{$this->unserializer}');\n}\n"; + } + $client .= "{$this->_exportedInstances[$name]['exportedName']}.prototype = {\n"; + $client .= "\tSync: function() { this.dispatcher.Sync(); }, \n"; + $client .= "\tAsync: function(callback) { this.dispatcher.Async(callback); },\n"; + foreach ($this->_exportedInstances[$name]['exportedMethods'] as $method) { + $client .= $this->_generateMethodStub($method); + } + $client = substr($client, 0, (strlen($client)-2))."\n"; + $client .= "}\n\n"; + + if ($this->packJavaScript) { + $client = $this->packJavaScript($client); + } + return $client; + } + + /** + * Returns a methods stub + * + * @param string $method the method name + * + * @return string the js code + * @access private + */ + function _generateMethodStub($method) + { + $stub = "\t{$method}: function() { return ". + "this.dispatcher.doCall('{$method}',arguments); },\n"; + return $stub; + } + + /** + * Populates the current payload + * + * @return string the js code + * @access private + */ + function populatePayload() + { + if (isset($_REQUEST['Iframe_XHR'])) { + $this->_iframe = $_REQUEST['Iframe_XHR_id']; + if (isset($_REQUEST['Iframe_XHR_headers']) && + is_array($_REQUEST['Iframe_XHR_headers'])) { + foreach ($_REQUEST['Iframe_XHR_headers'] as $header) { + + $array = explode(':', $header); + $array[0] = strip_tags(strtoupper(str_replace('-', '_', $array[0]))); + //only content-length and content-type can go in without an + //http_ prefix - security + if (strpos($array[0], 'HTTP_') !== 0 + && strcmp('CONTENT_TYPE', $array[0]) + && strcmp('CONTENT_LENGTH', $array[0])) { + $array[0] = 'HTTP_' . $array[0]; + } + $_SERVER[$array[0]] = strip_tags($array[1]); + } + } + $this->_payload = (isset($_REQUEST['Iframe_XHR_data']) + ? $_REQUEST['Iframe_XHR_data'] : ''); + + if (isset($_REQUEST['Iframe_XHR_method'])) { + $_GET['m'] = $_REQUEST['Iframe_XHR_method']; + } + if (isset($_REQUEST['Iframe_XHR_class'])) { + $_GET['c'] = $_REQUEST['Iframe_XHR_class']; + } + } + } + + /** + * Handle a ajax request if needed + * + * The current check is if GET variables c (class) and m (method) are set, + * more options may be available in the future + * + * @return boolean true if an ajax call was handled, false otherwise + */ + function handleRequest() + { + set_error_handler(array(&$this,'_errorHandler')); + if (function_exists('set_exception_handler')) { + set_exception_handler(array(&$this,'_exceptionHandler')); + } + if (isset($_GET['px'])) { + if ($this->_iframeGrabProxy()) { + restore_error_handler(); + if (function_exists('restore_exception_handler')) { + restore_exception_handler(); + } + return true; + } + } + + $class = strtolower($this->_getVar('c')); + $method = $this->_getVar('m'); + $phpCallback = $this->_getVar('cb'); + + + if (!empty($class) && !empty($method)) { + if (!isset($this->_exportedInstances[$class])) { + // handle error + trigger_error('Unknown class: '. $class); + } + if (!in_array(($this->php4CompatCase ? strtolower($method) : $method), + $this->_exportedInstances[$class]['exportedMethods'])) { + // handle error + trigger_error('Unknown method: ' . $method); + } + } else if (!empty($phpCallback)) { + if (strpos($phpCallback, '.') !== false) { + $phpCallback = explode('.', $phpCallback); + } + if (!$this->_validatePhpCallback($phpCallback)) { + restore_error_handler(); + if (function_exists('restore_exception_handler')) { + restore_exception_handler(); + } + return false; + } + } else { + restore_error_handler(); + if (function_exists('restore_exception_handler')) { + restore_exception_handler(); + } + return false; + } + + // auto-detect serializer to use from content-type + $type = $this->unserializer; + $key = array_search($this->_getClientPayloadContentType(), + $this->contentTypeMap); + if ($key) { + $type = $key; + } + $unserializer = $this->_getSerializer($type); + + $args = $unserializer->unserialize($this->_getClientPayload(), $this->_allowedClasses); + if (!is_array($args)) { + $args = array($args); + } + + if ($this->_interceptor !== false) { + $args = $this->_processInterceptor($class, $method, $phpCallback, $args); + } + + if (empty($phpCallback)) { + $ret = call_user_func_array(array(&$this->_exportedInstances[$class]['instance'], $method), $args); + } else { + $ret = call_user_func_array($phpCallback, $args); + } + + restore_error_handler(); + $this->_sendResponse($ret); + return true; + } + + /** + * Determines the content type of the client payload + * + * @return string + * a MIME content type + */ + function _getClientPayloadContentType() + { + //OPERA IS STUPID FIX + if (isset($_SERVER['HTTP_X_CONTENT_TYPE'])) { + $type = $this->_getServer('HTTP_X_CONTENT_TYPE'); + $pos = strpos($type, ';'); + + return strtolower($pos ? substr($type, 0, $pos) : $type); + } else if (isset($_SERVER['CONTENT_TYPE'])) { + $type = $this->_getServer('CONTENT_TYPE'); + $pos = strpos($type, ';'); + + return strtolower($pos ? substr($type, 0, $pos) : $type); + } + return 'text/plain'; + } + + /** + * Send a reponse adding needed headers and serializing content + * + * Note: this method echo's output as well as setting headers to prevent caching + * Iframe Detection: if this has been detected as an iframe response, it has to + * be wrapped in different code and headers changed (quite a mess) + * + * @param mixed $response content to serialize and send + * + * @access private + * @return void + */ + function _sendResponse($response) + { + if (is_object($response) && is_a($response, 'HTML_AJAX_Response')) { + $output = $response->getPayload(); + $content = $response->getContentType(); + + } elseif (is_a($response, 'PEAR_Error')) { + $serializer = $this->_getSerializer('Error'); + $output = $serializer->serialize(array( + 'message' => $response->getMessage(), + 'userinfo' => $response->getUserInfo(), + 'code' => $response->getCode(), + 'mode' => $response->getMode() + )); + $content = $this->contentTypeMap['Error']; + + } else { + $serializer = $this->_getSerializer($this->serializer); + $output = $serializer->serialize($response); + + $serializerType = $this->serializer; + // let a serializer change its output type + if (isset($serializer->serializerNewType)) { + $serializerType = $serializer->serializerNewType; + } + + if (isset($this->contentTypeMap[$serializerType])) { + $content = $this->contentTypeMap[$serializerType]; + } + } + // headers to force things not to be cached: + $headers = array(); + //OPERA IS STUPID FIX + if (isset($_SERVER['HTTP_X_CONTENT_TYPE'])) { + $headers['X-Content-Type'] = $content; + $content = 'text/plain'; + } + + if ($this->_sendContentLength()) { + $headers['Content-Length'] = strlen($output); + } + + $headers['Expires'] = 'Mon, 26 Jul 1997 05:00:00 GMT'; + $headers['Last-Modified'] = gmdate("D, d M Y H:i:s").'GMT'; + $headers['Cache-Control'] = 'no-cache, must-revalidate'; + $headers['Pragma'] = 'no-cache'; + $headers['Content-Type'] = $content.'; charset=utf-8'; + + //intercept to wrap iframe return data + if ($this->_iframe) { + $output = $this->_iframeWrapper($this->_iframe, + $output, $headers); + $headers['Content-Type'] = 'text/html; charset=utf-8'; + } + + $this->_sendHeaders($headers); + echo $output; + } + + /** + * Decide if we should send a Content-length header + * + * @return bool true if it's ok to send the header, false otherwise + * @access private + */ + function _sendContentLength() + { + if (!$this->sendContentLength) { + return false; + } + $ini_tests = array( "output_handler", + "zlib.output_compression", + "zlib.output_handler"); + foreach ($ini_tests as $test) { + if (ini_get($test)) { + return false; + } + } + return (ob_get_level() <= 0); + } + + /** + * Actually send a list of headers + * + * @param array $array list of headers to send + * + * @access private + * @return void + */ + function _sendHeaders($array) + { + foreach ($array as $header => $value) { + header($header . ': ' . $value); + } + } + + /** + * Get an instance of a serializer class + * + * @param string $type Last part of the class name + * + * @access private + * @return HTML_AJAX_Serializer + */ + function _getSerializer($type) + { + if (isset($this->_serializers[$type])) { + return $this->_serializers[$type]; + } + + $class = 'HTML_AJAX_Serializer_'.$type; + + if ( (version_compare(phpversion(), 5, '>') && !class_exists($class, false)) + || (version_compare(phpversion(), 5, '<') && !class_exists($class)) ) { + // include the class only if it isn't defined + include_once "HTML/AJAX/Serializer/{$type}.php"; + } + + //handle JSON loose typing option for associative arrays + if ($type == 'JSON') { + $this->_serializers[$type] = new $class($this->jsonLooseType); + } else { + $this->_serializers[$type] = new $class(); + } + return $this->_serializers[$type]; + } + + /** + * Get payload in its submitted form, currently only supports raw post + * + * @access private + * @return string raw post data + */ + function _getClientPayload() + { + if (empty($this->_payload)) { + if (isset($GLOBALS['HTTP_RAW_POST_DATA'])) { + $this->_payload = $GLOBALS['HTTP_RAW_POST_DATA']; + } else if (function_exists('file_get_contents')) { + // both file_get_contents() and php://input require PHP >= 4.3.0 + $this->_payload = file_get_contents('php://input'); + } else { + $this->_payload = ''; + } + } + return $this->_payload; + } + + /** + * stub for getting get vars - applies strip_tags + * + * @param string $var variable to get + * + * @access private + * @return string filtered _GET value + */ + function _getVar($var) + { + if (!isset($_GET[$var])) { + return null; + } else { + return strip_tags($_GET[$var]); + } + } + + /** + * stub for getting server vars - applies strip_tags + * + * @param string $var variable to get + * + * @access private + * @return string filtered _GET value + */ + function _getServer($var) + { + if (!isset($_SERVER[$var])) { + return null; + } else { + return strip_tags($_SERVER[$var]); + } + } + + /** + * Exception handler, passes them to _errorHandler to do the actual work + * + * @param Exception $ex Exception to be handled + * + * @access private + * @return void + */ + function _exceptionHandler($ex) + { + $this->_errorHandler($ex->getCode(), $ex->getMessage(), $ex->getFile(), $ex->getLine()); + } + + + /** + * Error handler that sends it errors to the client side + * + * @param int $errno Error number + * @param string $errstr Error string + * @param string $errfile Error file + * @param string $errline Error line + * + * @access private + * @return void + */ + function _errorHandler($errno, $errstr, $errfile, $errline) + { + if ($errno & error_reporting()) { + $e = new stdClass(); + $e->errNo = $errno; + $e->errStr = $errstr; + $e->errFile = $errfile; + $e->errLine = $errline; + + + $this->serializer = 'Error'; + $this->_sendResponse($e); + if ($this->debugEnabled) { + $this->debug = new HTML_AJAX_Debug($errstr, $errline, $errno, $errfile); + if ($this->debugSession) { + $this->debug->sessionError(); + } + $this->debug->_saveError(); + } + die(); + } + } + + /** + * Creates html to wrap serialized info for iframe xmlhttprequest fakeout + * + * @param string $id iframe instance id + * @param string $data data to pass + * @param string $headers headers to pass + * + * @access private + * @return string html page with iframe passing code + */ + function _iframeWrapper($id, $data, $headers = array()) + { + $string = '' + . ''; + return $string; + } + + /** + * Handles a proxied grab request + * + * @return bool true to end the response, false to continue trying to handle it + * @access private + */ + function _iframeGrabProxy() + { + if (!isset($_REQUEST['Iframe_XHR_id'])) { + trigger_error('Invalid iframe ID'); + return false; + } + $this->_iframe = $_REQUEST['Iframe_XHR_id']; + $this->_payload = (isset($_REQUEST['Iframe_XHR_data']) ? $_REQUEST['Iframe_XHR_data'] : ''); + $url = urldecode($_GET['px']); + $url_parts = parse_url($url); + $urlregex = '#^https?://#i'; + + if (!preg_match($urlregex, $url) || $url_parts['host'] != $_SERVER['HTTP_HOST']) { + trigger_error('Invalid URL for grab proxy'); + return true; + } + $method = (isset($_REQUEST['Iframe_XHR_HTTP_method']) + ? strtoupper($_REQUEST['Iframe_XHR_HTTP_method']) + : 'GET'); + // validate method + if ($method != 'GET' && $method != 'POST') { + trigger_error('Invalid grab URL'); + return true; + } + // validate headers + $headers = ''; + if (isset($_REQUEST['Iframe_XHR_headers'])) { + foreach ($_REQUEST['Iframe_XHR_headers'] as $header) { + if (strpos($header, "\r") !== false + || strpos($header, "\n") !== false) { + trigger_error('Invalid grab header'); + return true; + } + $headers .= $header . "\r\n"; + } + } + // tries to make request with file_get_contents() + if (ini_get('allow_url_fopen') && version_compare(phpversion(), '5.0.0'. '>=')) { + $opts = array( + $url_parts['scheme'] => array( + 'method' => $method, + 'headers' => $headers, + 'content' => $this->_payload + ) + ); + $ret = @file_get_contents($url, false, stream_context_create($opts)); + if (!empty($ret)) { + $this->_sendResponse($ret); + return true; + } + } + // tries to make request using the curl extension + if (function_exists('curl_setopt')) { + $ch = curl_init(); + curl_setopt($ch, CURLOPT_URL, $url); + curl_setopt($ch, CURLOPT_HEADER, $headers); + curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); + $ret = curl_exec($ch); + if ($ret !== false) { + curl_close($ch); + $this->_sendResponse($ret); + return true; + } + } + if (isset($url_parts['port'])) { + $port = $url_parts['port']; + } else { + $port = getservbyname(strtolower($url_parts['scheme']), 'tcp'); + if ($port === false) { + trigger_error('Grab proxy: Unknown port or service, defaulting to 80', E_USER_WARNING); + $port = 80; + } + } + if (!isset($url_parts['path'])) { + $url_parts['path'] = '/'; + } + if (!empty($url_parts['query'])) { + $url_parts['path'] .= '?' . $url_parts['query']; + } + $request = "$method {$url_parts['path']} HTTP/1.0\r\n" + . "Host: {$url['host']}\r\n" + . "Connection: close\r\n" + . "$headers\r\n"; + // tries to make request using the socket functions + $fp = fsockopen($_SERVER['HTTP_HOST'], $port, $errno, $errstr, 4); + if ($fp) { + fputs($fp, $request); + + $ret = ''; + $done_headers = false; + + while (!feof($fp)) { + $ret .= fgets($fp, 2048); + if ($done_headers || ($contentpos = strpos($ret, "\r\n\r\n")) === false) { + continue; + } + $done_headers = true; + $ret = substr($ret, $contentpos + 4); + } + fclose($fp); + $this->_sendResponse($ret); + return true; + } + // tries to make the request using the socket extension + $host = gethostbyname($url['host']); + if (($socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) < 0 + || ($connected = socket_connect($socket, $host, $port)) < 0 + || ($written = socket_write($socket, $request)) < strlen($request)) { + trigger_error('Grab proxy failed: ' . socket_strerror($socket)); + return true; + } + + $ret = ''; + $done_headers = false; + + while ($out = socket_read($socket, 2048)) { + $ret .= $out; + if ($done_headers || ($contentpos = strpos($ret, "\r\n\r\n")) === false) { + continue; + } + $done_headers = true; + $ret = substr($ret, $contentpos + 4); + } + socket_close($socket); + $this->_sendResponse($ret); + return true; + } + + /** + * Add a class or classes to those allowed to be unserialized + * + * @param mixed $classes the class or array of classes to add + * + * @access public + * @return void + */ + function addAllowedClasses($classes) + { + if (!is_array($classes)) { + $this->_allowedClasses[] = $classes; + } else { + $this->_allowedClasses = array_merge($this->_allowedClasses, $classes); + } + $this->_allowedClasses = array_unique($this->_allowedClasses); + } + + /** + * Checks that the given callback is callable and allowed to be called + * + * @param callback $callback the callback to check + * + * @return bool true if the callback is valid, false otherwise + * @access private + */ + function _validatePhpCallback($callback) + { + if (!is_callable($callback)) { + return false; + } + $sig = md5(serialize($callback)); + return isset($this->_validCallbacks[$sig]); + } + + /** + * Register a callback so it may be called from JS + * + * @param callback $callback the callback to register + * + * @access public + * @return void + */ + function registerPhpCallback($callback) + { + $this->_validCallbacks[md5(serialize($callback))] = 1; + } + + /** + * Make JavaScript code smaller + * + * Currently just strips whitespace and comments, needs to remain fast + * Strips comments only if they are not preceeded by code + * Strips /*-style comments only if they span over more than one line + * Since strings cannot span over multiple lines, it cannot be defeated by a + * string containing /* + * + * @param string $input Javascript to pack + * + * @access public + * @return string packed javascript + */ + function packJavaScript($input) + { + $stripPregs = array( + '/^\s*$/', + '/^\s*\/\/.*$/' + ); + $blockStart = '/^\s*\/\/\*/'; + $blockEnd = '/\*\/\s*(.*)$/'; + $inlineComment = '/\/\*.*\*\//'; + $out = ''; + + $lines = explode("\n", $input); + $inblock = false; + foreach ($lines as $line) { + $keep = true; + if ($inblock) { + if (preg_match($blockEnd, $line)) { + $inblock = false; + $line = preg_match($blockEnd, '$1', $line); + $keep = strlen($line) > 0; + } + } elseif (preg_match($inlineComment, $line)) { + $keep = true; + } elseif (preg_match($blockStart, $line)) { + $inblock = true; + $keep = false; + } + + if (!$inblock) { + foreach ($stripPregs as $preg) { + if (preg_match($preg, $line)) { + $keep = false; + break; + } + } + } + + if ($keep && !$inblock) { + $out .= trim($line)."\n"; + } + /* Enable to see what your striping out + else { + echo $line."
"; + }//*/ + } + $out .= "\n"; + return $out; + } + + /** + * Set an interceptor class + * + * An interceptor class runs during the process of handling a request, + * it allows you to run security checks globally. It also allows you to + * rewrite parameters + * + * You can throw errors and exceptions in your intercptor methods and + * they will be passed to javascript + * + * You can add interceptors are 3 levels + * For a particular class/method, this is done by add a method to you class + * named ClassName_MethodName($params) + * For a particular class, method ClassName($methodName,$params) + * Globally, method intercept($className,$methodName,$params) + * + * Only one match is done, using the most specific interceptor + * + * All methods have to return $params, if you want to empty all of the + * parameters return an empty array + * + * @param Object $instance an instance of you interceptor class + * + * @todo handle php callbacks + * @access public + * @return void + */ + function setInterceptor($instance) + { + $this->_interceptor = $instance; + } + + /** + * Attempt to intercept a call + * + * @param string $className Class Name + * @param string $methodName Method Name + * @param string $callback Not implemented + * @param array $params Array of parameters to pass to the interceptor + * + * @todo handle php callbacks + * @access private + * @return array Updated params + */ + function _processInterceptor($className,$methodName,$callback,$params) + { + + $m = $className.'_'.$methodName; + if (method_exists($this->_interceptor, $m)) { + return $this->_interceptor->$m($params); + } + + $m = $className; + if (method_exists($this->_interceptor, $m)) { + return $this->_interceptor->$m($methodName, $params); + } + + $m = 'intercept'; + if (method_exists($this->_interceptor, $m)) { + return $this->_interceptor->$m($className, $methodName, $params); + } + + return $params; + } +} + +/** + * PHP 4 compat function for interface/class exists + * + * @param string $class Class name + * @param bool $autoload Should the autoloader be called + * + * @access public + * @return bool + */ +function HTML_AJAX_Class_exists($class, $autoload) +{ + if (function_exists('interface_exists')) { + return class_exists($class, $autoload); + } else { + return class_exists($class); + } +} +/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ +?>