pradosoft / prado

framework/I18N/core/TCache_Lite.php

Doc Comments +2 added lines

@@ -485,6 +485,8 @@
     /**
     *
     * @access private
+    * @param string $id
+    * @param string $data
     */
     function _memoryCacheAdd($id, $data)
     {

Switch Indentation +9 added lines, -9 removed lines

@@ -611,15 +611,15 @@
     function _hash($data, $controlType)
     {
         switch ($controlType) {
-        case 'md5':
-            return md5($data);
-        case 'crc32':
-            return sprintf('% 32d', crc32($data));
-        case 'strlen':
-            return sprintf('% 32d', strlen($data));
-        default:
-            $this->raiseError('Unknown controlType ! '.
-            '(available values are only \'md5\', \'crc32\', \'strlen\')', -5);
+        	case 'md5':
+            	return md5($data);
+        	case 'crc32':
+            	return sprintf('% 32d', crc32($data));
+        	case 'strlen':
+            	return sprintf('% 32d', strlen($data));
+        	default:
+            	$this->raiseError('Unknown controlType ! '.
+            	'(available values are only \'md5\', \'crc32\', \'strlen\')', -5);
         }
     }
 

Indentation +567 added lines, -567 removed lines

@@ -46,575 +46,575 @@
 class TCache_Lite
 {
 
-    // --- Private properties ---
-
-    /**
-    * Directory where to put the cache files
-    * (make sure to add a trailing slash)
-    *
-    * @var string $_cacheDir
-    */
-    protected $_cacheDir = '/tmp/';
-
-    /**
-    * Enable / disable caching
-    *
-    * (can be very usefull for the debug of cached scripts)
-    *
-    * @var boolean $_caching
-    */
-    protected $_caching = true;
-
-    /**
-    * Cache lifetime (in seconds)
-    *
-    * @var int $_lifeTime
-    */
-    protected $_lifeTime = 3600;
-
-    /**
-    * Enable / disable fileLocking
-    *
-    * (can avoid cache corruption under bad circumstances)
-    *
-    * @var boolean $_fileLocking
-    */
-    protected $_fileLocking = true;
-
-    /**
-    * Timestamp of the last valid cache
-    *
-    * @var int $_refreshTime
-    */
-    protected $_refreshTime;
-
-    /**
-    * File name (with path)
-    *
-    * @var string $_file
-    */
-    protected $_file;
-
-    /**
-    * Enable / disable write control (the cache is read just after writing
-    * to detect corrupt entries)
-    *
-    * Enable write control will lightly slow the cache writing but not the
-    * cache reading. Write control can detect some corrupt cache files but
-    * maybe it's not a perfect control
-    *
-    * @var boolean $_writeControl
-    */
-    protected $_writeControl = true;
-
-    /**
-    * Enable / disable read control
-    *
-    * If enabled, a control key is embeded in cache file and this key is
-    * compared with the one calculated after the reading.
-    *
-    * @var boolean $_writeControl
-    */
-    protected $_readControl = true;
-
-    /**
-    * Type of read control (only if read control is enabled)
-    *
-    * Available values are :
-    * 'md5' for a md5 hash control (best but slowest)
-    * 'crc32' for a crc32 hash control (lightly less safe but faster,
-    * better choice)
-    * 'strlen' for a length only test (fastest)
-    *
-    * @var boolean $_readControlType
-    */
-    protected $_readControlType = 'crc32';
-
-    /**
-    * Current cache id
-    *
-    * @var string $_id
-    */
-    protected $_id;
-
-    /**
-    * Current cache group
-    *
-    * @var string $_group
-    */
-    protected $_group;
-
-    /**
-    * Enable / Disable "Memory Caching"
-    *
-    * NB : There is no lifetime for memory caching !
-    *
-    * @var boolean $_memoryCaching
-    */
-    protected $_memoryCaching = false;
-
-    /**
-    * Enable / Disable "Only Memory Caching"
-    * (be carefull, memory caching is "beta quality")
-    *
-    * @var boolean $_onlyMemoryCaching
-    */
-    protected $_onlyMemoryCaching = false;
-
-    /**
-    * Memory caching array
-    *
-    * @var array $_memoryCachingArray
-    */
-    protected $_memoryCachingArray = array();
-
-    /**
-    * Memory caching counter
-    *
-    * @var int $memoryCachingCounter
-    */
-    protected $_memoryCachingCounter = 0;
-
-    /**
-    * Memory caching limit
-    *
-    * @var int $memoryCachingLimit
-    */
-    protected $_memoryCachingLimit = 1000;
-
-    /**
-    * File Name protection
-    *
-    * if set to true, you can use any cache id or group name
-    * if set to false, it can be faster but cache ids and group names
-    * will be used directly in cache file names so be carefull with
-    * special characters...
-    *
-    * @var boolean $fileNameProtection
-    */
-    protected $_fileNameProtection = true;
-
-    /**
-    * Enable / disable automatic serialization
-    *
-    * it can be used to save directly datas which aren't strings
-    * (but it's slower)
-    *
-    * @var boolean $_serialize
-    */
-    protected $_automaticSerialization = false;
-
-    // --- Public methods ---
-
-    /**
-    * Constructor
-    *
-    * $options is an assoc. Available options are :
-    * $options = array(
-    * 'cacheDir' => directory where to put the cache files (string),
-    * 'caching' => enable / disable caching (boolean),
-    * 'lifeTime' => cache lifetime in seconds (int),
-    * 'fileLocking' => enable / disable fileLocking (boolean),
-    * 'writeControl' => enable / disable write control (boolean),
-    * 'readControl' => enable / disable read control (boolean),
-    * 'readControlType' => type of read control 'crc32', 'md5', 'strlen',
-    * 'memoryCaching' => enable / disable memory caching (boolean),
-    * 'onlyMemoryCaching' => enable / disable only memory caching (boolean),
-    * 'memoryCachingLimit' => max nbr of records in memory caching (int),
-    * 'fileNameProtection' => enable / disable file name protection (boolean),
-    * 'automaticSerialization' => enable / disable serialization (boolean)
-    * );
-    *
-    * @param array $options options
-    * @access public
-    */
-    function __construct($options = array(null))
-    {
-        $availableOptions = array(	'automaticSerialization',
-        							'fileNameProtection',
-        							'memoryCaching',
-        							'onlyMemoryCaching',
-        							'memoryCachingLimit',
-        							'cacheDir',
-        							'caching',
-        							'lifeTime',
-        							'fileLocking',
-        							'writeControl',
-        							'readControl',
-        							'readControlType');
-        foreach($options as $key => $value) {
-            if(in_array($key, $availableOptions)) {
-                $property = '_'.$key;
-                $this->$property = $value;
-            }
-        }
-        $this->_refreshTime = time() - $this->_lifeTime;
+	// --- Private properties ---
+
+	/**
+	 * Directory where to put the cache files
+	 * (make sure to add a trailing slash)
+	 *
+	 * @var string $_cacheDir
+	 */
+	protected $_cacheDir = '/tmp/';
+
+	/**
+	 * Enable / disable caching
+	 *
+	 * (can be very usefull for the debug of cached scripts)
+	 *
+	 * @var boolean $_caching
+	 */
+	protected $_caching = true;
+
+	/**
+	 * Cache lifetime (in seconds)
+	 *
+	 * @var int $_lifeTime
+	 */
+	protected $_lifeTime = 3600;
+
+	/**
+	 * Enable / disable fileLocking
+	 *
+	 * (can avoid cache corruption under bad circumstances)
+	 *
+	 * @var boolean $_fileLocking
+	 */
+	protected $_fileLocking = true;
+
+	/**
+	 * Timestamp of the last valid cache
+	 *
+	 * @var int $_refreshTime
+	 */
+	protected $_refreshTime;
+
+	/**
+	 * File name (with path)
+	 *
+	 * @var string $_file
+	 */
+	protected $_file;
+
+	/**
+	 * Enable / disable write control (the cache is read just after writing
+	 * to detect corrupt entries)
+	 *
+	 * Enable write control will lightly slow the cache writing but not the
+	 * cache reading. Write control can detect some corrupt cache files but
+	 * maybe it's not a perfect control
+	 *
+	 * @var boolean $_writeControl
+	 */
+	protected $_writeControl = true;
+
+	/**
+	 * Enable / disable read control
+	 *
+	 * If enabled, a control key is embeded in cache file and this key is
+	 * compared with the one calculated after the reading.
+	 *
+	 * @var boolean $_writeControl
+	 */
+	protected $_readControl = true;
+
+	/**
+	 * Type of read control (only if read control is enabled)
+	 *
+	 * Available values are :
+	 * 'md5' for a md5 hash control (best but slowest)
+	 * 'crc32' for a crc32 hash control (lightly less safe but faster,
+	 * better choice)
+	 * 'strlen' for a length only test (fastest)
+	 *
+	 * @var boolean $_readControlType
+	 */
+	protected $_readControlType = 'crc32';
+
+	/**
+	 * Current cache id
+	 *
+	 * @var string $_id
+	 */
+	protected $_id;
+
+	/**
+	 * Current cache group
+	 *
+	 * @var string $_group
+	 */
+	protected $_group;
+
+	/**
+	 * Enable / Disable "Memory Caching"
+	 *
+	 * NB : There is no lifetime for memory caching !
+	 *
+	 * @var boolean $_memoryCaching
+	 */
+	protected $_memoryCaching = false;
+
+	/**
+	 * Enable / Disable "Only Memory Caching"
+	 * (be carefull, memory caching is "beta quality")
+	 *
+	 * @var boolean $_onlyMemoryCaching
+	 */
+	protected $_onlyMemoryCaching = false;
+
+	/**
+	 * Memory caching array
+	 *
+	 * @var array $_memoryCachingArray
+	 */
+	protected $_memoryCachingArray = array();
+
+	/**
+	 * Memory caching counter
+	 *
+	 * @var int $memoryCachingCounter
+	 */
+	protected $_memoryCachingCounter = 0;
+
+	/**
+	 * Memory caching limit
+	 *
+	 * @var int $memoryCachingLimit
+	 */
+	protected $_memoryCachingLimit = 1000;
+
+	/**
+	 * File Name protection
+	 *
+	 * if set to true, you can use any cache id or group name
+	 * if set to false, it can be faster but cache ids and group names
+	 * will be used directly in cache file names so be carefull with
+	 * special characters...
+	 *
+	 * @var boolean $fileNameProtection
+	 */
+	protected $_fileNameProtection = true;
+
+	/**
+	 * Enable / disable automatic serialization
+	 *
+	 * it can be used to save directly datas which aren't strings
+	 * (but it's slower)
+	 *
+	 * @var boolean $_serialize
+	 */
+	protected $_automaticSerialization = false;
+
+	// --- Public methods ---
+
+	/**
+	 * Constructor
+	 *
+	 * $options is an assoc. Available options are :
+	 * $options = array(
+	 * 'cacheDir' => directory where to put the cache files (string),
+	 * 'caching' => enable / disable caching (boolean),
+	 * 'lifeTime' => cache lifetime in seconds (int),
+	 * 'fileLocking' => enable / disable fileLocking (boolean),
+	 * 'writeControl' => enable / disable write control (boolean),
+	 * 'readControl' => enable / disable read control (boolean),
+	 * 'readControlType' => type of read control 'crc32', 'md5', 'strlen',
+	 * 'memoryCaching' => enable / disable memory caching (boolean),
+	 * 'onlyMemoryCaching' => enable / disable only memory caching (boolean),
+	 * 'memoryCachingLimit' => max nbr of records in memory caching (int),
+	 * 'fileNameProtection' => enable / disable file name protection (boolean),
+	 * 'automaticSerialization' => enable / disable serialization (boolean)
+	 * );
+	 *
+	 * @param array $options options
+	 * @access public
+	 */
+	function __construct($options = array(null))
+	{
+		$availableOptions = array(	'automaticSerialization',
+									'fileNameProtection',
+									'memoryCaching',
+									'onlyMemoryCaching',
+									'memoryCachingLimit',
+									'cacheDir',
+									'caching',
+									'lifeTime',
+									'fileLocking',
+									'writeControl',
+									'readControl',
+									'readControlType');
+		foreach($options as $key => $value) {
+			if(in_array($key, $availableOptions)) {
+				$property = '_'.$key;
+				$this->$property = $value;
+			}
+		}
+		$this->_refreshTime = time() - $this->_lifeTime;
 	}
 
-    /**
-    * Test if a cache is available and (if yes) return it
-    *
-    * @param string $id cache id
-    * @param string $group name of the cache group
-    * @param boolean $doNotTestCacheValidity if set to true, the cache
-    * validity won't be tested
-    * @return string data of the cache (or false if no cache available)
-    * @access public
-    */
-    function get($id, $group = 'default', $doNotTestCacheValidity = false)
-    {
-        $this->_id = $id;
-        $this->_group = $group;
-        $data = false;
-        if ($this->_caching) {
-            $this->_setFileName($id, $group);
-            if ($this->_memoryCaching) {
-                if (isset($this->_memoryCachingArray[$this->_file])) {
-                    if ($this->_automaticSerialization) {
-                        return unserialize(
-                        			$this->_memoryCachingArray[$this->_file]);
-                    } else {
-                        return $this->_memoryCachingArray[$this->_file];
-                    }
-                } else {
-                    if ($this->_onlyMemoryCaching) {
-                        return false;
-                    }
-                }
-            }
-            if ($doNotTestCacheValidity) {
-                if (file_exists($this->_file)) {
-                    $data = $this->_read();
-                }
-            } else {
-                if (@filemtime($this->_file) > $this->_refreshTime) {
-                    $data = $this->_read();
-                }
-            }
-            if (($data) and ($this->_memoryCaching)) {
-                $this->_memoryCacheAdd($this->_file, $data);
-            }
-            if ($this->_automaticSerialization && is_string($data)) {
-                $data = unserialize($data);
-            }
-            return $data;
-        }
-        return false;
-    }
-
-    /**
-    * Save some data in a cache file
-    *
-    * @param string $data data to put in cache (can be another type than strings
-    * if automaticSerialization is on)
-    * @param string $id cache id
-    * @param string $group name of the cache group
-    * @return boolean true if no problem
-    * @access public
-    */
-    function save($data, $id = null, $group = 'default')
-    {
-        if ($this->_caching) {
-            if ($this->_automaticSerialization) {
-                $data = serialize($data);
-            }
-            if (isset($id)) {
-                $this->_setFileName($id, $group);
-            }
-            if ($this->_memoryCaching) {
-                $this->_memoryCacheAdd($this->_file, $data);
-                if ($this->_onlyMemoryCaching) {
-                    return true;
-                }
-            }
-            if ($this->_writeControl) {
-                if (!$this->_writeAndControl($data)) {
-                    @touch($this->_file, time() - 2*abs($this->_lifeTime));
-                    return false;
-                } else {
-                    return true;
-                }
-            } else {
-                return $this->_write($data);
-            }
-        }
-        return false;
-    }
-
-    /**
-    * Remove a cache file
-    *
-    * @param string $id cache id
-    * @param string $group name of the cache group
-    * @return boolean true if no problem
-    * @access public
-    */
-    function remove($id, $group = 'default')
-    {
-        $this->_setFileName($id, $group);
-        if (!@unlink($this->_file)) {
-            $this->raiseError('TCache_Lite : Unable to remove cache !', -3);
-            return false;
-        }
-        return true;
-    }
-
-    /**
-    * Clean the cache
-    *
-    * if no group is specified all cache files will be destroyed
-    * else only cache files of the specified group will be destroyed
-    *
-    * @param string $group name of the cache group
-    * @return boolean true if no problem
-    * @access public
-    */
-    function clean($group = false)
-    {
-        if ($this->_fileNameProtection) {
-            $motif = ($group) ? 'cache_'.md5($group).'_' : 'cache_';
-        } else {
-            $motif = ($group) ? 'cache_'.$group.'_' : 'cache_';
-        }
-        if ($this->_memoryCaching) {
-            while (list($key, $value) = each($this->_memoryCaching)) {
-                if (strpos($key, $motif, 0)) {
-                    unset($this->_memoryCaching[$key]);
-                    $this->_memoryCachingCounter =
-                    		$this->_memoryCachingCounter - 1;
-                }
-            }
-            if ($this->_onlyMemoryCaching) {
-                return true;
-            }
-        }
-        if (!($dh = opendir($this->_cacheDir))) {
-            $this->raiseError('TCache_Lite : Unable to open cache directory !');
-            return false;
-        }
-        while ($file = readdir($dh)) {
-            if (($file != '.') && ($file != '..')) {
-                $file = $this->_cacheDir . $file;
-                if (is_file($file)) {
-                    if (strpos($file, $motif, 0)) {
-                        if (!@unlink($file)) {
-             $this->raiseError('Cache_Lite : Unable to remove cache !', -3);
-                            return false;
-                        }
-                    }
-                }
-            }
-        }
-        return true;
-    }
-
-	    /**
-    * Set a new life time
-    *
-    * @param int $newLifeTime new life time (in seconds)
-    * @access public
-    */
-    function setLifeTime($newLifeTime)
-    {
-        $this->_lifeTime = $newLifeTime;
-        $this->_refreshTime = time() - $newLifeTime;
-    }
-
-    /**
-    *
-    * @access public
-    */
-    function saveMemoryCachingState($id, $group = 'default')
-    {
-        if ($this->_caching) {
-            $array = array(
-                'counter' => $this->_memoryCachingCounter,
-                'array' => $this->_memoryCachingState
-            );
-            $data = serialize($array);
-            $this->save($data, $id, $group);
-        }
-    }
-
-    /**
-    *
-    * @access public
-    */
-    function getMemoryCachingState($id, $group = 'default',
-    								$doNotTestCacheValidity = false)
-    {
-        if ($this->_caching) {
-            if ($data = $this->get($id, $group, $doNotTestCacheValidity))
-            {
-                $array = unserialize($data);
-                $this->_memoryCachingCounter = $array['counter'];
-                $this->_memoryCachingArray = $array['array'];
-            }
-        }
-    }
-
-    /**
-    * Return the cache last modification time
-    *
-    * BE CAREFUL : THIS METHOD IS FOR HACKING ONLY !
-    *
-    * @return int last modification time
-    */
-    function lastModified() {
-        return filemtime($this->cache->_file);
-    }
-
-    /**
-    * Trigger a PEAR error
-    *
-    * To improve performances, the PEAR.php file is included dynamically.
-    * The file is so included only when an error is triggered. So, in most
-    * cases, the file isn't included and perfs are much better.
-    *
-    * @param string $msg error message
-    * @param int $code error code
-    * @access public
-    */
-    function raiseError($msg, $code)
-    {
-       throw new Exception($msg);
-    }
-
-    // --- Private methods ---
-
-    /**
-    *
-    * @access private
-    */
-    function _memoryCacheAdd($id, $data)
-    {
-        $this->_memoryCachingArray[$this->_file] = $data;
-        if ($this->_memoryCachingCounter >= $this->_memoryCachingLimit) {
-            list($key, $value) = each($this->_memoryCachingArray);
-            unset($this->_memoryCachingArray[$key]);
-        } else {
-            $this->_memoryCachingCounter = $this->_memoryCachingCounter + 1;
-        }
-    }
-
-    /**
-    * Make a file name (with path)
-    *
-    * @param string $id cache id
-    * @param string $group name of the group
-    * @access private
-    */
-    function _setFileName($id, $group)
-    {
-        if ($this->_fileNameProtection) {
-            $this->_file = ($this->_cacheDir.'cache_'.md5($group).'_'
-            						.md5($id));
-        } else {
-            $this->_file = $this->_cacheDir.'cache_'.$group.'_'.$id;
-        }
-    }
-
-    function getCacheFile()
-    {
-    	return $this->_file;
-    }
-
-    /**
-    * Read the cache file and return the content
-    *
-    * @return string content of the cache file
-    * @access private
-    */
-    function _read()
-    {
-        $fp = @fopen($this->_file, "rb");
-        if ($this->_fileLocking) @flock($fp, LOCK_SH);
-        if ($fp) {
-        	// because the filesize can be cached by PHP itself...
-            clearstatcache();
-            $length = @filesize($this->_file);
-            if ($this->_readControl) {
-                $hashControl = @fread($fp, 32);
-                $length = $length - 32;
-            }
-            $data = @fread($fp, $length);
-            if ($this->_fileLocking) @flock($fp, LOCK_UN);
-            @fclose($fp);
-            if ($this->_readControl) {
-                $hashData = $this->_hash($data, $this->_readControlType);
-                if ($hashData != $hashControl) {
-                    @touch($this->_file, time() - 2*abs($this->_lifeTime));
-                    return false;
-                }
-            }
-            return $data;
-        }
-        $this->raiseError('Cache_Lite : Unable to read cache !', -2);
-        return false;
-    }
-
-    /**
-    * Write the given data in the cache file
-    *
-    * @param string $data data to put in cache
-    * @return boolean true if ok
-    * @access private
-    */
-    function _write($data)
-    {
-        $fp = @fopen($this->_file, "wb");
-        if ($fp) {
-            if ($this->_fileLocking) @flock($fp, LOCK_EX);
-            if ($this->_readControl) {
-                @fwrite($fp, $this->_hash($data, $this->_readControlType), 32);
-            }
-            $len = strlen($data);
-            @fwrite($fp, $data, $len);
-            if ($this->_fileLocking) @flock($fp, LOCK_UN);
-            @fclose($fp);
-            return true;
-        }
-        $this->raiseError('Cache_Lite : Unable to write cache !', -1);
-        return false;
-    }
-
-    /**
-    * Write the given data in the cache file and control it just after to avoid
-    * corrupted cache entries
-    *
-    * @param string $data data to put in cache
-    * @return boolean true if the test is ok
-    * @access private
-    */
-    function _writeAndControl($data)
-    {
-        $this->_write($data);
-        $dataRead = $this->_read($data);
-        return ($dataRead==$data);
-    }
-
-    /**
-    * Make a control key with the string containing datas
-    *
-    * @param string $data data
-    * @param string $controlType type of control 'md5', 'crc32' or 'strlen'
-    * @return string control key
-    * @access private
-    */
-    function _hash($data, $controlType)
-    {
-        switch ($controlType) {
-        case 'md5':
-            return md5($data);
-        case 'crc32':
-            return sprintf('% 32d', crc32($data));
-        case 'strlen':
-            return sprintf('% 32d', strlen($data));
-        default:
-            $this->raiseError('Unknown controlType ! '.
-            '(available values are only \'md5\', \'crc32\', \'strlen\')', -5);
-        }
-    }
+	/**
+	 * Test if a cache is available and (if yes) return it
+	 *
+	 * @param string $id cache id
+	 * @param string $group name of the cache group
+	 * @param boolean $doNotTestCacheValidity if set to true, the cache
+	 * validity won't be tested
+	 * @return string data of the cache (or false if no cache available)
+	 * @access public
+	 */
+	function get($id, $group = 'default', $doNotTestCacheValidity = false)
+	{
+		$this->_id = $id;
+		$this->_group = $group;
+		$data = false;
+		if ($this->_caching) {
+			$this->_setFileName($id, $group);
+			if ($this->_memoryCaching) {
+				if (isset($this->_memoryCachingArray[$this->_file])) {
+					if ($this->_automaticSerialization) {
+						return unserialize(
+									$this->_memoryCachingArray[$this->_file]);
+					} else {
+						return $this->_memoryCachingArray[$this->_file];
+					}
+				} else {
+					if ($this->_onlyMemoryCaching) {
+						return false;
+					}
+				}
+			}
+			if ($doNotTestCacheValidity) {
+				if (file_exists($this->_file)) {
+					$data = $this->_read();
+				}
+			} else {
+				if (@filemtime($this->_file) > $this->_refreshTime) {
+					$data = $this->_read();
+				}
+			}
+			if (($data) and ($this->_memoryCaching)) {
+				$this->_memoryCacheAdd($this->_file, $data);
+			}
+			if ($this->_automaticSerialization && is_string($data)) {
+				$data = unserialize($data);
+			}
+			return $data;
+		}
+		return false;
+	}
+
+	/**
+	 * Save some data in a cache file
+	 *
+	 * @param string $data data to put in cache (can be another type than strings
+	 * if automaticSerialization is on)
+	 * @param string $id cache id
+	 * @param string $group name of the cache group
+	 * @return boolean true if no problem
+	 * @access public
+	 */
+	function save($data, $id = null, $group = 'default')
+	{
+		if ($this->_caching) {
+			if ($this->_automaticSerialization) {
+				$data = serialize($data);
+			}
+			if (isset($id)) {
+				$this->_setFileName($id, $group);
+			}
+			if ($this->_memoryCaching) {
+				$this->_memoryCacheAdd($this->_file, $data);
+				if ($this->_onlyMemoryCaching) {
+					return true;
+				}
+			}
+			if ($this->_writeControl) {
+				if (!$this->_writeAndControl($data)) {
+					@touch($this->_file, time() - 2*abs($this->_lifeTime));
+					return false;
+				} else {
+					return true;
+				}
+			} else {
+				return $this->_write($data);
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Remove a cache file
+	 *
+	 * @param string $id cache id
+	 * @param string $group name of the cache group
+	 * @return boolean true if no problem
+	 * @access public
+	 */
+	function remove($id, $group = 'default')
+	{
+		$this->_setFileName($id, $group);
+		if (!@unlink($this->_file)) {
+			$this->raiseError('TCache_Lite : Unable to remove cache !', -3);
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Clean the cache
+	 *
+	 * if no group is specified all cache files will be destroyed
+	 * else only cache files of the specified group will be destroyed
+	 *
+	 * @param string $group name of the cache group
+	 * @return boolean true if no problem
+	 * @access public
+	 */
+	function clean($group = false)
+	{
+		if ($this->_fileNameProtection) {
+			$motif = ($group) ? 'cache_'.md5($group).'_' : 'cache_';
+		} else {
+			$motif = ($group) ? 'cache_'.$group.'_' : 'cache_';
+		}
+		if ($this->_memoryCaching) {
+			while (list($key, $value) = each($this->_memoryCaching)) {
+				if (strpos($key, $motif, 0)) {
+					unset($this->_memoryCaching[$key]);
+					$this->_memoryCachingCounter =
+							$this->_memoryCachingCounter - 1;
+				}
+			}
+			if ($this->_onlyMemoryCaching) {
+				return true;
+			}
+		}
+		if (!($dh = opendir($this->_cacheDir))) {
+			$this->raiseError('TCache_Lite : Unable to open cache directory !');
+			return false;
+		}
+		while ($file = readdir($dh)) {
+			if (($file != '.') && ($file != '..')) {
+				$file = $this->_cacheDir . $file;
+				if (is_file($file)) {
+					if (strpos($file, $motif, 0)) {
+						if (!@unlink($file)) {
+			 $this->raiseError('Cache_Lite : Unable to remove cache !', -3);
+							return false;
+						}
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+		/**
+		 * Set a new life time
+		 *
+		 * @param int $newLifeTime new life time (in seconds)
+		 * @access public
+		 */
+	function setLifeTime($newLifeTime)
+	{
+		$this->_lifeTime = $newLifeTime;
+		$this->_refreshTime = time() - $newLifeTime;
+	}
+
+	/**
+	 *
+	 * @access public
+	 */
+	function saveMemoryCachingState($id, $group = 'default')
+	{
+		if ($this->_caching) {
+			$array = array(
+				'counter' => $this->_memoryCachingCounter,
+				'array' => $this->_memoryCachingState
+			);
+			$data = serialize($array);
+			$this->save($data, $id, $group);
+		}
+	}
+
+	/**
+	 *
+	 * @access public
+	 */
+	function getMemoryCachingState($id, $group = 'default',
+									$doNotTestCacheValidity = false)
+	{
+		if ($this->_caching) {
+			if ($data = $this->get($id, $group, $doNotTestCacheValidity))
+			{
+				$array = unserialize($data);
+				$this->_memoryCachingCounter = $array['counter'];
+				$this->_memoryCachingArray = $array['array'];
+			}
+		}
+	}
+
+	/**
+	 * Return the cache last modification time
+	 *
+	 * BE CAREFUL : THIS METHOD IS FOR HACKING ONLY !
+	 *
+	 * @return int last modification time
+	 */
+	function lastModified() {
+		return filemtime($this->cache->_file);
+	}
+
+	/**
+	 * Trigger a PEAR error
+	 *
+	 * To improve performances, the PEAR.php file is included dynamically.
+	 * The file is so included only when an error is triggered. So, in most
+	 * cases, the file isn't included and perfs are much better.
+	 *
+	 * @param string $msg error message
+	 * @param int $code error code
+	 * @access public
+	 */
+	function raiseError($msg, $code)
+	{
+	   throw new Exception($msg);
+	}
+
+	// --- Private methods ---
+
+	/**
+	 *
+	 * @access private
+	 */
+	function _memoryCacheAdd($id, $data)
+	{
+		$this->_memoryCachingArray[$this->_file] = $data;
+		if ($this->_memoryCachingCounter >= $this->_memoryCachingLimit) {
+			list($key, $value) = each($this->_memoryCachingArray);
+			unset($this->_memoryCachingArray[$key]);
+		} else {
+			$this->_memoryCachingCounter = $this->_memoryCachingCounter + 1;
+		}
+	}
+
+	/**
+	 * Make a file name (with path)
+	 *
+	 * @param string $id cache id
+	 * @param string $group name of the group
+	 * @access private
+	 */
+	function _setFileName($id, $group)
+	{
+		if ($this->_fileNameProtection) {
+			$this->_file = ($this->_cacheDir.'cache_'.md5($group).'_'
+									.md5($id));
+		} else {
+			$this->_file = $this->_cacheDir.'cache_'.$group.'_'.$id;
+		}
+	}
+
+	function getCacheFile()
+	{
+		return $this->_file;
+	}
+
+	/**
+	 * Read the cache file and return the content
+	 *
+	 * @return string content of the cache file
+	 * @access private
+	 */
+	function _read()
+	{
+		$fp = @fopen($this->_file, "rb");
+		if ($this->_fileLocking) @flock($fp, LOCK_SH);
+		if ($fp) {
+			// because the filesize can be cached by PHP itself...
+			clearstatcache();
+			$length = @filesize($this->_file);
+			if ($this->_readControl) {
+				$hashControl = @fread($fp, 32);
+				$length = $length - 32;
+			}
+			$data = @fread($fp, $length);
+			if ($this->_fileLocking) @flock($fp, LOCK_UN);
+			@fclose($fp);
+			if ($this->_readControl) {
+				$hashData = $this->_hash($data, $this->_readControlType);
+				if ($hashData != $hashControl) {
+					@touch($this->_file, time() - 2*abs($this->_lifeTime));
+					return false;
+				}
+			}
+			return $data;
+		}
+		$this->raiseError('Cache_Lite : Unable to read cache !', -2);
+		return false;
+	}
+
+	/**
+	 * Write the given data in the cache file
+	 *
+	 * @param string $data data to put in cache
+	 * @return boolean true if ok
+	 * @access private
+	 */
+	function _write($data)
+	{
+		$fp = @fopen($this->_file, "wb");
+		if ($fp) {
+			if ($this->_fileLocking) @flock($fp, LOCK_EX);
+			if ($this->_readControl) {
+				@fwrite($fp, $this->_hash($data, $this->_readControlType), 32);
+			}
+			$len = strlen($data);
+			@fwrite($fp, $data, $len);
+			if ($this->_fileLocking) @flock($fp, LOCK_UN);
+			@fclose($fp);
+			return true;
+		}
+		$this->raiseError('Cache_Lite : Unable to write cache !', -1);
+		return false;
+	}
+
+	/**
+	 * Write the given data in the cache file and control it just after to avoid
+	 * corrupted cache entries
+	 *
+	 * @param string $data data to put in cache
+	 * @return boolean true if the test is ok
+	 * @access private
+	 */
+	function _writeAndControl($data)
+	{
+		$this->_write($data);
+		$dataRead = $this->_read($data);
+		return ($dataRead==$data);
+	}
+
+	/**
+	 * Make a control key with the string containing datas
+	 *
+	 * @param string $data data
+	 * @param string $controlType type of control 'md5', 'crc32' or 'strlen'
+	 * @return string control key
+	 * @access private
+	 */
+	function _hash($data, $controlType)
+	{
+		switch ($controlType) {
+		case 'md5':
+			return md5($data);
+		case 'crc32':
+			return sprintf('% 32d', crc32($data));
+		case 'strlen':
+			return sprintf('% 32d', strlen($data));
+		default:
+			$this->raiseError('Unknown controlType ! '.
+			'(available values are only \'md5\', \'crc32\', \'strlen\')', -5);
+		}
+	}
 
 }
 

Spacing +105 added lines, -105 removed lines

@@ -54,7 +54,7 @@ 
     *
     * @var string $_cacheDir
     */
-    protected $_cacheDir = '/tmp/';
+    protected $_cacheDir='/tmp/';
 
     /**
     * Enable / disable caching
@@ -63,14 +63,14 @@ 
     *
     * @var boolean $_caching
     */
-    protected $_caching = true;
+    protected $_caching=true;
 
     /**
     * Cache lifetime (in seconds)
     *
     * @var int $_lifeTime
     */
-    protected $_lifeTime = 3600;
+    protected $_lifeTime=3600;
 
     /**
     * Enable / disable fileLocking
@@ -79,7 +79,7 @@ 
     *
     * @var boolean $_fileLocking
     */
-    protected $_fileLocking = true;
+    protected $_fileLocking=true;
 
     /**
     * Timestamp of the last valid cache
@@ -105,7 +105,7 @@ 
     *
     * @var boolean $_writeControl
     */
-    protected $_writeControl = true;
+    protected $_writeControl=true;
 
     /**
     * Enable / disable read control
@@ -115,7 +115,7 @@ 
     *
     * @var boolean $_writeControl
     */
-    protected $_readControl = true;
+    protected $_readControl=true;
 
     /**
     * Type of read control (only if read control is enabled)
@@ -128,7 +128,7 @@ 
     *
     * @var boolean $_readControlType
     */
-    protected $_readControlType = 'crc32';
+    protected $_readControlType='crc32';
 
     /**
     * Current cache id
@@ -151,7 +151,7 @@ 
     *
     * @var boolean $_memoryCaching
     */
-    protected $_memoryCaching = false;
+    protected $_memoryCaching=false;
 
     /**
     * Enable / Disable "Only Memory Caching"
@@ -159,28 +159,28 @@ 
     *
     * @var boolean $_onlyMemoryCaching
     */
-    protected $_onlyMemoryCaching = false;
+    protected $_onlyMemoryCaching=false;
 
     /**
     * Memory caching array
     *
     * @var array $_memoryCachingArray
     */
-    protected $_memoryCachingArray = array();
+    protected $_memoryCachingArray=array();
 
     /**
     * Memory caching counter
     *
     * @var int $memoryCachingCounter
     */
-    protected $_memoryCachingCounter = 0;
+    protected $_memoryCachingCounter=0;
 
     /**
     * Memory caching limit
     *
     * @var int $memoryCachingLimit
     */
-    protected $_memoryCachingLimit = 1000;
+    protected $_memoryCachingLimit=1000;
 
     /**
     * File Name protection
@@ -192,7 +192,7 @@ 
     *
     * @var boolean $fileNameProtection
     */
-    protected $_fileNameProtection = true;
+    protected $_fileNameProtection=true;
 
     /**
     * Enable / disable automatic serialization
@@ -202,7 +202,7 @@ 
     *
     * @var boolean $_serialize
     */
-    protected $_automaticSerialization = false;
+    protected $_automaticSerialization=false;
 
     // --- Public methods ---
 
@@ -228,9 +228,9 @@ 
     * @param array $options options
     * @access public
     */
-    function __construct($options = array(null))
+    function __construct($options=array(null))
     {
-        $availableOptions = array(	'automaticSerialization',
+        $availableOptions=array('automaticSerialization',
         							'fileNameProtection',
         							'memoryCaching',
         							'onlyMemoryCaching',
@@ -244,11 +244,11 @@ 
         							'readControlType');
         foreach($options as $key => $value) {
             if(in_array($key, $availableOptions)) {
-                $property = '_'.$key;
-                $this->$property = $value;
+                $property='_'.$key;
+                $this->$property=$value;
             }
         }
-        $this->_refreshTime = time() - $this->_lifeTime;
+        $this->_refreshTime=time() - $this->_lifeTime;
 	}
 
     /**
@@ -261,41 +261,41 @@ 
     * @return string data of the cache (or false if no cache available)
     * @access public
     */
-    function get($id, $group = 'default', $doNotTestCacheValidity = false)
+    function get($id, $group='default', $doNotTestCacheValidity=false)
     {
-        $this->_id = $id;
-        $this->_group = $group;
-        $data = false;
-        if ($this->_caching) {
+        $this->_id=$id;
+        $this->_group=$group;
+        $data=false;
+        if($this->_caching) {
             $this->_setFileName($id, $group);
-            if ($this->_memoryCaching) {
-                if (isset($this->_memoryCachingArray[$this->_file])) {
-                    if ($this->_automaticSerialization) {
+            if($this->_memoryCaching) {
+                if(isset($this->_memoryCachingArray[$this->_file])) {
+                    if($this->_automaticSerialization) {
                         return unserialize(
                         			$this->_memoryCachingArray[$this->_file]);
                     } else {
                         return $this->_memoryCachingArray[$this->_file];
                     }
                 } else {
-                    if ($this->_onlyMemoryCaching) {
+                    if($this->_onlyMemoryCaching) {
                         return false;
                     }
                 }
             }
-            if ($doNotTestCacheValidity) {
-                if (file_exists($this->_file)) {
-                    $data = $this->_read();
+            if($doNotTestCacheValidity) {
+                if(file_exists($this->_file)) {
+                    $data=$this->_read();
                 }
             } else {
-                if (@filemtime($this->_file) > $this->_refreshTime) {
-                    $data = $this->_read();
+                if(@filemtime($this->_file) > $this->_refreshTime) {
+                    $data=$this->_read();
                 }
             }
-            if (($data) and ($this->_memoryCaching)) {
+            if(($data) and ($this->_memoryCaching)) {
                 $this->_memoryCacheAdd($this->_file, $data);
             }
-            if ($this->_automaticSerialization && is_string($data)) {
-                $data = unserialize($data);
+            if($this->_automaticSerialization && is_string($data)) {
+                $data=unserialize($data);
             }
             return $data;
         }
@@ -312,24 +312,24 @@ 
     * @return boolean true if no problem
     * @access public
     */
-    function save($data, $id = null, $group = 'default')
+    function save($data, $id=null, $group='default')
     {
-        if ($this->_caching) {
-            if ($this->_automaticSerialization) {
-                $data = serialize($data);
+        if($this->_caching) {
+            if($this->_automaticSerialization) {
+                $data=serialize($data);
             }
-            if (isset($id)) {
+            if(isset($id)) {
                 $this->_setFileName($id, $group);
             }
-            if ($this->_memoryCaching) {
+            if($this->_memoryCaching) {
                 $this->_memoryCacheAdd($this->_file, $data);
-                if ($this->_onlyMemoryCaching) {
+                if($this->_onlyMemoryCaching) {
                     return true;
                 }
             }
-            if ($this->_writeControl) {
-                if (!$this->_writeAndControl($data)) {
-                    @touch($this->_file, time() - 2*abs($this->_lifeTime));
+            if($this->_writeControl) {
+                if(!$this->_writeAndControl($data)) {
+                    @touch($this->_file, time() - 2 * abs($this->_lifeTime));
                     return false;
                 } else {
                     return true;
@@ -349,10 +349,10 @@ 
     * @return boolean true if no problem
     * @access public
     */
-    function remove($id, $group = 'default')
+    function remove($id, $group='default')
     {
         $this->_setFileName($id, $group);
-        if (!@unlink($this->_file)) {
+        if(!@unlink($this->_file)) {
             $this->raiseError('TCache_Lite : Unable to remove cache !', -3);
             return false;
         }
@@ -369,35 +369,35 @@ 
     * @return boolean true if no problem
     * @access public
     */
-    function clean($group = false)
+    function clean($group=false)
     {
-        if ($this->_fileNameProtection) {
-            $motif = ($group) ? 'cache_'.md5($group).'_' : 'cache_';
+        if($this->_fileNameProtection) {
+            $motif=($group) ? 'cache_'.md5($group).'_' : 'cache_';
         } else {
-            $motif = ($group) ? 'cache_'.$group.'_' : 'cache_';
+            $motif=($group) ? 'cache_'.$group.'_' : 'cache_';
         }
-        if ($this->_memoryCaching) {
-            while (list($key, $value) = each($this->_memoryCaching)) {
-                if (strpos($key, $motif, 0)) {
+        if($this->_memoryCaching) {
+            while(list($key, $value)=each($this->_memoryCaching)) {
+                if(strpos($key, $motif, 0)) {
                     unset($this->_memoryCaching[$key]);
-                    $this->_memoryCachingCounter =
+                    $this->_memoryCachingCounter=
                     		$this->_memoryCachingCounter - 1;
                 }
             }
-            if ($this->_onlyMemoryCaching) {
+            if($this->_onlyMemoryCaching) {
                 return true;
             }
         }
-        if (!($dh = opendir($this->_cacheDir))) {
+        if(!($dh=opendir($this->_cacheDir))) {
             $this->raiseError('TCache_Lite : Unable to open cache directory !');
             return false;
         }
-        while ($file = readdir($dh)) {
-            if (($file != '.') && ($file != '..')) {
-                $file = $this->_cacheDir . $file;
-                if (is_file($file)) {
-                    if (strpos($file, $motif, 0)) {
-                        if (!@unlink($file)) {
+        while($file=readdir($dh)) {
+            if(($file!='.') && ($file!='..')) {
+                $file=$this->_cacheDir.$file;
+                if(is_file($file)) {
+                    if(strpos($file, $motif, 0)) {
+                        if(!@unlink($file)) {
              $this->raiseError('Cache_Lite : Unable to remove cache !', -3);
                             return false;
                         }
@@ -416,22 +416,22 @@ 
     */
     function setLifeTime($newLifeTime)
     {
-        $this->_lifeTime = $newLifeTime;
-        $this->_refreshTime = time() - $newLifeTime;
+        $this->_lifeTime=$newLifeTime;
+        $this->_refreshTime=time() - $newLifeTime;
     }
 
     /**
     *
     * @access public
     */
-    function saveMemoryCachingState($id, $group = 'default')
+    function saveMemoryCachingState($id, $group='default')
     {
-        if ($this->_caching) {
-            $array = array(
+        if($this->_caching) {
+            $array=array(
                 'counter' => $this->_memoryCachingCounter,
                 'array' => $this->_memoryCachingState
             );
-            $data = serialize($array);
+            $data=serialize($array);
             $this->save($data, $id, $group);
         }
     }
@@ -440,15 +440,15 @@ 
     *
     * @access public
     */
-    function getMemoryCachingState($id, $group = 'default',
-    								$doNotTestCacheValidity = false)
+    function getMemoryCachingState($id, $group='default',
+    								$doNotTestCacheValidity=false)
     {
-        if ($this->_caching) {
-            if ($data = $this->get($id, $group, $doNotTestCacheValidity))
+        if($this->_caching) {
+            if($data=$this->get($id, $group, $doNotTestCacheValidity))
             {
-                $array = unserialize($data);
-                $this->_memoryCachingCounter = $array['counter'];
-                $this->_memoryCachingArray = $array['array'];
+                $array=unserialize($data);
+                $this->_memoryCachingCounter=$array['counter'];
+                $this->_memoryCachingArray=$array['array'];
             }
         }
     }
@@ -488,12 +488,12 @@ 
     */
     function _memoryCacheAdd($id, $data)
     {
-        $this->_memoryCachingArray[$this->_file] = $data;
-        if ($this->_memoryCachingCounter >= $this->_memoryCachingLimit) {
-            list($key, $value) = each($this->_memoryCachingArray);
+        $this->_memoryCachingArray[$this->_file]=$data;
+        if($this->_memoryCachingCounter >= $this->_memoryCachingLimit) {
+            list($key, $value)=each($this->_memoryCachingArray);
             unset($this->_memoryCachingArray[$key]);
         } else {
-            $this->_memoryCachingCounter = $this->_memoryCachingCounter + 1;
+            $this->_memoryCachingCounter=$this->_memoryCachingCounter + 1;
         }
     }
 
@@ -506,11 +506,11 @@ 
     */
     function _setFileName($id, $group)
     {
-        if ($this->_fileNameProtection) {
-            $this->_file = ($this->_cacheDir.'cache_'.md5($group).'_'
+        if($this->_fileNameProtection) {
+            $this->_file=($this->_cacheDir.'cache_'.md5($group).'_'
             						.md5($id));
         } else {
-            $this->_file = $this->_cacheDir.'cache_'.$group.'_'.$id;
+            $this->_file=$this->_cacheDir.'cache_'.$group.'_'.$id;
         }
     }
 
@@ -527,23 +527,23 @@ 
     */
     function _read()
     {
-        $fp = @fopen($this->_file, "rb");
-        if ($this->_fileLocking) @flock($fp, LOCK_SH);
-        if ($fp) {
+        $fp=@fopen($this->_file, "rb");
+        if($this->_fileLocking) @flock($fp, LOCK_SH);
+        if($fp) {
         	// because the filesize can be cached by PHP itself...
             clearstatcache();
-            $length = @filesize($this->_file);
-            if ($this->_readControl) {
-                $hashControl = @fread($fp, 32);
-                $length = $length - 32;
+            $length=@filesize($this->_file);
+            if($this->_readControl) {
+                $hashControl=@fread($fp, 32);
+                $length=$length - 32;
             }
-            $data = @fread($fp, $length);
-            if ($this->_fileLocking) @flock($fp, LOCK_UN);
+            $data=@fread($fp, $length);
+            if($this->_fileLocking) @flock($fp, LOCK_UN);
             @fclose($fp);
-            if ($this->_readControl) {
-                $hashData = $this->_hash($data, $this->_readControlType);
-                if ($hashData != $hashControl) {
-                    @touch($this->_file, time() - 2*abs($this->_lifeTime));
+            if($this->_readControl) {
+                $hashData=$this->_hash($data, $this->_readControlType);
+                if($hashData!=$hashControl) {
+                    @touch($this->_file, time() - 2 * abs($this->_lifeTime));
                     return false;
                 }
             }
@@ -562,15 +562,15 @@ 
     */
     function _write($data)
     {
-        $fp = @fopen($this->_file, "wb");
-        if ($fp) {
-            if ($this->_fileLocking) @flock($fp, LOCK_EX);
-            if ($this->_readControl) {
+        $fp=@fopen($this->_file, "wb");
+        if($fp) {
+            if($this->_fileLocking) @flock($fp, LOCK_EX);
+            if($this->_readControl) {
                 @fwrite($fp, $this->_hash($data, $this->_readControlType), 32);
             }
-            $len = strlen($data);
+            $len=strlen($data);
             @fwrite($fp, $data, $len);
-            if ($this->_fileLocking) @flock($fp, LOCK_UN);
+            if($this->_fileLocking) @flock($fp, LOCK_UN);
             @fclose($fp);
             return true;
         }
@@ -589,7 +589,7 @@ 
     function _writeAndControl($data)
     {
         $this->_write($data);
-        $dataRead = $this->_read($data);
+        $dataRead=$this->_read($data);
         return ($dataRead==$data);
     }
 
@@ -603,7 +603,7 @@ 
     */
     function _hash($data, $controlType)
     {
-        switch ($controlType) {
+        switch($controlType) {
         case 'md5':
             return md5($data);
         case 'crc32':

framework/IO/TTarFileExtractor.php

Doc Comments +9 added lines

@@ -224,6 +224,9 @@ 
       return $v_block;
     }
 
+    /**
+     * @param double $p_len
+     */
     private function _jumpBlock($p_len=null)
     {
       if (is_resource($this->_file)) {
@@ -317,6 +320,12 @@ 
       return true;
     }
 
+    /**
+     * @param string $p_path
+     * @param string $p_mode
+     * @param integer $p_file_list
+     * @param string $p_remove_path
+     */
     protected function _extractList($p_path, &$p_list_detail, $p_mode,
 	                      $p_file_list, $p_remove_path)
     {

Spacing +155 added lines, -155 removed lines

@@ -60,14 +60,14 @@ 
     */
     public function __construct($p_tarname)
     {
-        $this->_tarname = $p_tarname;
+        $this->_tarname=$p_tarname;
     }
 
     public function __destruct()
     {
         $this->_close();
         // ----- Look for a local copy to delete
-        if ($this->_temp_tarname != '')
+        if($this->_temp_tarname!='')
             @unlink($this->_temp_tarname);
     }
 
@@ -110,11 +110,11 @@ 
     */
     protected function extractModify($p_path, $p_remove_path)
     {
-        $v_result = true;
-        $v_list_detail = array();
+        $v_result=true;
+        $v_list_detail=array();
 
-        if ($v_result = $this->_openRead()) {
-            $v_result = $this->_extractList($p_path, $v_list_detail,
+        if($v_result=$this->_openRead()) {
+            $v_result=$this->_extractList($p_path, $v_list_detail,
 			                                "complete", 0, $p_remove_path);
             $this->_close();
         }
@@ -129,8 +129,8 @@ 
 
     private function _isArchive($p_filename=null)
     {
-        if ($p_filename == null) {
-            $p_filename = $this->_tarname;
+        if($p_filename==null) {
+            $p_filename=$this->_tarname;
         }
         clearstatcache();
         return @is_file($p_filename);
@@ -138,39 +138,39 @@ 
 
     private function _openRead()
     {
-        if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {
+        if(strtolower(substr($this->_tarname, 0, 7))=='http://') {
 
           // ----- Look if a local copy need to be done
-          if ($this->_temp_tarname == '') {
-              $this->_temp_tarname = uniqid('tar').'.tmp';
-              if (!$v_file_from = @fopen($this->_tarname, 'rb')) {
+          if($this->_temp_tarname=='') {
+              $this->_temp_tarname=uniqid('tar').'.tmp';
+              if(!$v_file_from=@fopen($this->_tarname, 'rb')) {
                 $this->_error('Unable to open in read mode \''
 				              .$this->_tarname.'\'');
-                $this->_temp_tarname = '';
+                $this->_temp_tarname='';
                 return false;
               }
-              if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {
+              if(!$v_file_to=@fopen($this->_temp_tarname, 'wb')) {
                 $this->_error('Unable to open in write mode \''
 				              .$this->_temp_tarname.'\'');
-                $this->_temp_tarname = '';
+                $this->_temp_tarname='';
                 return false;
               }
-              while ($v_data = @fread($v_file_from, 1024))
+              while($v_data=@fread($v_file_from, 1024))
                   @fwrite($v_file_to, $v_data);
               @fclose($v_file_from);
               @fclose($v_file_to);
           }
 
           // ----- File to open if the local copy
-          $v_filename = $this->_temp_tarname;
+          $v_filename=$this->_temp_tarname;
 
         } else
           // ----- File to open if the normal Tar file
-          $v_filename = $this->_tarname;
+          $v_filename=$this->_tarname;
 
-		$this->_file = @fopen($v_filename, "rb");
+		$this->_file=@fopen($v_filename, "rb");
 
-        if ($this->_file == 0) {
+        if($this->_file==0) {
             $this->_error('Unable to open in read mode \''.$v_filename.'\'');
             return false;
         }
@@ -181,17 +181,17 @@ 
     private function _close()
     {
         //if (isset($this->_file)) {
-        if (is_resource($this->_file))
+        if(is_resource($this->_file))
 		{
                @fclose($this->_file);
-            $this->_file = 0;
+            $this->_file=0;
         }
 
         // ----- Look if a local copy need to be erase
         // Note that it might be interesting to keep the url for a time : ToDo
-        if ($this->_temp_tarname != '') {
+        if($this->_temp_tarname!='') {
             @unlink($this->_temp_tarname);
-            $this->_temp_tarname = '';
+            $this->_temp_tarname='';
         }
 
         return true;
@@ -202,76 +202,76 @@ 
         $this->_close();
 
         // ----- Look for a local copy
-        if ($this->_temp_tarname != '') {
+        if($this->_temp_tarname!='') {
             // ----- Remove the local copy but not the remote tarname
             @unlink($this->_temp_tarname);
-            $this->_temp_tarname = '';
+            $this->_temp_tarname='';
         } else {
             // ----- Remove the local tarname file
             @unlink($this->_tarname);
         }
-        $this->_tarname = '';
+        $this->_tarname='';
 
         return true;
     }
 
     private function _readBlock()
     {
-      $v_block = null;
-      if (is_resource($this->_file)) {
-              $v_block = @fread($this->_file, 512);
+      $v_block=null;
+      if(is_resource($this->_file)) {
+              $v_block=@fread($this->_file, 512);
       }
       return $v_block;
     }
 
     private function _jumpBlock($p_len=null)
     {
-      if (is_resource($this->_file)) {
-          if ($p_len === null)
-              $p_len = 1;
+      if(is_resource($this->_file)) {
+          if($p_len===null)
+              $p_len=1;
 
-              @fseek($this->_file, @ftell($this->_file)+($p_len*512));
+              @fseek($this->_file, @ftell($this->_file) + ($p_len * 512));
       }
       return true;
     }
 
     private function _readHeader($v_binary_data, &$v_header)
     {
-        if (strlen($v_binary_data)==0) {
-            $v_header['filename'] = '';
+        if(strlen($v_binary_data)==0) {
+            $v_header['filename']='';
             return true;
         }
 
-        if (strlen($v_binary_data) != 512) {
-            $v_header['filename'] = '';
+        if(strlen($v_binary_data)!=512) {
+            $v_header['filename']='';
             $this->_error('Invalid block size : '.strlen($v_binary_data));
             return false;
         }
 
         // ----- Calculate the checksum
-        $v_checksum = 0;
+        $v_checksum=0;
         // ..... First part of the header
-        for ($i=0; $i<148; $i++)
-            $v_checksum+=ord(substr($v_binary_data,$i,1));
+        for($i=0; $i < 148; $i++)
+            $v_checksum+=ord(substr($v_binary_data, $i, 1));
         // ..... Ignore the checksum value and replace it by ' ' (space)
-        for ($i=148; $i<156; $i++)
-            $v_checksum += ord(' ');
+        for($i=148; $i < 156; $i++)
+            $v_checksum+=ord(' ');
         // ..... Last part of the header
-        for ($i=156; $i<512; $i++)
-           $v_checksum+=ord(substr($v_binary_data,$i,1));
+        for($i=156; $i < 512; $i++)
+           $v_checksum+=ord(substr($v_binary_data, $i, 1));
 
-        $v_data = unpack("a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/"
+        $v_data=unpack("a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/"
 		                 ."a8checksum/a1typeflag/a100link/a6magic/a2version/"
 						 ."a32uname/a32gname/a8devmajor/a8devminor",
 						 $v_binary_data);
 
         // ----- Extract the checksum
-        $v_header['checksum'] = OctDec(trim($v_data['checksum']));
-        if ($v_header['checksum'] != $v_checksum) {
-            $v_header['filename'] = '';
+        $v_header['checksum']=OctDec(trim($v_data['checksum']));
+        if($v_header['checksum']!=$v_checksum) {
+            $v_header['filename']='';
 
             // ----- Look for last block (empty block)
-            if (($v_checksum == 256) && ($v_header['checksum'] == 0))
+            if(($v_checksum==256) && ($v_header['checksum']==0))
                 return true;
 
             $this->_error('Invalid checksum for file "'.$v_data['filename']
@@ -281,38 +281,38 @@ 
         }
 
         // ----- Extract the properties
-        $v_header['filename'] = trim($v_data['filename']);
-        $v_header['mode'] = OctDec(trim($v_data['mode']));
-        $v_header['uid'] = OctDec(trim($v_data['uid']));
-        $v_header['gid'] = OctDec(trim($v_data['gid']));
-        $v_header['size'] = OctDec(trim($v_data['size']));
-        $v_header['mtime'] = OctDec(trim($v_data['mtime']));
-        if (($v_header['typeflag'] = $v_data['typeflag']) == "5") {
-          $v_header['size'] = 0;
+        $v_header['filename']=trim($v_data['filename']);
+        $v_header['mode']=OctDec(trim($v_data['mode']));
+        $v_header['uid']=OctDec(trim($v_data['uid']));
+        $v_header['gid']=OctDec(trim($v_data['gid']));
+        $v_header['size']=OctDec(trim($v_data['size']));
+        $v_header['mtime']=OctDec(trim($v_data['mtime']));
+        if(($v_header['typeflag']=$v_data['typeflag'])=="5") {
+          $v_header['size']=0;
         }
         return true;
     }
 
     private function _readLongHeader(&$v_header)
     {
-      $v_filename = '';
-      $n = floor($v_header['size']/512);
-      for ($i=0; $i<$n; $i++) {
-        $v_content = $this->_readBlock();
-        $v_filename .= $v_content;
+      $v_filename='';
+      $n=floor($v_header['size'] / 512);
+      for($i=0; $i < $n; $i++) {
+        $v_content=$this->_readBlock();
+        $v_filename.=$v_content;
       }
-      if (($v_header['size'] % 512) != 0) {
-        $v_content = $this->_readBlock();
-        $v_filename .= $v_content;
+      if(($v_header['size'] % 512)!=0) {
+        $v_content=$this->_readBlock();
+        $v_filename.=$v_content;
       }
 
       // ----- Read the next header
-      $v_binary_data = $this->_readBlock();
+      $v_binary_data=$this->_readBlock();
 
-      if (!$this->_readHeader($v_binary_data, $v_header))
+      if(!$this->_readHeader($v_binary_data, $v_header))
         return false;
 
-      $v_header['filename'] = $v_filename;
+      $v_header['filename']=$v_filename;
 
       return true;
     }
@@ -321,34 +321,34 @@ 
 	                      $p_file_list, $p_remove_path)
     {
     $v_result=true;
-    $v_nb = 0;
-    $v_extract_all = true;
-    $v_listing = false;
-
-    $p_path = $this->_translateWinPath($p_path, false);
-    if ($p_path == '' || (substr($p_path, 0, 1) != '/'
-	    && substr($p_path, 0, 3) != "../" && !strpos($p_path, ':'))) {
-      $p_path = "./".$p_path;
+    $v_nb=0;
+    $v_extract_all=true;
+    $v_listing=false;
+
+    $p_path=$this->_translateWinPath($p_path, false);
+    if($p_path=='' || (substr($p_path, 0, 1)!='/'
+	    && substr($p_path, 0, 3)!="../" && !strpos($p_path, ':'))) {
+      $p_path="./".$p_path;
     }
-    $p_remove_path = $this->_translateWinPath($p_remove_path);
+    $p_remove_path=$this->_translateWinPath($p_remove_path);
 
     // ----- Look for path to remove format (should end by /)
-    if (($p_remove_path != '') && (substr($p_remove_path, -1) != '/'))
-      $p_remove_path .= '/';
-    $p_remove_path_size = strlen($p_remove_path);
+    if(($p_remove_path!='') && (substr($p_remove_path, -1)!='/'))
+      $p_remove_path.='/';
+    $p_remove_path_size=strlen($p_remove_path);
 
-    switch ($p_mode) {
+    switch($p_mode) {
       case "complete" :
-        $v_extract_all = true;
-        $v_listing = false;
+        $v_extract_all=true;
+        $v_listing=false;
       break;
       case "partial" :
-          $v_extract_all = false;
-          $v_listing = false;
+          $v_extract_all=false;
+          $v_listing=false;
       break;
       case "list" :
-          $v_extract_all = false;
-          $v_listing = true;
+          $v_extract_all=false;
+          $v_listing=true;
       break;
       default :
         $this->_error('Invalid extract mode ('.$p_mode.')');
@@ -357,103 +357,103 @@ 
 
     clearstatcache();
 
-    while (strlen($v_binary_data = $this->_readBlock()) != 0)
+    while(strlen($v_binary_data=$this->_readBlock())!=0)
     {
-      $v_extract_file = false;
-      $v_extraction_stopped = 0;
+      $v_extract_file=false;
+      $v_extraction_stopped=0;
 
-      if (!$this->_readHeader($v_binary_data, $v_header))
+      if(!$this->_readHeader($v_binary_data, $v_header))
         return false;
 
-      if ($v_header['filename'] == '') {
+      if($v_header['filename']=='') {
         continue;
       }
 
       // ----- Look for long filename
-      if ($v_header['typeflag'] == 'L') {
-        if (!$this->_readLongHeader($v_header))
+      if($v_header['typeflag']=='L') {
+        if(!$this->_readLongHeader($v_header))
           return false;
       }
 
-      if ((!$v_extract_all) && (is_array($p_file_list))) {
+      if((!$v_extract_all) && (is_array($p_file_list))) {
         // ----- By default no unzip if the file is not found
-        $v_extract_file = false;
+        $v_extract_file=false;
 
-        for ($i=0; $i<sizeof($p_file_list); $i++) {
+        for($i=0; $i < sizeof($p_file_list); $i++) {
           // ----- Look if it is a directory
-          if (substr($p_file_list[$i], -1) == '/') {
+          if(substr($p_file_list[$i], -1)=='/') {
             // ----- Look if the directory is in the filename path
-            if ((strlen($v_header['filename']) > strlen($p_file_list[$i]))
+            if((strlen($v_header['filename']) > strlen($p_file_list[$i]))
 			    && (substr($v_header['filename'], 0, strlen($p_file_list[$i]))
 				    == $p_file_list[$i])) {
-              $v_extract_file = true;
+              $v_extract_file=true;
               break;
             }
           }
 
           // ----- It is a file, so compare the file names
-          elseif ($p_file_list[$i] == $v_header['filename']) {
-            $v_extract_file = true;
+          elseif($p_file_list[$i]==$v_header['filename']) {
+            $v_extract_file=true;
             break;
           }
         }
       } else {
-        $v_extract_file = true;
+        $v_extract_file=true;
       }
 
       // ----- Look if this file need to be extracted
-      if (($v_extract_file) && (!$v_listing))
+      if(($v_extract_file) && (!$v_listing))
       {
-        if (($p_remove_path != '')
+        if(($p_remove_path!='')
             && (substr($v_header['filename'], 0, $p_remove_path_size)
 			    == $p_remove_path))
-          $v_header['filename'] = substr($v_header['filename'],
+          $v_header['filename']=substr($v_header['filename'],
 		                                 $p_remove_path_size);
-        if (($p_path != './') && ($p_path != '/')) {
-          while (substr($p_path, -1) == '/')
-            $p_path = substr($p_path, 0, strlen($p_path)-1);
+        if(($p_path!='./') && ($p_path!='/')) {
+          while(substr($p_path, -1)=='/')
+            $p_path=substr($p_path, 0, strlen($p_path) - 1);
 
-          if (substr($v_header['filename'], 0, 1) == '/')
-              $v_header['filename'] = $p_path.$v_header['filename'];
+          if(substr($v_header['filename'], 0, 1)=='/')
+              $v_header['filename']=$p_path.$v_header['filename'];
           else
-            $v_header['filename'] = $p_path.'/'.$v_header['filename'];
+            $v_header['filename']=$p_path.'/'.$v_header['filename'];
         }
-        if (file_exists($v_header['filename'])) {
-          if (   (@is_dir($v_header['filename']))
-		      && ($v_header['typeflag'] == '')) {
+        if(file_exists($v_header['filename'])) {
+          if((@is_dir($v_header['filename']))
+		      && ($v_header['typeflag']=='')) {
             $this->_error('File '.$v_header['filename']
 			              .' already exists as a directory');
             return false;
           }
-          if (   ($this->_isArchive($v_header['filename']))
-		      && ($v_header['typeflag'] == "5")) {
+          if(($this->_isArchive($v_header['filename']))
+		      && ($v_header['typeflag']=="5")) {
             $this->_error('Directory '.$v_header['filename']
 			              .' already exists as a file');
             return false;
           }
-          if (!is_writeable($v_header['filename'])) {
+          if(!is_writeable($v_header['filename'])) {
             $this->_error('File '.$v_header['filename']
 			              .' already exists and is write protected');
             return false;
           }
-          if (filemtime($v_header['filename']) > $v_header['mtime']) {
+          if(filemtime($v_header['filename']) > $v_header['mtime']) {
             // To be completed : An error or silent no replace ?
           }
         }
 
         // ----- Check the directory availability and create it if necessary
-        elseif (($v_result
-		         = $this->_dirCheck(($v_header['typeflag'] == "5"
-				                    ?$v_header['filename']
-									:dirname($v_header['filename'])))) != 1) {
+        elseif(($v_result
+		         = $this->_dirCheck(($v_header['typeflag']=="5"
+				                    ? $v_header['filename']
+									:dirname($v_header['filename']))))!=1) {
             $this->_error('Unable to create path for '.$v_header['filename']);
             return false;
         }
 
-        if ($v_extract_file) {
-          if ($v_header['typeflag'] == "5") {
-            if (!@file_exists($v_header['filename'])) {
-                if (!@mkdir($v_header['filename'], PRADO_CHMOD)) {
+        if($v_extract_file) {
+          if($v_header['typeflag']=="5") {
+            if(!@file_exists($v_header['filename'])) {
+                if(!@mkdir($v_header['filename'], PRADO_CHMOD)) {
                     $this->_error('Unable to create directory {'
 					              .$v_header['filename'].'}');
                     return false;
@@ -461,18 +461,18 @@ 
                 chmod($v_header['filename'], PRADO_CHMOD);
             }
           } else {
-              if (($v_dest_file = @fopen($v_header['filename'], "wb")) == 0) {
+              if(($v_dest_file=@fopen($v_header['filename'], "wb"))==0) {
                   $this->_error('Error while opening {'.$v_header['filename']
 				                .'} in write binary mode');
                   return false;
               } else {
-                  $n = floor($v_header['size']/512);
-                  for ($i=0; $i<$n; $i++) {
-                      $v_content = $this->_readBlock();
+                  $n=floor($v_header['size'] / 512);
+                  for($i=0; $i < $n; $i++) {
+                      $v_content=$this->_readBlock();
                       fwrite($v_dest_file, $v_content, 512);
                   }
-            if (($v_header['size'] % 512) != 0) {
-              $v_content = $this->_readBlock();
+            if(($v_header['size'] % 512)!=0) {
+              $v_content=$this->_readBlock();
               fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));
             }
 
@@ -486,7 +486,7 @@ 
 
           // ----- Check the file size
           clearstatcache();
-          if (filesize($v_header['filename']) != $v_header['size']) {
+          if(filesize($v_header['filename'])!=$v_header['size']) {
               $this->_error('Extracted file '.$v_header['filename']
 			                .' does not have the correct file size \''
 							.filesize($v_header['filename'])
@@ -496,10 +496,10 @@ 
           }
           }
         } else {
-          $this->_jumpBlock(ceil(($v_header['size']/512)));
+          $this->_jumpBlock(ceil(($v_header['size'] / 512)));
         }
       } else {
-          $this->_jumpBlock(ceil(($v_header['size']/512)));
+          $this->_jumpBlock(ceil(($v_header['size'] / 512)));
       }
 
       /* TBC : Seems to be unused ...
@@ -509,15 +509,15 @@ 
         $v_end_of_file = @feof($this->_file);
         */
 
-      if ($v_listing || $v_extract_file || $v_extraction_stopped) {
+      if($v_listing || $v_extract_file || $v_extraction_stopped) {
         // ----- Log extracted files
-        if (($v_file_dir = dirname($v_header['filename']))
+        if(($v_file_dir=dirname($v_header['filename']))
 		    == $v_header['filename'])
-          $v_file_dir = '';
-        if ((substr($v_header['filename'], 0, 1) == '/') && ($v_file_dir == ''))
-          $v_file_dir = '/';
+          $v_file_dir='';
+        if((substr($v_header['filename'], 0, 1)=='/') && ($v_file_dir==''))
+          $v_file_dir='/';
 
-        $p_list_detail[$v_nb++] = $v_header;
+        $p_list_detail[$v_nb++]=$v_header;
       }
     }
 
@@ -534,36 +534,36 @@ 
      */
     protected function _dirCheck($p_dir)
     {
-        if ((@is_dir($p_dir)) || ($p_dir == ''))
+        if((@is_dir($p_dir)) || ($p_dir==''))
             return true;
 
-        $p_parent_dir = dirname($p_dir);
+        $p_parent_dir=dirname($p_dir);
 
-        if (($p_parent_dir != $p_dir) &&
-            ($p_parent_dir != '') &&
+        if(($p_parent_dir!=$p_dir) &&
+            ($p_parent_dir!='') &&
             (!$this->_dirCheck($p_parent_dir)))
              return false;
 
-        if (!@mkdir($p_dir, PRADO_CHMOD)) {
+        if(!@mkdir($p_dir, PRADO_CHMOD)) {
             $this->_error("Unable to create directory '$p_dir'");
             return false;
         }
-        chmod($p_dir,PRADO_CHMOD);
+        chmod($p_dir, PRADO_CHMOD);
 
         return true;
     }
 
     protected function _translateWinPath($p_path, $p_remove_disk_letter=true)
     {
-      if (substr(PHP_OS, 0, 3) == 'WIN') {
+      if(substr(PHP_OS, 0, 3)=='WIN') {
           // ----- Look for potential disk letter
-          if (   ($p_remove_disk_letter)
-		      && (($v_position = strpos($p_path, ':')) != false)) {
-              $p_path = substr($p_path, $v_position+1);
+          if(($p_remove_disk_letter)
+		      && (($v_position=strpos($p_path, ':'))!=false)) {
+              $p_path=substr($p_path, $v_position + 1);
           }
           // ----- Change potential windows directory separator
-          if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0,1) == '\\')) {
-              $p_path = strtr($p_path, '\\', '/');
+          if((strpos($p_path, '\\') > 0) || (substr($p_path, 0, 1)=='\\')) {
+              $p_path=strtr($p_path, '\\', '/');
           }
       }
       return $p_path;

Braces +6 added lines, -4 removed lines

@@ -155,8 +155,9 @@ 
                 $this->_temp_tarname = '';
                 return false;
               }
-              while ($v_data = @fread($v_file_from, 1024))
-                  @fwrite($v_file_to, $v_data);
+              while ($v_data = @fread($v_file_from, 1024)) {
+                                @fwrite($v_file_to, $v_data);
+              }
               @fclose($v_file_from);
               @fclose($v_file_to);
           }
@@ -410,8 +411,9 @@ 
           $v_header['filename'] = substr($v_header['filename'],
 		                                 $p_remove_path_size);
         if (($p_path != './') && ($p_path != '/')) {
-          while (substr($p_path, -1) == '/')
-            $p_path = substr($p_path, 0, strlen($p_path)-1);
+          while (substr($p_path, -1) == '/') {
+                      $p_path = substr($p_path, 0, strlen($p_path)-1);
+          }
 
           if (substr($v_header['filename'], 0, 1) == '/')
               $v_header['filename'] = $p_path.$v_header['filename'];

Indentation +510 added lines, -510 removed lines

@@ -37,537 +37,537 @@
  */
 class TTarFileExtractor
 {
-    /**
-    * @var string Name of the Tar
-    */
-    private $_tarname='';
-
-    /**
-    * @var file descriptor
-    */
-    private $_file=0;
-
-    /**
-    * @var string Local Tar name of a remote Tar (http:// or ftp://)
-    */
-    private $_temp_tarname='';
-
-    /**
-    * Archive_Tar Class constructor. This flavour of the constructor only
-    * declare a new Archive_Tar object, identifying it by the name of the
-    * tar file.
-    *
-    * @param    string  $p_tarname  The name of the tar archive to create
-    * @access public
-    */
-    public function __construct($p_tarname)
-    {
-        $this->_tarname = $p_tarname;
-    }
-
-    public function __destruct()
-    {
-        $this->_close();
-        // ----- Look for a local copy to delete
-        if ($this->_temp_tarname != '')
-            @unlink($this->_temp_tarname);
-    }
-
-    public function extract($p_path='')
-    {
-        return $this->extractModify($p_path, '');
-    }
-
-    /**
-    * This method extract all the content of the archive in the directory
-    * indicated by $p_path. When relevant the memorized path of the
-    * files/dir can be modified by removing the $p_remove_path path at the
-    * beginning of the file/dir path.
-    * While extracting a file, if the directory path does not exists it is
-    * created.
-    * While extracting a file, if the file already exists it is replaced
-    * without looking for last modification date.
-    * While extracting a file, if the file already exists and is write
-    * protected, the extraction is aborted.
-    * While extracting a file, if a directory with the same name already
-    * exists, the extraction is aborted.
-    * While extracting a directory, if a file with the same name already
-    * exists, the extraction is aborted.
-    * While extracting a file/directory if the destination directory exist
-    * and is write protected, or does not exist but can not be created,
-    * the extraction is aborted.
-    * If after extraction an extracted file does not show the correct
-    * stored file size, the extraction is aborted.
-    * When the extraction is aborted, a PEAR error text is set and false
-    * is returned. However the result can be a partial extraction that may
-    * need to be manually cleaned.
-    *
-    * @param string $p_path         The path of the directory where the
-	*                               files/dir need to by extracted.
-    * @param string $p_remove_path  Part of the memorized path that can be
-	*                               removed if present at the beginning of
-	*                               the file/dir path.
-    * @return boolean               true on success, false on error.
-    * @access public
-    */
-    protected function extractModify($p_path, $p_remove_path)
-    {
-        $v_result = true;
-        $v_list_detail = array();
-
-        if ($v_result = $this->_openRead()) {
-            $v_result = $this->_extractList($p_path, $v_list_detail,
-			                                "complete", 0, $p_remove_path);
-            $this->_close();
-        }
-
-        return $v_result;
-    }
-
-    protected function _error($p_message)
-    {
+	/**
+	 * @var string Name of the Tar
+	 */
+	private $_tarname='';
+
+	/**
+	 * @var file descriptor
+	 */
+	private $_file=0;
+
+	/**
+	 * @var string Local Tar name of a remote Tar (http:// or ftp://)
+	 */
+	private $_temp_tarname='';
+
+	/**
+	 * Archive_Tar Class constructor. This flavour of the constructor only
+	 * declare a new Archive_Tar object, identifying it by the name of the
+	 * tar file.
+	 *
+	 * @param    string  $p_tarname  The name of the tar archive to create
+	 * @access public
+	 */
+	public function __construct($p_tarname)
+	{
+		$this->_tarname = $p_tarname;
+	}
+
+	public function __destruct()
+	{
+		$this->_close();
+		// ----- Look for a local copy to delete
+		if ($this->_temp_tarname != '')
+			@unlink($this->_temp_tarname);
+	}
+
+	public function extract($p_path='')
+	{
+		return $this->extractModify($p_path, '');
+	}
+
+	/**
+	 * This method extract all the content of the archive in the directory
+	 * indicated by $p_path. When relevant the memorized path of the
+	 * files/dir can be modified by removing the $p_remove_path path at the
+	 * beginning of the file/dir path.
+	 * While extracting a file, if the directory path does not exists it is
+	 * created.
+	 * While extracting a file, if the file already exists it is replaced
+	 * without looking for last modification date.
+	 * While extracting a file, if the file already exists and is write
+	 * protected, the extraction is aborted.
+	 * While extracting a file, if a directory with the same name already
+	 * exists, the extraction is aborted.
+	 * While extracting a directory, if a file with the same name already
+	 * exists, the extraction is aborted.
+	 * While extracting a file/directory if the destination directory exist
+	 * and is write protected, or does not exist but can not be created,
+	 * the extraction is aborted.
+	 * If after extraction an extracted file does not show the correct
+	 * stored file size, the extraction is aborted.
+	 * When the extraction is aborted, a PEAR error text is set and false
+	 * is returned. However the result can be a partial extraction that may
+	 * need to be manually cleaned.
+	 *
+	 * @param string $p_path         The path of the directory where the
+	 *                               files/dir need to by extracted.
+	 * @param string $p_remove_path  Part of the memorized path that can be
+	 *                               removed if present at the beginning of
+	 *                               the file/dir path.
+	 * @return boolean               true on success, false on error.
+	 * @access public
+	 */
+	protected function extractModify($p_path, $p_remove_path)
+	{
+		$v_result = true;
+		$v_list_detail = array();
+
+		if ($v_result = $this->_openRead()) {
+			$v_result = $this->_extractList($p_path, $v_list_detail,
+											"complete", 0, $p_remove_path);
+			$this->_close();
+		}
+
+		return $v_result;
+	}
+
+	protected function _error($p_message)
+	{
 		throw new \Exception($p_message);
-    }
-
-    private function _isArchive($p_filename=null)
-    {
-        if ($p_filename == null) {
-            $p_filename = $this->_tarname;
-        }
-        clearstatcache();
-        return @is_file($p_filename);
-    }
-
-    private function _openRead()
-    {
-        if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {
-
-          // ----- Look if a local copy need to be done
-          if ($this->_temp_tarname == '') {
-              $this->_temp_tarname = uniqid('tar').'.tmp';
-              if (!$v_file_from = @fopen($this->_tarname, 'rb')) {
-                $this->_error('Unable to open in read mode \''
-				              .$this->_tarname.'\'');
-                $this->_temp_tarname = '';
-                return false;
-              }
-              if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {
-                $this->_error('Unable to open in write mode \''
-				              .$this->_temp_tarname.'\'');
-                $this->_temp_tarname = '';
-                return false;
-              }
-              while ($v_data = @fread($v_file_from, 1024))
-                  @fwrite($v_file_to, $v_data);
-              @fclose($v_file_from);
-              @fclose($v_file_to);
-          }
-
-          // ----- File to open if the local copy
-          $v_filename = $this->_temp_tarname;
-
-        } else
-          // ----- File to open if the normal Tar file
-          $v_filename = $this->_tarname;
+	}
+
+	private function _isArchive($p_filename=null)
+	{
+		if ($p_filename == null) {
+			$p_filename = $this->_tarname;
+		}
+		clearstatcache();
+		return @is_file($p_filename);
+	}
+
+	private function _openRead()
+	{
+		if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {
+
+		  // ----- Look if a local copy need to be done
+		  if ($this->_temp_tarname == '') {
+			  $this->_temp_tarname = uniqid('tar').'.tmp';
+			  if (!$v_file_from = @fopen($this->_tarname, 'rb')) {
+				$this->_error('Unable to open in read mode \''
+							  .$this->_tarname.'\'');
+				$this->_temp_tarname = '';
+				return false;
+			  }
+			  if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {
+				$this->_error('Unable to open in write mode \''
+							  .$this->_temp_tarname.'\'');
+				$this->_temp_tarname = '';
+				return false;
+			  }
+			  while ($v_data = @fread($v_file_from, 1024))
+				  @fwrite($v_file_to, $v_data);
+			  @fclose($v_file_from);
+			  @fclose($v_file_to);
+		  }
+
+		  // ----- File to open if the local copy
+		  $v_filename = $this->_temp_tarname;
+
+		} else
+		  // ----- File to open if the normal Tar file
+		  $v_filename = $this->_tarname;
 
 		$this->_file = @fopen($v_filename, "rb");
 
-        if ($this->_file == 0) {
-            $this->_error('Unable to open in read mode \''.$v_filename.'\'');
-            return false;
-        }
+		if ($this->_file == 0) {
+			$this->_error('Unable to open in read mode \''.$v_filename.'\'');
+			return false;
+		}
 
-        return true;
-    }
+		return true;
+	}
 
-    private function _close()
-    {
-        //if (isset($this->_file)) {
-        if (is_resource($this->_file))
+	private function _close()
+	{
+		//if (isset($this->_file)) {
+		if (is_resource($this->_file))
 		{
-               @fclose($this->_file);
-            $this->_file = 0;
-        }
-
-        // ----- Look if a local copy need to be erase
-        // Note that it might be interesting to keep the url for a time : ToDo
-        if ($this->_temp_tarname != '') {
-            @unlink($this->_temp_tarname);
-            $this->_temp_tarname = '';
-        }
-
-        return true;
-    }
-
-    private function _cleanFile()
-    {
-        $this->_close();
-
-        // ----- Look for a local copy
-        if ($this->_temp_tarname != '') {
-            // ----- Remove the local copy but not the remote tarname
-            @unlink($this->_temp_tarname);
-            $this->_temp_tarname = '';
-        } else {
-            // ----- Remove the local tarname file
-            @unlink($this->_tarname);
-        }
-        $this->_tarname = '';
-
-        return true;
-    }
-
-    private function _readBlock()
-    {
-      $v_block = null;
-      if (is_resource($this->_file)) {
-              $v_block = @fread($this->_file, 512);
-      }
-      return $v_block;
-    }
-
-    private function _jumpBlock($p_len=null)
-    {
-      if (is_resource($this->_file)) {
-          if ($p_len === null)
-              $p_len = 1;
-
-              @fseek($this->_file, @ftell($this->_file)+($p_len*512));
-      }
-      return true;
-    }
-
-    private function _readHeader($v_binary_data, &$v_header)
-    {
-        if (strlen($v_binary_data)==0) {
-            $v_header['filename'] = '';
-            return true;
-        }
-
-        if (strlen($v_binary_data) != 512) {
-            $v_header['filename'] = '';
-            $this->_error('Invalid block size : '.strlen($v_binary_data));
-            return false;
-        }
-
-        // ----- Calculate the checksum
-        $v_checksum = 0;
-        // ..... First part of the header
-        for ($i=0; $i<148; $i++)
-            $v_checksum+=ord(substr($v_binary_data,$i,1));
-        // ..... Ignore the checksum value and replace it by ' ' (space)
-        for ($i=148; $i<156; $i++)
-            $v_checksum += ord(' ');
-        // ..... Last part of the header
-        for ($i=156; $i<512; $i++)
-           $v_checksum+=ord(substr($v_binary_data,$i,1));
-
-        $v_data = unpack("a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/"
-		                 ."a8checksum/a1typeflag/a100link/a6magic/a2version/"
+			   @fclose($this->_file);
+			$this->_file = 0;
+		}
+
+		// ----- Look if a local copy need to be erase
+		// Note that it might be interesting to keep the url for a time : ToDo
+		if ($this->_temp_tarname != '') {
+			@unlink($this->_temp_tarname);
+			$this->_temp_tarname = '';
+		}
+
+		return true;
+	}
+
+	private function _cleanFile()
+	{
+		$this->_close();
+
+		// ----- Look for a local copy
+		if ($this->_temp_tarname != '') {
+			// ----- Remove the local copy but not the remote tarname
+			@unlink($this->_temp_tarname);
+			$this->_temp_tarname = '';
+		} else {
+			// ----- Remove the local tarname file
+			@unlink($this->_tarname);
+		}
+		$this->_tarname = '';
+
+		return true;
+	}
+
+	private function _readBlock()
+	{
+	  $v_block = null;
+	  if (is_resource($this->_file)) {
+			  $v_block = @fread($this->_file, 512);
+	  }
+	  return $v_block;
+	}
+
+	private function _jumpBlock($p_len=null)
+	{
+	  if (is_resource($this->_file)) {
+		  if ($p_len === null)
+			  $p_len = 1;
+
+			  @fseek($this->_file, @ftell($this->_file)+($p_len*512));
+	  }
+	  return true;
+	}
+
+	private function _readHeader($v_binary_data, &$v_header)
+	{
+		if (strlen($v_binary_data)==0) {
+			$v_header['filename'] = '';
+			return true;
+		}
+
+		if (strlen($v_binary_data) != 512) {
+			$v_header['filename'] = '';
+			$this->_error('Invalid block size : '.strlen($v_binary_data));
+			return false;
+		}
+
+		// ----- Calculate the checksum
+		$v_checksum = 0;
+		// ..... First part of the header
+		for ($i=0; $i<148; $i++)
+			$v_checksum+=ord(substr($v_binary_data,$i,1));
+		// ..... Ignore the checksum value and replace it by ' ' (space)
+		for ($i=148; $i<156; $i++)
+			$v_checksum += ord(' ');
+		// ..... Last part of the header
+		for ($i=156; $i<512; $i++)
+		   $v_checksum+=ord(substr($v_binary_data,$i,1));
+
+		$v_data = unpack("a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/"
+						 ."a8checksum/a1typeflag/a100link/a6magic/a2version/"
 						 ."a32uname/a32gname/a8devmajor/a8devminor",
 						 $v_binary_data);
 
-        // ----- Extract the checksum
-        $v_header['checksum'] = OctDec(trim($v_data['checksum']));
-        if ($v_header['checksum'] != $v_checksum) {
-            $v_header['filename'] = '';
+		// ----- Extract the checksum
+		$v_header['checksum'] = OctDec(trim($v_data['checksum']));
+		if ($v_header['checksum'] != $v_checksum) {
+			$v_header['filename'] = '';
 
-            // ----- Look for last block (empty block)
-            if (($v_checksum == 256) && ($v_header['checksum'] == 0))
-                return true;
+			// ----- Look for last block (empty block)
+			if (($v_checksum == 256) && ($v_header['checksum'] == 0))
+				return true;
 
-            $this->_error('Invalid checksum for file "'.$v_data['filename']
-			              .'" : '.$v_checksum.' calculated, '
+			$this->_error('Invalid checksum for file "'.$v_data['filename']
+						  .'" : '.$v_checksum.' calculated, '
 						  .$v_header['checksum'].' expected');
-            return false;
-        }
-
-        // ----- Extract the properties
-        $v_header['filename'] = trim($v_data['filename']);
-        $v_header['mode'] = OctDec(trim($v_data['mode']));
-        $v_header['uid'] = OctDec(trim($v_data['uid']));
-        $v_header['gid'] = OctDec(trim($v_data['gid']));
-        $v_header['size'] = OctDec(trim($v_data['size']));
-        $v_header['mtime'] = OctDec(trim($v_data['mtime']));
-        if (($v_header['typeflag'] = $v_data['typeflag']) == "5") {
-          $v_header['size'] = 0;
-        }
-        return true;
-    }
-
-    private function _readLongHeader(&$v_header)
-    {
-      $v_filename = '';
-      $n = floor($v_header['size']/512);
-      for ($i=0; $i<$n; $i++) {
-        $v_content = $this->_readBlock();
-        $v_filename .= $v_content;
-      }
-      if (($v_header['size'] % 512) != 0) {
-        $v_content = $this->_readBlock();
-        $v_filename .= $v_content;
-      }
-
-      // ----- Read the next header
-      $v_binary_data = $this->_readBlock();
-
-      if (!$this->_readHeader($v_binary_data, $v_header))
-        return false;
-
-      $v_header['filename'] = $v_filename;
-
-      return true;
-    }
-
-    protected function _extractList($p_path, &$p_list_detail, $p_mode,
-	                      $p_file_list, $p_remove_path)
-    {
-    $v_result=true;
-    $v_nb = 0;
-    $v_extract_all = true;
-    $v_listing = false;
-
-    $p_path = $this->_translateWinPath($p_path, false);
-    if ($p_path == '' || (substr($p_path, 0, 1) != '/'
-	    && substr($p_path, 0, 3) != "../" && !strpos($p_path, ':'))) {
-      $p_path = "./".$p_path;
-    }
-    $p_remove_path = $this->_translateWinPath($p_remove_path);
-
-    // ----- Look for path to remove format (should end by /)
-    if (($p_remove_path != '') && (substr($p_remove_path, -1) != '/'))
-      $p_remove_path .= '/';
-    $p_remove_path_size = strlen($p_remove_path);
-
-    switch ($p_mode) {
-      case "complete" :
-        $v_extract_all = true;
-        $v_listing = false;
-      break;
-      case "partial" :
-          $v_extract_all = false;
-          $v_listing = false;
-      break;
-      case "list" :
-          $v_extract_all = false;
-          $v_listing = true;
-      break;
-      default :
-        $this->_error('Invalid extract mode ('.$p_mode.')');
-        return false;
-    }
-
-    clearstatcache();
-
-    while (strlen($v_binary_data = $this->_readBlock()) != 0)
-    {
-      $v_extract_file = false;
-      $v_extraction_stopped = 0;
-
-      if (!$this->_readHeader($v_binary_data, $v_header))
-        return false;
-
-      if ($v_header['filename'] == '') {
-        continue;
-      }
-
-      // ----- Look for long filename
-      if ($v_header['typeflag'] == 'L') {
-        if (!$this->_readLongHeader($v_header))
-          return false;
-      }
-
-      if ((!$v_extract_all) && (is_array($p_file_list))) {
-        // ----- By default no unzip if the file is not found
-        $v_extract_file = false;
-
-        for ($i=0; $i<sizeof($p_file_list); $i++) {
-          // ----- Look if it is a directory
-          if (substr($p_file_list[$i], -1) == '/') {
-            // ----- Look if the directory is in the filename path
-            if ((strlen($v_header['filename']) > strlen($p_file_list[$i]))
-			    && (substr($v_header['filename'], 0, strlen($p_file_list[$i]))
-				    == $p_file_list[$i])) {
-              $v_extract_file = true;
-              break;
-            }
-          }
-
-          // ----- It is a file, so compare the file names
-          elseif ($p_file_list[$i] == $v_header['filename']) {
-            $v_extract_file = true;
-            break;
-          }
-        }
-      } else {
-        $v_extract_file = true;
-      }
-
-      // ----- Look if this file need to be extracted
-      if (($v_extract_file) && (!$v_listing))
-      {
-        if (($p_remove_path != '')
-            && (substr($v_header['filename'], 0, $p_remove_path_size)
-			    == $p_remove_path))
-          $v_header['filename'] = substr($v_header['filename'],
-		                                 $p_remove_path_size);
-        if (($p_path != './') && ($p_path != '/')) {
-          while (substr($p_path, -1) == '/')
-            $p_path = substr($p_path, 0, strlen($p_path)-1);
-
-          if (substr($v_header['filename'], 0, 1) == '/')
-              $v_header['filename'] = $p_path.$v_header['filename'];
-          else
-            $v_header['filename'] = $p_path.'/'.$v_header['filename'];
-        }
-        if (file_exists($v_header['filename'])) {
-          if (   (@is_dir($v_header['filename']))
-		      && ($v_header['typeflag'] == '')) {
-            $this->_error('File '.$v_header['filename']
-			              .' already exists as a directory');
-            return false;
-          }
-          if (   ($this->_isArchive($v_header['filename']))
-		      && ($v_header['typeflag'] == "5")) {
-            $this->_error('Directory '.$v_header['filename']
-			              .' already exists as a file');
-            return false;
-          }
-          if (!is_writeable($v_header['filename'])) {
-            $this->_error('File '.$v_header['filename']
-			              .' already exists and is write protected');
-            return false;
-          }
-          if (filemtime($v_header['filename']) > $v_header['mtime']) {
-            // To be completed : An error or silent no replace ?
-          }
-        }
-
-        // ----- Check the directory availability and create it if necessary
-        elseif (($v_result
-		         = $this->_dirCheck(($v_header['typeflag'] == "5"
-				                    ?$v_header['filename']
+			return false;
+		}
+
+		// ----- Extract the properties
+		$v_header['filename'] = trim($v_data['filename']);
+		$v_header['mode'] = OctDec(trim($v_data['mode']));
+		$v_header['uid'] = OctDec(trim($v_data['uid']));
+		$v_header['gid'] = OctDec(trim($v_data['gid']));
+		$v_header['size'] = OctDec(trim($v_data['size']));
+		$v_header['mtime'] = OctDec(trim($v_data['mtime']));
+		if (($v_header['typeflag'] = $v_data['typeflag']) == "5") {
+		  $v_header['size'] = 0;
+		}
+		return true;
+	}
+
+	private function _readLongHeader(&$v_header)
+	{
+	  $v_filename = '';
+	  $n = floor($v_header['size']/512);
+	  for ($i=0; $i<$n; $i++) {
+		$v_content = $this->_readBlock();
+		$v_filename .= $v_content;
+	  }
+	  if (($v_header['size'] % 512) != 0) {
+		$v_content = $this->_readBlock();
+		$v_filename .= $v_content;
+	  }
+
+	  // ----- Read the next header
+	  $v_binary_data = $this->_readBlock();
+
+	  if (!$this->_readHeader($v_binary_data, $v_header))
+		return false;
+
+	  $v_header['filename'] = $v_filename;
+
+	  return true;
+	}
+
+	protected function _extractList($p_path, &$p_list_detail, $p_mode,
+						  $p_file_list, $p_remove_path)
+	{
+	$v_result=true;
+	$v_nb = 0;
+	$v_extract_all = true;
+	$v_listing = false;
+
+	$p_path = $this->_translateWinPath($p_path, false);
+	if ($p_path == '' || (substr($p_path, 0, 1) != '/'
+		&& substr($p_path, 0, 3) != "../" && !strpos($p_path, ':'))) {
+	  $p_path = "./".$p_path;
+	}
+	$p_remove_path = $this->_translateWinPath($p_remove_path);
+
+	// ----- Look for path to remove format (should end by /)
+	if (($p_remove_path != '') && (substr($p_remove_path, -1) != '/'))
+	  $p_remove_path .= '/';
+	$p_remove_path_size = strlen($p_remove_path);
+
+	switch ($p_mode) {
+	  case "complete" :
+		$v_extract_all = true;
+		$v_listing = false;
+	  break;
+	  case "partial" :
+		  $v_extract_all = false;
+		  $v_listing = false;
+	  break;
+	  case "list" :
+		  $v_extract_all = false;
+		  $v_listing = true;
+	  break;
+	  default :
+		$this->_error('Invalid extract mode ('.$p_mode.')');
+		return false;
+	}
+
+	clearstatcache();
+
+	while (strlen($v_binary_data = $this->_readBlock()) != 0)
+	{
+	  $v_extract_file = false;
+	  $v_extraction_stopped = 0;
+
+	  if (!$this->_readHeader($v_binary_data, $v_header))
+		return false;
+
+	  if ($v_header['filename'] == '') {
+		continue;
+	  }
+
+	  // ----- Look for long filename
+	  if ($v_header['typeflag'] == 'L') {
+		if (!$this->_readLongHeader($v_header))
+		  return false;
+	  }
+
+	  if ((!$v_extract_all) && (is_array($p_file_list))) {
+		// ----- By default no unzip if the file is not found
+		$v_extract_file = false;
+
+		for ($i=0; $i<sizeof($p_file_list); $i++) {
+		  // ----- Look if it is a directory
+		  if (substr($p_file_list[$i], -1) == '/') {
+			// ----- Look if the directory is in the filename path
+			if ((strlen($v_header['filename']) > strlen($p_file_list[$i]))
+				&& (substr($v_header['filename'], 0, strlen($p_file_list[$i]))
+					== $p_file_list[$i])) {
+			  $v_extract_file = true;
+			  break;
+			}
+		  }
+
+		  // ----- It is a file, so compare the file names
+		  elseif ($p_file_list[$i] == $v_header['filename']) {
+			$v_extract_file = true;
+			break;
+		  }
+		}
+	  } else {
+		$v_extract_file = true;
+	  }
+
+	  // ----- Look if this file need to be extracted
+	  if (($v_extract_file) && (!$v_listing))
+	  {
+		if (($p_remove_path != '')
+			&& (substr($v_header['filename'], 0, $p_remove_path_size)
+				== $p_remove_path))
+		  $v_header['filename'] = substr($v_header['filename'],
+										 $p_remove_path_size);
+		if (($p_path != './') && ($p_path != '/')) {
+		  while (substr($p_path, -1) == '/')
+			$p_path = substr($p_path, 0, strlen($p_path)-1);
+
+		  if (substr($v_header['filename'], 0, 1) == '/')
+			  $v_header['filename'] = $p_path.$v_header['filename'];
+		  else
+			$v_header['filename'] = $p_path.'/'.$v_header['filename'];
+		}
+		if (file_exists($v_header['filename'])) {
+		  if (   (@is_dir($v_header['filename']))
+			  && ($v_header['typeflag'] == '')) {
+			$this->_error('File '.$v_header['filename']
+						  .' already exists as a directory');
+			return false;
+		  }
+		  if (   ($this->_isArchive($v_header['filename']))
+			  && ($v_header['typeflag'] == "5")) {
+			$this->_error('Directory '.$v_header['filename']
+						  .' already exists as a file');
+			return false;
+		  }
+		  if (!is_writeable($v_header['filename'])) {
+			$this->_error('File '.$v_header['filename']
+						  .' already exists and is write protected');
+			return false;
+		  }
+		  if (filemtime($v_header['filename']) > $v_header['mtime']) {
+			// To be completed : An error or silent no replace ?
+		  }
+		}
+
+		// ----- Check the directory availability and create it if necessary
+		elseif (($v_result
+				 = $this->_dirCheck(($v_header['typeflag'] == "5"
+									?$v_header['filename']
 									:dirname($v_header['filename'])))) != 1) {
-            $this->_error('Unable to create path for '.$v_header['filename']);
-            return false;
-        }
-
-        if ($v_extract_file) {
-          if ($v_header['typeflag'] == "5") {
-            if (!@file_exists($v_header['filename'])) {
-                if (!@mkdir($v_header['filename'], PRADO_CHMOD)) {
-                    $this->_error('Unable to create directory {'
-					              .$v_header['filename'].'}');
-                    return false;
-                }
-                chmod($v_header['filename'], PRADO_CHMOD);
-            }
-          } else {
-              if (($v_dest_file = @fopen($v_header['filename'], "wb")) == 0) {
-                  $this->_error('Error while opening {'.$v_header['filename']
-				                .'} in write binary mode');
-                  return false;
-              } else {
-                  $n = floor($v_header['size']/512);
-                  for ($i=0; $i<$n; $i++) {
-                      $v_content = $this->_readBlock();
-                      fwrite($v_dest_file, $v_content, 512);
-                  }
-            if (($v_header['size'] % 512) != 0) {
-              $v_content = $this->_readBlock();
-              fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));
-            }
-
-            @fclose($v_dest_file);
-
-            // ----- Change the file mode, mtime
-            @touch($v_header['filename'], $v_header['mtime']);
-            // To be completed
-            //chmod($v_header[filename], DecOct($v_header[mode]));
-          }
-
-          // ----- Check the file size
-          clearstatcache();
-          if (filesize($v_header['filename']) != $v_header['size']) {
-              $this->_error('Extracted file '.$v_header['filename']
-			                .' does not have the correct file size \''
+			$this->_error('Unable to create path for '.$v_header['filename']);
+			return false;
+		}
+
+		if ($v_extract_file) {
+		  if ($v_header['typeflag'] == "5") {
+			if (!@file_exists($v_header['filename'])) {
+				if (!@mkdir($v_header['filename'], PRADO_CHMOD)) {
+					$this->_error('Unable to create directory {'
+								  .$v_header['filename'].'}');
+					return false;
+				}
+				chmod($v_header['filename'], PRADO_CHMOD);
+			}
+		  } else {
+			  if (($v_dest_file = @fopen($v_header['filename'], "wb")) == 0) {
+				  $this->_error('Error while opening {'.$v_header['filename']
+								.'} in write binary mode');
+				  return false;
+			  } else {
+				  $n = floor($v_header['size']/512);
+				  for ($i=0; $i<$n; $i++) {
+					  $v_content = $this->_readBlock();
+					  fwrite($v_dest_file, $v_content, 512);
+				  }
+			if (($v_header['size'] % 512) != 0) {
+			  $v_content = $this->_readBlock();
+			  fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));
+			}
+
+			@fclose($v_dest_file);
+
+			// ----- Change the file mode, mtime
+			@touch($v_header['filename'], $v_header['mtime']);
+			// To be completed
+			//chmod($v_header[filename], DecOct($v_header[mode]));
+		  }
+
+		  // ----- Check the file size
+		  clearstatcache();
+		  if (filesize($v_header['filename']) != $v_header['size']) {
+			  $this->_error('Extracted file '.$v_header['filename']
+							.' does not have the correct file size \''
 							.filesize($v_header['filename'])
 							.'\' ('.$v_header['size']
 							.' expected). Archive may be corrupted.');
-              return false;
-          }
-          }
-        } else {
-          $this->_jumpBlock(ceil(($v_header['size']/512)));
-        }
-      } else {
-          $this->_jumpBlock(ceil(($v_header['size']/512)));
-      }
-
-      /* TBC : Seems to be unused ...
+			  return false;
+		  }
+		  }
+		} else {
+		  $this->_jumpBlock(ceil(($v_header['size']/512)));
+		}
+	  } else {
+		  $this->_jumpBlock(ceil(($v_header['size']/512)));
+	  }
+
+	  /* TBC : Seems to be unused ...
       if ($this->_compress)
         $v_end_of_file = @gzeof($this->_file);
       else
         $v_end_of_file = @feof($this->_file);
         */
 
-      if ($v_listing || $v_extract_file || $v_extraction_stopped) {
-        // ----- Log extracted files
-        if (($v_file_dir = dirname($v_header['filename']))
-		    == $v_header['filename'])
-          $v_file_dir = '';
-        if ((substr($v_header['filename'], 0, 1) == '/') && ($v_file_dir == ''))
-          $v_file_dir = '/';
-
-        $p_list_detail[$v_nb++] = $v_header;
-      }
-    }
-
-        return true;
-    }
-
-    /**
-     * Check if a directory exists and create it (including parent
-     * dirs) if not.
-     *
-     * @param string $p_dir directory to check
-     *
-     * @return bool true if the directory exists or was created
-     */
-    protected function _dirCheck($p_dir)
-    {
-        if ((@is_dir($p_dir)) || ($p_dir == ''))
-            return true;
-
-        $p_parent_dir = dirname($p_dir);
-
-        if (($p_parent_dir != $p_dir) &&
-            ($p_parent_dir != '') &&
-            (!$this->_dirCheck($p_parent_dir)))
-             return false;
-
-        if (!@mkdir($p_dir, PRADO_CHMOD)) {
-            $this->_error("Unable to create directory '$p_dir'");
-            return false;
-        }
-        chmod($p_dir,PRADO_CHMOD);
-
-        return true;
-    }
-
-    protected function _translateWinPath($p_path, $p_remove_disk_letter=true)
-    {
-      if (substr(PHP_OS, 0, 3) == 'WIN') {
-          // ----- Look for potential disk letter
-          if (   ($p_remove_disk_letter)
-		      && (($v_position = strpos($p_path, ':')) != false)) {
-              $p_path = substr($p_path, $v_position+1);
-          }
-          // ----- Change potential windows directory separator
-          if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0,1) == '\\')) {
-              $p_path = strtr($p_path, '\\', '/');
-          }
-      }
-      return $p_path;
-    }
+	  if ($v_listing || $v_extract_file || $v_extraction_stopped) {
+		// ----- Log extracted files
+		if (($v_file_dir = dirname($v_header['filename']))
+			== $v_header['filename'])
+		  $v_file_dir = '';
+		if ((substr($v_header['filename'], 0, 1) == '/') && ($v_file_dir == ''))
+		  $v_file_dir = '/';
+
+		$p_list_detail[$v_nb++] = $v_header;
+	  }
+	}
+
+		return true;
+	}
+
+	/**
+	 * Check if a directory exists and create it (including parent
+	 * dirs) if not.
+	 *
+	 * @param string $p_dir directory to check
+	 *
+	 * @return bool true if the directory exists or was created
+	 */
+	protected function _dirCheck($p_dir)
+	{
+		if ((@is_dir($p_dir)) || ($p_dir == ''))
+			return true;
+
+		$p_parent_dir = dirname($p_dir);
+
+		if (($p_parent_dir != $p_dir) &&
+			($p_parent_dir != '') &&
+			(!$this->_dirCheck($p_parent_dir)))
+			 return false;
+
+		if (!@mkdir($p_dir, PRADO_CHMOD)) {
+			$this->_error("Unable to create directory '$p_dir'");
+			return false;
+		}
+		chmod($p_dir,PRADO_CHMOD);
+
+		return true;
+	}
+
+	protected function _translateWinPath($p_path, $p_remove_disk_letter=true)
+	{
+	  if (substr(PHP_OS, 0, 3) == 'WIN') {
+		  // ----- Look for potential disk letter
+		  if (   ($p_remove_disk_letter)
+			  && (($v_position = strpos($p_path, ':')) != false)) {
+			  $p_path = substr($p_path, $v_position+1);
+		  }
+		  // ----- Change potential windows directory separator
+		  if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0,1) == '\\')) {
+			  $p_path = strtr($p_path, '\\', '/');
+		  }
+	  }
+	  return $p_path;
+	}
 }

framework/IO/TTextWriter.php

Doc Comments +1 added lines

@@ -38,6 +38,7 @@
 	/**
 	 * Writes a string.
 	 * @param string string to be written
+	 * @param string $str
 	 */
 	public function write($str)
 	{

framework/TService.php

Doc Comments +1 added lines

@@ -49,6 +49,7 @@
 
 	/**
 	 * @param string id of this service
+	 * @param string $value
 	 */
 	public function setID($value)
 	{

framework/Util/TLogger.php

Doc Comments +1 added lines

@@ -98,6 +98,7 @@
 	 * @param integer level filter
 	 * @param array category filter
 	 * @param array control filter
+	 * @param integer $levels
 	 * @return array list of messages. Each array elements represents one message
 	 * with the following structure:
 	 * array(

Spacing +20 added lines, -20 removed lines

@@ -63,16 +63,16 @@ 
 	 * @param string category of the message
 	 * @param string|TControl control of the message
 	 */
-	public function log($message,$level,$category='Uncategorized', $ctl=null)
+	public function log($message, $level, $category='Uncategorized', $ctl=null)
 	{
 		if($ctl) {
 			if($ctl instanceof TControl)
-				$ctl = $ctl->ClientId;
+				$ctl=$ctl->ClientId;
 			else if(!is_string($ctl))
-				$ctl = null;
+				$ctl=null;
 		} else
-			$ctl = null;
-		$this->_logs[]=array($message,$level,$category,microtime(true),memory_get_usage(),$ctl);
+			$ctl=null;
+		$this->_logs[]=array($message, $level, $category, microtime(true), memory_get_usage(), $ctl);
 	}
 
 	/**
@@ -108,7 +108,7 @@ 
 	 *   [4] => memory in bytes
 	 *   [5] => control client id
 	 */
-	public function getLogs($levels=null,$categories=null,$controls=null,$timestamp=null)
+	public function getLogs($levels=null, $categories=null, $controls=null, $timestamp=null)
 	{
 		$this->_levels=$levels;
 		$this->_categories=$categories;
@@ -116,15 +116,15 @@ 
 		$this->_timestamp=$timestamp;
 		if(empty($levels) && empty($categories) && empty($controls) && is_null($timestamp))
 			return $this->_logs;
-		$logs = $this->_logs;
+		$logs=$this->_logs;
 		if(!empty($levels))
-			$logs = array_values(array_filter( array_filter($logs,array($this,'filterByLevels')) ));
+			$logs=array_values(array_filter(array_filter($logs, array($this, 'filterByLevels'))));
 		if(!empty($categories))
-			$logs = array_values(array_filter( array_filter($logs,array($this,'filterByCategories')) ));
+			$logs=array_values(array_filter(array_filter($logs, array($this, 'filterByCategories'))));
 		if(!empty($controls))
-			$logs = array_values(array_filter( array_filter($logs,array($this,'filterByControl')) ));
+			$logs=array_values(array_filter(array_filter($logs, array($this, 'filterByControl'))));
 		if(!is_null($timestamp))
-			$logs = array_values(array_filter( array_filter($logs,array($this,'filterByTimeStamp')) ));
+			$logs=array_values(array_filter(array_filter($logs, array($this, 'filterByTimeStamp'))));
 		return $logs;
 	}
 
@@ -152,7 +152,7 @@ 
 	 * @param array category filter
 	 * @param array control filter
 	 */
-	public function deleteLogs($levels=null,$categories=null,$controls=null,$timestamp=null)
+	public function deleteLogs($levels=null, $categories=null, $controls=null, $timestamp=null)
 	{
 		$this->_levels=$levels;
 		$this->_categories=$categories;
@@ -163,16 +163,16 @@ 
 			$this->_logs=array();
 			return;
 		}
-		$logs = $this->_logs;
+		$logs=$this->_logs;
 		if(!empty($levels))
-			$logs = array_filter( array_filter($logs,array($this,'filterByLevels')) );
+			$logs=array_filter(array_filter($logs, array($this, 'filterByLevels')));
 		if(!empty($categories))
-			$logs = array_filter( array_filter($logs,array($this,'filterByCategories')) );
+			$logs=array_filter(array_filter($logs, array($this, 'filterByCategories')));
 		if(!empty($controls))
-			$logs = array_filter( array_filter($logs,array($this,'filterByControl')) );
+			$logs=array_filter(array_filter($logs, array($this, 'filterByControl')));
 		if(!is_null($timestamp))
-			$logs = array_filter( array_filter($logs,array($this,'filterByTimeStamp')) );
-		$this->_logs = array_values( array_diff_key($this->_logs, $logs) );
+			$logs=array_filter(array_filter($logs, array($this, 'filterByTimeStamp')));
+		$this->_logs=array_values(array_diff_key($this->_logs, $logs));
 	}
 
 	/**
@@ -184,7 +184,7 @@ 
 		foreach($this->_categories as $category)
 		{
 			// element 2 is the category
-			if($value[2]===$category || strpos($value[2],$category.'.')===0)
+			if($value[2]===$category || strpos($value[2], $category.'.')===0)
 				return $value;
 		}
 		return false;
@@ -212,7 +212,7 @@ 
 		// element 5 are the control client ids
 		foreach($this->_controls as $control)
 		{
-			if($value[5]===$control || strpos($value[5],$control)===0)
+			if($value[5]===$control || strpos($value[5], $control)===0)
 				return $value;
 		}
 		return false;

framework/Util/TRpcClient.php

Doc Comments +3 added lines

@@ -105,6 +105,9 @@
 	 * @param string RPC server URL
 	 * @param array payload data
 	 * @param string request mime type
+	 * @param string $serverUrl
+	 * @param string $mimeType
+	 * @return string
 	 */
 	protected function performRequest($serverUrl, $payload, $mimeType)
 	{

Spacing +9 added lines, -9 removed lines

@@ -57,7 +57,7 @@ 
 	/**
 	 * @var boolean whether the request is a notification and therefore should not care about the result (default: false)
 	 */
-	private $_isNotification = false;
+	private $_isNotification=false;
 
 	// magics
 
@@ -65,10 +65,10 @@ 
 	 * @param string url to RPC server
 	 * @param boolean whether requests are considered to be notifications (completely ignoring the response) (default: false)
 	 */
-	public function __construct($serverUrl, $isNotification = false)
+	public function __construct($serverUrl, $isNotification=false)
 	{
-		$this->_serverUrl = $serverUrl;
-		$this->_isNotification = TPropertyValue::ensureBoolean($isNotification);
+		$this->_serverUrl=$serverUrl;
+		$this->_isNotification=TPropertyValue::ensureBoolean($isNotification);
 	}
 
 	// methods
@@ -78,9 +78,9 @@ 
 	 * @return TRpcClient instance
 	 * @throws TApplicationException if an unsupported RPC client type was specified
 	 */
-	public static function create($type, $serverUrl, $isNotification = false)
+	public static function create($type, $serverUrl, $isNotification=false)
 	{
-		if(($_handler = constant('TRpcClientTypesEnumerable::'.strtoupper($type))) === null)
+		if(($_handler=constant('TRpcClientTypesEnumerable::'.strtoupper($type)))===null)
 			throw new TApplicationException('rpcclient_unsupported_handler');
 
 		return new $_handler($serverUrl, $isNotification);
@@ -110,7 +110,7 @@ 
 	 */
 	protected function performRequest($serverUrl, $payload, $mimeType)
 	{
-		if(($_response = @file_get_contents($serverUrl, false, $this->createStreamContext($payload, $mimeType))) === false)
+		if(($_response=@file_get_contents($serverUrl, false, $this->createStreamContext($payload, $mimeType)))===false)
 			throw new TRpcClientRequestException('Request failed ("'.$http_response_header[0].'")');
 
 		return $_response;
@@ -131,7 +131,7 @@ 
 	 */
 	public function setIsNotification($bool)
 	{
-		$this->_isNotification = TPropertyValue::ensureBoolean($bool);
+		$this->_isNotification=TPropertyValue::ensureBoolean($bool);
 	}
 
 	/**
@@ -147,6 +147,6 @@ 
 	 */
 	public function setServerUrl($value)
 	{
-		$this->_serverUrl = $value;
+		$this->_serverUrl=$value;
 	}
 }
\ No newline at end of file

framework/Util/TSimpleDateFormatter.php

Doc Comments +10 added lines

@@ -60,6 +60,7 @@ 
 	 * Constructor, create a new date time formatter.
 	 * @param string formatting pattern.
 	 * @param string pattern and value charset
+	 * @param string $pattern
 	 */
 	public function __construct($pattern, $charset='UTF-8')
 	{
@@ -93,6 +94,7 @@ 
 
 	/**
 	 * @param string formatting charset.
+	 * @param string $charset
 	 */
 	public function setCharset($charset)
 	{
@@ -313,6 +315,7 @@ 
 
 	/**
 	 * Calculate the length of a string, may be consider iconv_strlen?
+	 * @param string $string
 	 */
 	private function length($string)
 	{
@@ -338,6 +341,9 @@ 
 
 	/**
 	 * Returns true if char at position equals a particular char.
+	 * @param string $string
+	 * @param integer $pos
+	 * @param string $char
 	 */
 	private function charEqual($string, $pos, $char)
 	{
@@ -350,6 +356,10 @@ 
 	 * @param int starting position
 	 * @param int minimum integer length
 	 * @param int maximum integer length
+	 * @param string $str
+	 * @param integer $i
+	 * @param integer|null $minlength
+	 * @param integer|null $maxlength
 	 * @return string integer portion of the string, null otherwise
 	 */
 	private function getInteger($str,$i,$minlength,$maxlength)

Braces +4 added lines, -8 removed lines

@@ -225,8 +225,7 @@ 
 			$year = "{$date['year']}";
 			$month = $date['mon'];
 			$day = $date['mday'];
-		}
-		else
+		} else
 		{
 			$year = null;
 			$month = null;
@@ -262,8 +261,7 @@ 
 						$year = $iYear + 2000;
 				}
 				$year = (int)$year;
-			}
-			elseif($token=='MM' || $token=='M')
+			} elseif($token=='MM' || $token=='M')
 			{
 				$month=$this->getInteger($value,$i_val,
 									$this->length($token),2);
@@ -273,8 +271,7 @@ 
 					//throw new TInvalidDataValueException('Invalid month', $value);
 				$i_val += strlen($month);
 				$month = $iMonth;
-			}
-			elseif ($token=='dd' || $token=='d')
+			} elseif ($token=='dd' || $token=='d')
 			{
 				$day = $this->getInteger($value,$i_val,
 									$this->length($token), 2);
@@ -284,8 +281,7 @@ 
 					//throw new TInvalidDataValueException('Invalid day', $value);
 				$i_val += strlen($day);
 				$day = $iDay;
-			}
-			else
+			} else
 			{
 				if($this->substring($value, $i_val, $this->length($token)) != $token)
 					return null;

Spacing +76 added lines, -76 removed lines

@@ -60,7 +60,7 @@ 
 	 * Charset, default is 'UTF-8'
 	 * @var string
 	 */
-	private $charset = 'UTF-8';
+	private $charset='UTF-8';
 
 	/**
 	 * Constructor, create a new date time formatter.
@@ -86,7 +86,7 @@ 
 	 */
 	public function setPattern($pattern)
 	{
-		$this->pattern = $pattern;
+		$this->pattern=$pattern;
 	}
 
 	/**
@@ -102,7 +102,7 @@ 
 	 */
 	public function setCharset($charset)
 	{
-		$this->charset = $charset;
+		$this->charset=$charset;
 	}
 
 	/**
@@ -112,17 +112,17 @@ 
 	 */
 	public function format($value)
 	{
-		$date = $this->getDate($value);
-		$bits['yyyy'] = $date['year'];
-		$bits['yy'] = substr("{$date['year']}", -2);
+		$date=$this->getDate($value);
+		$bits['yyyy']=$date['year'];
+		$bits['yy']=substr("{$date['year']}", -2);
 
-		$bits['MM'] = str_pad("{$date['mon']}", 2, '0', STR_PAD_LEFT);
-		$bits['M'] = $date['mon'];
+		$bits['MM']=str_pad("{$date['mon']}", 2, '0', STR_PAD_LEFT);
+		$bits['M']=$date['mon'];
 
-		$bits['dd'] = str_pad("{$date['mday']}", 2, '0', STR_PAD_LEFT);
-		$bits['d'] = $date['mday'];
+		$bits['dd']=str_pad("{$date['mday']}", 2, '0', STR_PAD_LEFT);
+		$bits['d']=$date['mday'];
 
-		$pattern = preg_replace('/M{3,4}/', 'MM', $this->pattern);
+		$pattern=preg_replace('/M{3,4}/', 'MM', $this->pattern);
 		return str_replace(array_keys($bits), $bits, $pattern);
 	}
 
@@ -159,13 +159,13 @@ 
 
 	public function getDayMonthYearOrdering()
 	{
-		$ordering = array();
-		if(is_int($day= strpos($this->pattern, 'd')))
-			$ordering['day'] = $day;
-		if(is_int($month= strpos($this->pattern, 'M')))
-			$ordering['month'] = $month;
-		if(is_int($year= strpos($this->pattern, 'yy')))
-			$ordering['year'] = $year;
+		$ordering=array();
+		if(is_int($day=strpos($this->pattern, 'd')))
+			$ordering['day']=$day;
+		if(is_int($month=strpos($this->pattern, 'M')))
+			$ordering['month']=$month;
+		if(is_int($year=strpos($this->pattern, 'yy')))
+			$ordering['year']=$year;
 		asort($ordering);
 		return array_keys($ordering);
 	}
@@ -177,7 +177,7 @@ 
 	 */
 	private function getDate($value)
 	{
-		$s = new TDateTimeStamp;
+		$s=new TDateTimeStamp;
 		if(is_numeric($value))
 			return $s->getDate($value);
 		else
@@ -189,10 +189,10 @@ 
 	 */
 	public function isValidDate($value)
 	{
-		if($value === null) {
+		if($value===null) {
 			return false;
 		} else {
-			return $this->parse($value, false) !== null;
+			return $this->parse($value, false)!==null;
 		}
 	}
 
@@ -202,7 +202,7 @@ 
 	 * @return int date time stamp
 	 * @throws TInvalidDataValueException if date string is malformed.
 	 */
-	public function parse($value,$defaultToCurrentTime=true)
+	public function parse($value, $defaultToCurrentTime=true)
 	{
 		if(is_int($value) || is_float($value))
 			return $value;
@@ -211,108 +211,108 @@ 
 
 		if(empty($this->pattern)) return time();
 
-		$date = time();
+		$date=time();
 
 		if($this->length(trim($value)) < 1)
 			return $defaultToCurrentTime ? $date : null;
 
-		$pattern = $this->pattern;
+		$pattern=$this->pattern;
 
-		$i_val = 0;
-		$i_format = 0;
-		$pattern_length = $this->length($pattern);
-		$c = '';
+		$i_val=0;
+		$i_format=0;
+		$pattern_length=$this->length($pattern);
+		$c='';
 		$token='';
 		$x=null; $y=null;
 
 
 		if($defaultToCurrentTime)
 		{
-			$year = "{$date['year']}";
-			$month = $date['mon'];
-			$day = $date['mday'];
+			$year="{$date['year']}";
+			$month=$date['mon'];
+			$day=$date['mday'];
 		}
 		else
 		{
-			$year = null;
-			$month = null;
-			$day = null;
+			$year=null;
+			$month=null;
+			$day=null;
 		}
 
-		while ($i_format < $pattern_length)
+		while($i_format < $pattern_length)
 		{
-			$c = $this->charAt($pattern,$i_format);
+			$c=$this->charAt($pattern, $i_format);
 			$token='';
-			while ($this->charEqual($pattern, $i_format, $c)
+			while($this->charEqual($pattern, $i_format, $c)
 						&& ($i_format < $pattern_length))
 			{
-				$token .= $this->charAt($pattern, $i_format++);
+				$token.=$this->charAt($pattern, $i_format++);
 			}
 
-			if ($token=='yyyy' || $token=='yy' || $token=='y')
+			if($token=='yyyy' || $token=='yy' || $token=='y')
 			{
-				if ($token=='yyyy') { $x=4;$y=4; }
-				if ($token=='yy')   { $x=2;$y=2; }
-				if ($token=='y')    { $x=2;$y=4; }
-				$year = $this->getInteger($value,$i_val,$x,$y);
-				if($year === null)
+				if($token=='yyyy') { $x=4; $y=4; }
+				if($token=='yy') { $x=2; $y=2; }
+				if($token=='y') { $x=2; $y=4; }
+				$year=$this->getInteger($value, $i_val, $x, $y);
+				if($year===null)
 					return null;
 					//throw new TInvalidDataValueException('Invalid year', $value);
-				$i_val += strlen($year);
-				if(strlen($year) == 2)
+				$i_val+=strlen($year);
+				if(strlen($year)==2)
 				{
-					$iYear = (int)$year;
+					$iYear=(int) $year;
 					if($iYear > 70)
-						$year = $iYear + 1900;
+						$year=$iYear + 1900;
 					else
-						$year = $iYear + 2000;
+						$year=$iYear + 2000;
 				}
-				$year = (int)$year;
+				$year=(int) $year;
 			}
 			elseif($token=='MM' || $token=='M')
 			{
-				$month=$this->getInteger($value,$i_val,
-									$this->length($token),2);
-				$iMonth = (int)$month;
-				if($month === null || $iMonth < 1 || $iMonth > 12 )
+				$month=$this->getInteger($value, $i_val,
+									$this->length($token), 2);
+				$iMonth=(int) $month;
+				if($month===null || $iMonth < 1 || $iMonth > 12)
 					return null;
 					//throw new TInvalidDataValueException('Invalid month', $value);
-				$i_val += strlen($month);
-				$month = $iMonth;
+				$i_val+=strlen($month);
+				$month=$iMonth;
 			}
-			elseif ($token=='dd' || $token=='d')
+			elseif($token=='dd' || $token=='d')
 			{
-				$day = $this->getInteger($value,$i_val,
+				$day=$this->getInteger($value, $i_val,
 									$this->length($token), 2);
-				$iDay = (int)$day;
-				if($day === null || $iDay < 1 || $iDay >31)
+				$iDay=(int) $day;
+				if($day===null || $iDay < 1 || $iDay > 31)
 					return null;
 					//throw new TInvalidDataValueException('Invalid day', $value);
-				$i_val += strlen($day);
-				$day = $iDay;
+				$i_val+=strlen($day);
+				$day=$iDay;
 			}
 			else
 			{
-				if($this->substring($value, $i_val, $this->length($token)) != $token)
+				if($this->substring($value, $i_val, $this->length($token))!=$token)
 					return null;
 					//throw new TInvalidDataValueException("Subpattern '{$this->pattern}' mismatch", $value);
 				else
-					$i_val += $this->length($token);
+					$i_val+=$this->length($token);
 			}
 		}
-		if ($i_val != $this->length($value))
+		if($i_val!=$this->length($value))
 			return null;
 			//throw new TInvalidDataValueException("Pattern '{$this->pattern}' mismatch", $value);
-		if(!$defaultToCurrentTime && ($month === null || $day === null || $year === null))
+		if(!$defaultToCurrentTime && ($month===null || $day===null || $year===null))
 			return null;
 		else
 		{
 			if(empty($year)) {
-				$year = date('Y');
+				$year=date('Y');
 			}
-			$day = (int)$day <= 0 ? 1 : (int)$day;
-			$month = (int)$month <= 0 ? 1 : (int)$month;
-			$s = new TDateTimeStamp;
+			$day=(int) $day <= 0 ? 1 : (int) $day;
+			$month=(int) $month <= 0 ? 1 : (int) $month;
+			$s=new TDateTimeStamp;
 			return $s->getTimeStamp(0, 0, 0, $month, $day, $year);
 		}
 	}
@@ -347,7 +347,7 @@ 
 	 */
 	private function charEqual($string, $pos, $char)
 	{
-		return $this->charAt($string, $pos) == $char;
+		return $this->charAt($string, $pos)==$char;
 	}
 
 	/**
@@ -358,15 +358,15 @@ 
 	 * @param int maximum integer length
 	 * @return string integer portion of the string, null otherwise
 	 */
-	private function getInteger($str,$i,$minlength,$maxlength)
+	private function getInteger($str, $i, $minlength, $maxlength)
 	{
 		//match for digits backwards
-		for ($x = $maxlength; $x >= $minlength; $x--)
+		for($x=$maxlength; $x >= $minlength; $x--)
 		{
-			$token= $this->substring($str, $i,$x);
-			if ($this->length($token) < $minlength)
+			$token=$this->substring($str, $i, $x);
+			if($this->length($token) < $minlength)
 				return null;
-			if (preg_match('/^\d+$/', $token))
+			if(preg_match('/^\d+$/', $token))
 				return $token;
 		}
 		return null;

framework/Util/TVarDumper.php

Doc Comments +3 added lines

@@ -55,6 +55,9 @@
 			return self::$_output;
 	}
 
+	/**
+	 * @param integer $level
+	 */
 	private static function dumpInternal($var,$level)
 	{
 		switch(gettype($var))

Spacing +17 added lines, -17 removed lines

@@ -40,27 +40,27 @@ 
 	 * @param integer maximum depth that the dumper should go into the variable. Defaults to 10.
 	 * @return string the string representation of the variable
 	 */
-	public static function dump($var,$depth=10,$highlight=false)
+	public static function dump($var, $depth=10, $highlight=false)
 	{
 		self::$_output='';
 		self::$_objects=array();
 		self::$_depth=$depth;
-		self::dumpInternal($var,0);
+		self::dumpInternal($var, 0);
 		if($highlight)
 		{
-			$result=highlight_string("<?php\n".self::$_output,true);
-			return preg_replace('/&lt;\\?php<br \\/>/','',$result,1);
+			$result=highlight_string("<?php\n".self::$_output, true);
+			return preg_replace('/&lt;\\?php<br \\/>/', '', $result, 1);
 		}
 		else
 			return self::$_output;
 	}
 
-	private static function dumpInternal($var,$level)
+	private static function dumpInternal($var, $level)
 	{
 		switch(gettype($var))
 		{
 			case 'boolean':
-				self::$_output.=$var?'true':'false';
+				self::$_output.=$var ? 'true' : 'false';
 				break;
 			case 'integer':
 				self::$_output.="$var";
@@ -81,41 +81,41 @@ 
 				self::$_output.='{unknown}';
 				break;
 			case 'array':
-				if(self::$_depth<=$level)
+				if(self::$_depth <= $level)
 					self::$_output.='array(...)';
 				else if(empty($var))
 					self::$_output.='array()';
 				else
 				{
 					$keys=array_keys($var);
-					$spaces=str_repeat(' ',$level*4);
+					$spaces=str_repeat(' ', $level * 4);
 					self::$_output.="array\n".$spaces.'(';
 					foreach($keys as $key)
 					{
 						self::$_output.="\n".$spaces."    [$key] => ";
-						self::$_output.=self::dumpInternal($var[$key],$level+1);
+						self::$_output.=self::dumpInternal($var[$key], $level + 1);
 					}
 					self::$_output.="\n".$spaces.')';
 				}
 				break;
 			case 'object':
-				if(($id=array_search($var,self::$_objects,true))!==false)
-					self::$_output.=get_class($var).'#'.($id+1).'(...)';
-				else if(self::$_depth<=$level)
+				if(($id=array_search($var, self::$_objects, true))!==false)
+					self::$_output.=get_class($var).'#'.($id + 1).'(...)';
+				else if(self::$_depth <= $level)
 					self::$_output.=get_class($var).'(...)';
 				else
 				{
-					$id=array_push(self::$_objects,$var);
+					$id=array_push(self::$_objects, $var);
 					$className=get_class($var);
-					$members=(array)$var;
+					$members=(array) $var;
 					$keys=array_keys($members);
-					$spaces=str_repeat(' ',$level*4);
+					$spaces=str_repeat(' ', $level * 4);
 					self::$_output.="$className#$id\n".$spaces.'(';
 					foreach($keys as $key)
 					{
-						$keyDisplay=strtr(trim($key),array("\0"=>':'));
+						$keyDisplay=strtr(trim($key), array("\0"=>':'));
 						self::$_output.="\n".$spaces."    [$keyDisplay] => ";
-						self::$_output.=self::dumpInternal($members[$key],$level+1);
+						self::$_output.=self::dumpInternal($members[$key], $level + 1);
 					}
 					self::$_output.="\n".$spaces.')';
 				}

Braces +1 added lines, -2 removed lines

@@ -52,8 +52,7 @@
 		{
 			$result=highlight_string("<?php\n".self::$_output,true);
 			return preg_replace('/&lt;\\?php<br \\/>/','',$result,1);
-		}
-		else
+		} else
 			return self::$_output;
 	}
 

framework/Web/Javascripts/JSMin.php

Doc Comments +9 added lines

@@ -73,6 +73,9 @@ 
 
   // -- Protected Instance Methods ---------------------------------------------
 
+  /**
+   * @param integer $d
+   */
   protected function action($d) {
     switch($d) {
       case 1:
@@ -132,6 +135,9 @@ 
     }
   }
 
+  /**
+   * @return string
+   */
   protected function get() {
     $c = $this->lookAhead;
     $this->lookAhead = null;
@@ -156,6 +162,9 @@ 
     return ' ';
   }
 
+  /**
+   * @param string $c
+   */
   protected function isAlphaNum($c) {
     return ord($c) > 126 || $c === '\\' || preg_match('/^[\w\$]$/', $c) === 1;
   }

Braces +2 added lines, -4 removed lines

@@ -191,8 +191,7 @@ 
             default:
               if ($this->isAlphaNum($this->b)) {
                 $this->action(1);
-              }
-              else {
+              } else {
                 $this->action(2);
               }
           }
@@ -224,8 +223,7 @@ 
                 default:
                   if ($this->isAlphaNum($this->a)) {
                     $this->action(1);
-                  }
-                  else {
+                  } else {
                     $this->action(3);
                   }
               }

Indentation +198 added lines, -198 removed lines

@@ -59,228 +59,228 @@
   // -- Public Static Methods --------------------------------------------------
 
   public static function minify($js) {
-    $jsmin = new JSMin($js);
-    return $jsmin->min();
+	$jsmin = new JSMin($js);
+	return $jsmin->min();
   }
 
   // -- Public Instance Methods ------------------------------------------------
 
   public function __construct($input) {
-    $this->input       = str_replace("\r\n", "\n", $input);
-    $this->inputLength = strlen($this->input);
+	$this->input       = str_replace("\r\n", "\n", $input);
+	$this->inputLength = strlen($this->input);
   }
 
   // -- Protected Instance Methods ---------------------------------------------
 
   protected function action($d) {
-    switch($d) {
-      case 1:
-        $this->output .= $this->a;
-
-      case 2:
-        $this->a = $this->b;
-
-        if ($this->a === "'" || $this->a === '"') {
-          for (;;) {
-            $this->output .= $this->a;
-            $this->a       = $this->get();
-
-            if ($this->a === $this->b) {
-              break;
-            }
-
-            if (ord($this->a) <= self::ORD_LF) {
-              throw new JSMinException('Unterminated string literal.');
-            }
-
-            if ($this->a === '\\') {
-              $this->output .= $this->a;
-              $this->a       = $this->get();
-            }
-          }
-        }
-
-      case 3:
-        $this->b = $this->next();
-
-        if ($this->b === '/' && (
-            $this->a === '(' || $this->a === ',' || $this->a === '=' ||
-            $this->a === ':' || $this->a === '[' || $this->a === '!' ||
-            $this->a === '&' || $this->a === '|' || $this->a === '?')) {
-
-          $this->output .= $this->a . $this->b;
-
-          for (;;) {
-            $this->a = $this->get();
-
-            if ($this->a === '/') {
-              break;
-            } elseif ($this->a === '\\') {
-              $this->output .= $this->a;
-              $this->a       = $this->get();
-            } elseif (ord($this->a) <= self::ORD_LF) {
-              throw new JSMinException('Unterminated regular expression '.
-                  'literal.');
-            }
-
-            $this->output .= $this->a;
-          }
-
-          $this->b = $this->next();
-        }
-    }
+	switch($d) {
+	  case 1:
+		$this->output .= $this->a;
+
+	  case 2:
+		$this->a = $this->b;
+
+		if ($this->a === "'" || $this->a === '"') {
+		  for (;;) {
+			$this->output .= $this->a;
+			$this->a       = $this->get();
+
+			if ($this->a === $this->b) {
+			  break;
+			}
+
+			if (ord($this->a) <= self::ORD_LF) {
+			  throw new JSMinException('Unterminated string literal.');
+			}
+
+			if ($this->a === '\\') {
+			  $this->output .= $this->a;
+			  $this->a       = $this->get();
+			}
+		  }
+		}
+
+	  case 3:
+		$this->b = $this->next();
+
+		if ($this->b === '/' && (
+			$this->a === '(' || $this->a === ',' || $this->a === '=' ||
+			$this->a === ':' || $this->a === '[' || $this->a === '!' ||
+			$this->a === '&' || $this->a === '|' || $this->a === '?')) {
+
+		  $this->output .= $this->a . $this->b;
+
+		  for (;;) {
+			$this->a = $this->get();
+
+			if ($this->a === '/') {
+			  break;
+			} elseif ($this->a === '\\') {
+			  $this->output .= $this->a;
+			  $this->a       = $this->get();
+			} elseif (ord($this->a) <= self::ORD_LF) {
+			  throw new JSMinException('Unterminated regular expression '.
+				  'literal.');
+			}
+
+			$this->output .= $this->a;
+		  }
+
+		  $this->b = $this->next();
+		}
+	}
   }
 
   protected function get() {
-    $c = $this->lookAhead;
-    $this->lookAhead = null;
-
-    if ($c === null) {
-      if ($this->inputIndex < $this->inputLength) {
-        $c = $this->input[$this->inputIndex];
-        $this->inputIndex += 1;
-      } else {
-        $c = null;
-      }
-    }
-
-    if ($c === "\r") {
-      return "\n";
-    }
-
-    if ($c === null || $c === "\n" || ord($c) >= self::ORD_SPACE) {
-      return $c;
-    }
-
-    return ' ';
+	$c = $this->lookAhead;
+	$this->lookAhead = null;
+
+	if ($c === null) {
+	  if ($this->inputIndex < $this->inputLength) {
+		$c = $this->input[$this->inputIndex];
+		$this->inputIndex += 1;
+	  } else {
+		$c = null;
+	  }
+	}
+
+	if ($c === "\r") {
+	  return "\n";
+	}
+
+	if ($c === null || $c === "\n" || ord($c) >= self::ORD_SPACE) {
+	  return $c;
+	}
+
+	return ' ';
   }
 
   protected function isAlphaNum($c) {
-    return ord($c) > 126 || $c === '\\' || preg_match('/^[\w\$]$/', $c) === 1;
+	return ord($c) > 126 || $c === '\\' || preg_match('/^[\w\$]$/', $c) === 1;
   }
 
   protected function min() {
-    $this->a = "\n";
-    $this->action(3);
-
-    while ($this->a !== null) {
-      switch ($this->a) {
-        case ' ':
-          if ($this->isAlphaNum($this->b)) {
-            $this->action(1);
-          } else {
-            $this->action(2);
-          }
-          break;
-
-        case "\n":
-          switch ($this->b) {
-            case '{':
-            case '[':
-            case '(':
-            case '+':
-            case '-':
-              $this->action(1);
-              break;
-
-            case ' ':
-              $this->action(3);
-              break;
-
-            default:
-              if ($this->isAlphaNum($this->b)) {
-                $this->action(1);
-              }
-              else {
-                $this->action(2);
-              }
-          }
-          break;
-
-        default:
-          switch ($this->b) {
-            case ' ':
-              if ($this->isAlphaNum($this->a)) {
-                $this->action(1);
-                break;
-              }
-
-              $this->action(3);
-              break;
-
-            case "\n":
-              switch ($this->a) {
-                case '}':
-                case ']':
-                case ')':
-                case '+':
-                case '-':
-                case '"':
-                case "'":
-                  $this->action(1);
-                  break;
-
-                default:
-                  if ($this->isAlphaNum($this->a)) {
-                    $this->action(1);
-                  }
-                  else {
-                    $this->action(3);
-                  }
-              }
-              break;
-
-            default:
-              $this->action(1);
-              break;
-          }
-      }
-    }
-
-    return $this->output;
+	$this->a = "\n";
+	$this->action(3);
+
+	while ($this->a !== null) {
+	  switch ($this->a) {
+		case ' ':
+		  if ($this->isAlphaNum($this->b)) {
+			$this->action(1);
+		  } else {
+			$this->action(2);
+		  }
+		  break;
+
+		case "\n":
+		  switch ($this->b) {
+			case '{':
+			case '[':
+			case '(':
+			case '+':
+			case '-':
+			  $this->action(1);
+			  break;
+
+			case ' ':
+			  $this->action(3);
+			  break;
+
+			default:
+			  if ($this->isAlphaNum($this->b)) {
+				$this->action(1);
+			  }
+			  else {
+				$this->action(2);
+			  }
+		  }
+		  break;
+
+		default:
+		  switch ($this->b) {
+			case ' ':
+			  if ($this->isAlphaNum($this->a)) {
+				$this->action(1);
+				break;
+			  }
+
+			  $this->action(3);
+			  break;
+
+			case "\n":
+			  switch ($this->a) {
+				case '}':
+				case ']':
+				case ')':
+				case '+':
+				case '-':
+				case '"':
+				case "'":
+				  $this->action(1);
+				  break;
+
+				default:
+				  if ($this->isAlphaNum($this->a)) {
+					$this->action(1);
+				  }
+				  else {
+					$this->action(3);
+				  }
+			  }
+			  break;
+
+			default:
+			  $this->action(1);
+			  break;
+		  }
+	  }
+	}
+
+	return $this->output;
   }
 
   protected function next() {
-    $c = $this->get();
-
-    if ($c === '/') {
-      switch($this->peek()) {
-        case '/':
-          for (;;) {
-            $c = $this->get();
-
-            if (ord($c) <= self::ORD_LF) {
-              return $c;
-            }
-          }
-
-        case '*':
-          $this->get();
-
-          for (;;) {
-            switch($this->get()) {
-              case '*':
-                if ($this->peek() === '/') {
-                  $this->get();
-                  return ' ';
-                }
-                break;
-
-              case null:
-                throw new JSMinException('Unterminated comment.');
-            }
-          }
-
-        default:
-          return $c;
-      }
-    }
-
-    return $c;
+	$c = $this->get();
+
+	if ($c === '/') {
+	  switch($this->peek()) {
+		case '/':
+		  for (;;) {
+			$c = $this->get();
+
+			if (ord($c) <= self::ORD_LF) {
+			  return $c;
+			}
+		  }
+
+		case '*':
+		  $this->get();
+
+		  for (;;) {
+			switch($this->get()) {
+			  case '*':
+				if ($this->peek() === '/') {
+				  $this->get();
+				  return ' ';
+				}
+				break;
+
+			  case null:
+				throw new JSMinException('Unterminated comment.');
+			}
+		  }
+
+		default:
+		  return $c;
+	  }
+	}
+
+	return $c;
   }
 
   protected function peek() {
-    $this->lookAhead = $this->get();
-    return $this->lookAhead;
+	$this->lookAhead = $this->get();
+	return $this->lookAhead;
   }
 }
\ No newline at end of file

Spacing +66 added lines, -66 removed lines

@@ -47,29 +47,29 @@ 
 namespace Prado\Web\Javascripts;
 
 class JSMin {
-  const ORD_LF    = 10;
-  const ORD_SPACE = 32;
+  const ORD_LF=10;
+  const ORD_SPACE=32;
 
-  protected $a           = '';
-  protected $b           = '';
-  protected $input       = '';
-  protected $inputIndex  = 0;
-  protected $inputLength = 0;
-  protected $lookAhead   = null;
-  protected $output      = '';
+  protected $a='';
+  protected $b='';
+  protected $input='';
+  protected $inputIndex=0;
+  protected $inputLength=0;
+  protected $lookAhead=null;
+  protected $output='';
 
   // -- Public Static Methods --------------------------------------------------
 
   public static function minify($js) {
-    $jsmin = new JSMin($js);
+    $jsmin=new JSMin($js);
     return $jsmin->min();
   }
 
   // -- Public Instance Methods ------------------------------------------------
 
   public function __construct($input) {
-    $this->input       = str_replace("\r\n", "\n", $input);
-    $this->inputLength = strlen($this->input);
+    $this->input=str_replace("\r\n", "\n", $input);
+    $this->inputLength=strlen($this->input);
   }
 
   // -- Protected Instance Methods ---------------------------------------------
@@ -77,80 +77,80 @@ 
   protected function action($d) {
     switch($d) {
       case 1:
-        $this->output .= $this->a;
+        $this->output.=$this->a;
 
       case 2:
-        $this->a = $this->b;
+        $this->a=$this->b;
 
-        if ($this->a === "'" || $this->a === '"') {
-          for (;;) {
-            $this->output .= $this->a;
-            $this->a       = $this->get();
+        if($this->a==="'" || $this->a==='"') {
+          for(;;) {
+            $this->output.=$this->a;
+            $this->a=$this->get();
 
-            if ($this->a === $this->b) {
+            if($this->a===$this->b) {
               break;
             }
 
-            if (ord($this->a) <= self::ORD_LF) {
+            if(ord($this->a) <= self::ORD_LF) {
               throw new JSMinException('Unterminated string literal.');
             }
 
-            if ($this->a === '\\') {
-              $this->output .= $this->a;
-              $this->a       = $this->get();
+            if($this->a==='\\') {
+              $this->output.=$this->a;
+              $this->a=$this->get();
             }
           }
         }
 
       case 3:
-        $this->b = $this->next();
+        $this->b=$this->next();
 
-        if ($this->b === '/' && (
-            $this->a === '(' || $this->a === ',' || $this->a === '=' ||
-            $this->a === ':' || $this->a === '[' || $this->a === '!' ||
-            $this->a === '&' || $this->a === '|' || $this->a === '?')) {
+        if($this->b==='/' && (
+            $this->a==='(' || $this->a===',' || $this->a==='=' ||
+            $this->a===':' || $this->a==='[' || $this->a==='!' ||
+            $this->a==='&' || $this->a==='|' || $this->a==='?')) {
 
-          $this->output .= $this->a . $this->b;
+          $this->output.=$this->a.$this->b;
 
-          for (;;) {
-            $this->a = $this->get();
+          for(;;) {
+            $this->a=$this->get();
 
-            if ($this->a === '/') {
+            if($this->a==='/') {
               break;
-            } elseif ($this->a === '\\') {
-              $this->output .= $this->a;
-              $this->a       = $this->get();
-            } elseif (ord($this->a) <= self::ORD_LF) {
+            } elseif($this->a==='\\') {
+              $this->output.=$this->a;
+              $this->a=$this->get();
+            } elseif(ord($this->a) <= self::ORD_LF) {
               throw new JSMinException('Unterminated regular expression '.
                   'literal.');
             }
 
-            $this->output .= $this->a;
+            $this->output.=$this->a;
           }
 
-          $this->b = $this->next();
+          $this->b=$this->next();
         }
     }
   }
 
   protected function get() {
-    $c = $this->lookAhead;
-    $this->lookAhead = null;
+    $c=$this->lookAhead;
+    $this->lookAhead=null;
 
-    if ($c === null) {
-      if ($this->inputIndex < $this->inputLength) {
-        $c = $this->input[$this->inputIndex];
-        $this->inputIndex += 1;
+    if($c===null) {
+      if($this->inputIndex < $this->inputLength) {
+        $c=$this->input[$this->inputIndex];
+        $this->inputIndex+=1;
       } else {
-        $c = null;
+        $c=null;
       }
     }
 
-    if ($c === "\r") {
+    if($c==="\r") {
       return "\n";
     }
 
-    if ($c === null || $c === "\n" || ord($c) >= self::ORD_SPACE) {
+    if($c===null || $c==="\n" || ord($c) >= self::ORD_SPACE) {
       return $c;
     }
 
@@ -158,17 +158,17 @@ 
   }
 
   protected function isAlphaNum($c) {
-    return ord($c) > 126 || $c === '\\' || preg_match('/^[\w\$]$/', $c) === 1;
+    return ord($c) > 126 || $c==='\\' || preg_match('/^[\w\$]$/', $c)===1;
   }
 
   protected function min() {
-    $this->a = "\n";
+    $this->a="\n";
     $this->action(3);
 
-    while ($this->a !== null) {
-      switch ($this->a) {
+    while($this->a!==null) {
+      switch($this->a) {
         case ' ':
-          if ($this->isAlphaNum($this->b)) {
+          if($this->isAlphaNum($this->b)) {
             $this->action(1);
           } else {
             $this->action(2);
@@ -176,7 +176,7 @@ 
           break;
 
         case "\n":
-          switch ($this->b) {
+          switch($this->b) {
             case '{':
             case '[':
             case '(':
@@ -190,7 +190,7 @@ 
               break;
 
             default:
-              if ($this->isAlphaNum($this->b)) {
+              if($this->isAlphaNum($this->b)) {
                 $this->action(1);
               }
               else {
@@ -200,9 +200,9 @@ 
           break;
 
         default:
-          switch ($this->b) {
+          switch($this->b) {
             case ' ':
-              if ($this->isAlphaNum($this->a)) {
+              if($this->isAlphaNum($this->a)) {
                 $this->action(1);
                 break;
               }
@@ -211,7 +211,7 @@ 
               break;
 
             case "\n":
-              switch ($this->a) {
+              switch($this->a) {
                 case '}':
                 case ']':
                 case ')':
@@ -223,7 +223,7 @@ 
                   break;
 
                 default:
-                  if ($this->isAlphaNum($this->a)) {
+                  if($this->isAlphaNum($this->a)) {
                     $this->action(1);
                   }
                   else {
@@ -243,15 +243,15 @@ 
   }
 
   protected function next() {
-    $c = $this->get();
+    $c=$this->get();
 
-    if ($c === '/') {
+    if($c==='/') {
       switch($this->peek()) {
         case '/':
-          for (;;) {
-            $c = $this->get();
+          for(;;) {
+            $c=$this->get();
 
-            if (ord($c) <= self::ORD_LF) {
+            if(ord($c) <= self::ORD_LF) {
               return $c;
             }
           }
@@ -259,10 +259,10 @@ 
         case '*':
           $this->get();
 
-          for (;;) {
+          for(;;) {
             switch($this->get()) {
               case '*':
-                if ($this->peek() === '/') {
+                if($this->peek()==='/') {
                   $this->get();
                   return ' ';
                 }
@@ -282,7 +282,7 @@ 
   }
 
   protected function peek() {
-    $this->lookAhead = $this->get();
+    $this->lookAhead=$this->get();
     return $this->lookAhead;
   }
 }
\ No newline at end of file