File Source for FilesystemToolkit.class.php

<?php
/**
* For including this file you have to define the constant "CLASSPATH".
* Because every include in the framework depends on the CLASSPATH definition.
* The CLASSPATH means the relative path to the folder that contains the
* framework GilliGan.
*
* @package filesystem
*/
if( !defined( "CLASSPATH" ) )
{
echo "<h3>You have to define the constant CLASSPATH!</h3>\n";
echo "Example: define( 'CLASSPATH', '../path/to/classes/' );\n";
exit();
}
/**
* Including various functions to manipulate arrays.
*/
require_once( CLASSPATH."core/Arrays.class.php" );
/**
* Constant FILESANDFOLDER describes that files and folder kan match this value.
* For example if you want to read both (file and folders) from a filesystem.
*/
define( "FILEORFOLDER", 0 );
/**
* Constant FILES is defined to declare the type files in a filesystem.
*/
define( "FILE", 1 );
/**
* Constant FOLDER is defined to declare the type folder in a filesystem.
*/
define( "FOLDER", 2 );
/**
* Static Methods
*
* @package filesystem
* @version 0.1.9
* @static
* @author Daniel Plücken ( daniel@debakel.net )
* @license http://www.gnu.org/copyleft/lesser.html
* GNU Lesser General Public License
* @copyright Copyright (c) 2003 Daniel Plücken ( daniel@debakel.net )
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*/
class FilesystemToolkit
{
/**
* Removes the last slash in a path if it is on the last position.
*
* @version 1.0
* @since 0.1.0
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @static
* @param string $string The string comprises the path and the filename
* and which should be slited.
* @return string
*/
function getCleanPath( $string )
{
// perhaps?
// return preg_replace( "!(.+?)/ *$!", "$1", $string );
if( ( $strpos = strrpos( $string, '/' ) ) === strlen( $string ) - 1 )
return substr( $string, 0, $strpos );
else
return $string;
}
/**
* Return human readable sizes.
*
* @author Aidan Lister <aidan@php.net>
* @version 1.1
* @since 0.1.9
* @link http://aidanlister.com/repos/v/function.size_readable.php
* @static
* @param int $size Size
* @param int $unit The maximum unit
* @param int $retstring The return string format
* @param int $si Whether to use SI prefixes
*/
function size_readable( $size, $unit = null, $retstring = null, $si = true )
{
// Units
if ($si === true) {
$sizes = array('B', 'KB', 'MB', 'GB', 'TB', 'PB');
$mod = 1000;
} else {
$sizes = array('B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB');
$mod = 1024;
}
$ii = count($sizes) - 1;
// Max unit
$unit = array_search($unit, $sizes);
if ($unit === null || $unit === false) {
$unit = $ii;
}
// Return string
if ($retstring === null) {
$retstring = '%01.2f %s';
}
// Loop
$i = 0;
while ($unit != $i && $size >= 1024 && $i < $ii) {
$size /= $mod;
$i++;
}
return sprintf($retstring, $size, $sizes[$i]);
}
/**
* Returns the suffix of a file. To be returned, the suffix has to have three
* or four digits and contains only letters (ASCII) and numbers.
*
* @version 1.0
* @since 0.1.85
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @static
* @param string $path The string containing the path to the file to
* checkout.
* @return string
*/
function getFileSuffix( $path )
{ return preg_replace( "!.+\.([a-z0-9]{3,4})$!i", "$1", $path ); }
/**
* Separates the path and the filename of each other and returns the splited
* values in an array. The first entry [0] of the array will be the path and
* the second entry [1] will be the filename.
*
* @version 1.2
* @since 0.1.1
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @static
* @param string $string The string comprises the path and the filename
* and which should be slited.
* @return array
*/
function separatePathAndFile( $string )
{
$string = FilesystemToolkit::getCleanPath( $string );
$pos = strrpos( $string, "/" );
if( $pos === false )
{
$arr[0] = ".";
$arr[1] = $string;
}
else
{
$arr[0] = substr( $string, 0, $pos );
$arr[1] = substr( $string, $pos + 1 );
}
return $arr;
}
/**
* Extracs the direct path from one to another folder.
* The from-folder is absolut the target-folder is relative.
* For example you read out links from a htmlsource and you want to follow
* this links. You know the url of the file's htmlsource and where the links
* you read out relativly refer to. Then you just should give the url $from
* and the relative path $to to this function and it will return you the
* direct url to the links in the htmlsource.
*
* @version 1.2
* @since 0.1.4
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @static
* @param string $from
* @param string $to
* @return string
*/
function getPurePathFromTo( $from, $to )
{
$from = FilesystemToolkit::getCleanPath( $from );
$to = FilesystemToolkit::getCleanPath( $to );
$fromArr = explode( "/", $from );
$toArr = explode( "/", $to );
while ( $toArr[0] == "." )
Arrays::deleteRecord( 0, $toArr );
for ( $i = 0; $i < count( $toArr ); $i++ )
if ( $toArr[$i] == ".." )
Arrays::deleteRecord( count( $fromArr )-1, $fromArr );
while ( $toArr[0] == ".." )
Arrays::deleteRecord( 0, $toArr );
$frompath = implode( "/", $fromArr );
$outputstr = ( !empty( $frompath )
? $frompath."/"
: ""
)
.implode( "/", $toArr );
return $outputstr;
}
/**
* Loads the content of a given folder. Stores file- and foldernmaes in a two
* dimensional array like as follows:
*
* $out[FILENUMBER]['name']
* $out[FILENUMBER]['is_dir']
* $out[FILENUMBER]['size'] (if flag $filesize is set)
*
* The output array will be sorted by the filename.
*
* @static
* @version 1.2
* @since 0.1.5
* @todo Modifying the sort that files and folders will be grouped in the
* out array
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $dir
* @param string $regExpMatchFiles
* @param string $regExpMatchFolder
* @param boolean $filesize
* @return false|array
*/
function loadFolderContent(
$dir,
$regExpMatchFiles = "",
$regExpMatchFolder = "",
$filesize = false
)
{
if( !is_dir( $dir ) )
return false;
else
{
$out = array();
clearstatcache();
$i = 0;
$folder = opendir( $dir );
# folder and files to separate arrays.
while ( ( $file = readdir( $folder ) ) !== false )
{
if (
$file != "."
&& $file != ".."
)
{
# collecting folder
if (
is_dir( $dir."/".$file )
&& (
empty( $regExpMatchFolder )
|| preg_match( $regExpMatchFolder, $file )
)
)
{
$out[$i]["name"] = $file;
$out[$i]["is_dir"] = true;
$i++;
}
else # collecting files
if (
empty( $regExpMatchFiles )
|| preg_match( $regExpMatchFiles, $file )
)
{
$out[$i]["name"] = $file;
$out[$i]["is_dir"] = false;
if ( $filesize )
$out[$i]["size"] = filesize( $dir."/".$file );
$i++;
}
}
}
closedir( $folder );
if ( count( $out ) > 1 )
Arrays::sortSecondDimension( $out, "name" );
return $out;
}
}
/**
* Loads the content of a given file.
*
* @static
* @version 1.0
* @since 0.1.5
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $path Where the file can be found.
* @param string $file The file's name whose content should be loaded.
* @return string
*/
function loadFileContent()
{
$param = func_get_args();
if ( empty( $param[1] ) )
{
$tmpArr = FilesystemToolkit
::separatePathAndFile( $param[0] );
$path = $tmpArr[0];
$file = $tmpArr[1];
}
else
{
$path = $param[0];
$file = $param[1];
}
if ( file_exists( $path."/".$file ) )
$data = implode( "", ( file( $path."/".$file ) ) );
return $data;
}
/**
* Copies a directory recursively.
*
* @static
* @version 1.0
* @since 0.1.7
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $source The directory to copy.
* @param string $target The target directory for copying.
* @return string
*/
function copyDir( $source, $target )
{
$source = FilesystemToolkit::getCleanPath( $source );
$target = FilesystemToolkit::getCleanPath( $target );
if ( !is_dir( $target ) )
mkdir( $target );
$folder = opendir( $source );
while ( ( $file = readdir( $folder ) ) !== false )
{
if (
$file != "."
&& $file != ".."
)
{
# recursive invokation
if ( is_dir( $source."/".$file ) )
{
if ( !is_dir( $target."/".$file ) )
mkdir( $target."/".$file );
FilesystemToolkit::copyDir(
$source."/".$file,
$target."/".$file
);
}
else
if ( !file_exists( $target."/".$file ) )
{
// temporarly file content
$tfc = FilesystemToolkit::loadFileContent( $source."/".$file );
fwrite( fopen( $target."/".$file, 'w' ), $tfc );
}
}
}
closedir( $folder );
}
/**
* Deletes a directory recursively.
*
* @static
* @version 1.0
* @since 0.1.6
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $dir The directory to delete.
* @return void
*/
function deleteDir( $dir )
{
$dir = FilesystemToolkit::getCleanPath( $dir );
$folder = opendir( $dir );
while ( ( $file = readdir( $folder ) ) !== false )
{
if (
$file != "."
&& $file != ".."
)
{
# recursive invokation
if( is_dir( $dir."/".$file ) )
FilesystemToolkit::deleteDir( $dir."/".$file );
else
unlink( $dir."/".$file );
}
}
closedir( $folder );
rmdir( $dir );
}
/**
* Deletes a directory recursively. This method is an alias for the method
* deleteDir()
*
* @static
* @version 1.0
* @since 0.1.6
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $dir The directory to delete.
* @return string
*/
function removeDir( $dir )
{ FilesystemToolkit::deleteDir(); }
/**
* Rewrites a directory recursively to handle it like it is written by the
* server user.
*
* @static
* @version 1.0
* @since 0.1.7
* @author Daniel Plücken <daniel@debakel.net>
* @access public
* @param string $dir The directory to rewrite.
* @return string
*/
function rewriteDir( $dir )
{
$dir = FilesystemToolkit::getCleanPath( $dir );
$folder = opendir( $dir );
while ( ( $file = readdir( $folder ) ) !== false )
{
if (
$file != "."
&& $file != ".."
)
{
# recursive invokation
if ( is_dir( $dir."/".$file ) )
FilesystemToolkit::rewriteDir( $dir."/".$file );
else
{
// temporarly file content
$tfc = FilesystemToolkit::loadFileContent( $dir."/".$file );
unlink( $dir."/".$file );
fwrite( fopen( $dir."/".$file, 'w' ), $tfc );
}
}
}
closedir( $folder );
}
/**
* Checks whether an url can access.
*
* @static
* @version 1.0
* @since 0.1.8
* @author Fabrizio (staff at bibivu dot com)
* @author Daniel Plücken <daniel@debakel.net> (only write down here)
* @see http://www.php.net/manual/en/function.file-exists.php
* @access public
* @param string $url The url to proof of existence.
* @return string
*/
function url_exists( $url )
{
$a_url = parse_url( $url );
if ( !isset( $a_url["port"] ) )
$a_url["port"] = 80;
$errno = 0;
$errstr = "";
$timeout = 30;
if (
!isset( $a_url["host"] )
|| $a_url["host"] == gethostbyname( $a_url["host"] )
)
return false;
else
{
$fid = fsockopen(
$a_url["host"],
$a_url["port"],
$errno, $errstr,
$timeout
);
if ( !$fid )
return false;
$page = isset( $a_url["path"] )
? $a_url["path"]
: "";
$page .= isset( $a_url["query"] )
? "?".$a_url["query"]
: "";
fputs(
$fid,
"HEAD ".$page." HTTP/1.0\r\n"
."Host: ".$a_url["host"]."\r\n\r\n"
);
$head = fread( $fid, 4096 );
fclose( $fid );
return preg_match( '#^HTTP/.*\s+[200|302]+\s#i', $head );
}
}
} // END of class FilesystemToolkit
?>

Source for file FilesystemToolkit.class.php