Context Navigation

source: branches/version-2_13-dev/data/module/System.php @ 23125

Visit:

Revision 23125, 19.8 KB checked in by kimoto, 11 years ago (diff)
#2275 PEAR更新不要なrequire_onceの削除レガシーなPEARモジュールは使わない SearchReplace?.phpのパスが間違っているので修正

Line
1	<?php
2	/**
3	* File/Directory manipulation
4	*
5	* PHP versions 4 and 5
6	*
7	* @category pear
8	* @package System
9	* @author Tomas V.V.Cox <cox@idecnet.com>
10	* @copyright 1997-2009 The Authors
11	* @license http://opensource.org/licenses/bsd-license.php New BSD License
12	* @version CVS: $Id: System.php 313024 2011-07-06 19:51:24Z dufuz $
13	* @link http://pear.php.net/package/PEAR
14	* @since File available since Release 0.1
15	*/
16
17	/**
18	* base class
19	*/
20	require_once 'PEAR.php';
21	require_once 'Console/Getopt.php';
22
23	$GLOBALS['_System_temp_files'] = array();
24
25	/**
26	* System offers cross plattform compatible system functions
27	*
28	* Static functions for different operations. Should work under
29	* Unix and Windows. The names and usage has been taken from its respectively
30	* GNU commands. The functions will return (bool) false on error and will
31	* trigger the error with the PHP trigger_error() function (you can silence
32	* the error by prefixing a '@' sign after the function call, but this
33	* is not recommended practice. Instead use an error handler with
34	* {@link set_error_handler()}).
35	*
36	* Documentation on this class you can find in:
37	* http://pear.php.net/manual/
38	*
39	* Example usage:
40	* if (!@System::rm('-r file1 dir1')) {
41	* print "could not delete file1 or dir1";
42	* }
43	*
44	* In case you need to to pass file names with spaces,
45	* pass the params as an array:
46	*
47	* System::rm(array('-r', $file1, $dir1));
48	*
49	* @category pear
50	* @package System
51	* @author Tomas V.V. Cox <cox@idecnet.com>
52	* @copyright 1997-2006 The PHP Group
53	* @license http://opensource.org/licenses/bsd-license.php New BSD License
54	* @version Release: 1.9.4
55	* @link http://pear.php.net/package/PEAR
56	* @since Class available since Release 0.1
57	* @static
58	*/
59	class System
60	{
61	/**
62	* returns the commandline arguments of a function
63	*
64	* @param string $argv the commandline
65	* @param string $short_options the allowed option short-tags
66	* @param string $long_options the allowed option long-tags
67	* @return array the given options and there values
68	* @static
69	* @access private
70	*/
71	function _parseArgs($argv, $short_options, $long_options = null)
72	{
73	if (!is_array($argv) && $argv !== null) {
74	// Find all items, quoted or otherwise
75	preg_match_all("/(?:[\"'])(.*?)(?:['\"])\|([^\s]+)/", $argv, $av);
76	$argv = $av[1];
77	foreach ($av[2] as $k => $a) {
78	if (empty($a)) {
79	continue;
80	}
81	$argv[$k] = trim($a) ;
82	}
83	}
84	return Console_Getopt::getopt2($argv, $short_options, $long_options);
85	}
86
87	/**
88	* Output errors with PHP trigger_error(). You can silence the errors
89	* with prefixing a "@" sign to the function call: @System::mkdir(..);
90	*
91	* @param mixed $error a PEAR error or a string with the error message
92	* @return bool false
93	* @static
94	* @access private
95	*/
96	function raiseError($error)
97	{
98	if (PEAR::isError($error)) {
99	$error = $error->getMessage();
100	}
101	trigger_error($error, E_USER_WARNING);
102	return false;
103	}
104
105	/**
106	* Creates a nested array representing the structure of a directory
107	*
108	* System::_dirToStruct('dir1', 0) =>
109	* Array
110	* (
111	* [dirs] => Array
112	* (
113	* [0] => dir1
114	* )
115	*
116	* [files] => Array
117	* (
118	* [0] => dir1/file2
119	* [1] => dir1/file3
120	* )
121	* )
122	* @param string $sPath Name of the directory
123	* @param integer $maxinst max. deep of the lookup
124	* @param integer $aktinst starting deep of the lookup
125	* @param bool $silent if true, do not emit errors.
126	* @return array the structure of the dir
127	* @static
128	* @access private
129	*/
130	function _dirToStruct($sPath, $maxinst, $aktinst = 0, $silent = false)
131	{
132	$struct = array('dirs' => array(), 'files' => array());
133	if (($dir = @opendir($sPath)) === false) {
134	if (!$silent) {
135	System::raiseError("Could not open dir $sPath");
136	}
137	return $struct; // XXX could not open error
138	}
139
140	$struct['dirs'][] = $sPath = realpath($sPath); // XXX don't add if '.' or '..' ?
141	$list = array();
142	while (false !== ($file = readdir($dir))) {
143	if ($file != '.' && $file != '..') {
144	$list[] = $file;
145	}
146	}
147
148	closedir($dir);
149	natsort($list);
150	if ($aktinst < $maxinst \|\| $maxinst == 0) {
151	foreach ($list as $val) {
152	$path = $sPath . DIRECTORY_SEPARATOR . $val;
153	if (is_dir($path) && !is_link($path)) {
154	$tmp = System::_dirToStruct($path, $maxinst, $aktinst+1, $silent);
155	$struct = array_merge_recursive($struct, $tmp);
156	} else {
157	$struct['files'][] = $path;
158	}
159	}
160	}
161
162	return $struct;
163	}
164
165	/**
166	* Creates a nested array representing the structure of a directory and files
167	*
168	* @param array $files Array listing files and dirs
169	* @return array
170	* @static
171	* @see System::_dirToStruct()
172	*/
173	function _multipleToStruct($files)
174	{
175	$struct = array('dirs' => array(), 'files' => array());
176	settype($files, 'array');
177	foreach ($files as $file) {
178	if (is_dir($file) && !is_link($file)) {
179	$tmp = System::_dirToStruct($file, 0);
180	$struct = array_merge_recursive($tmp, $struct);
181	} else {
182	if (!in_array($file, $struct['files'])) {
183	$struct['files'][] = $file;
184	}
185	}
186	}
187	return $struct;
188	}
189
190	/**
191	* The rm command for removing files.
192	* Supports multiple files and dirs and also recursive deletes
193	*
194	* @param string $args the arguments for rm
195	* @return mixed PEAR_Error or true for success
196	* @static
197	* @access public
198	*/
199	function rm($args)
200	{
201	$opts = System::_parseArgs($args, 'rf'); // "f" does nothing but I like it :-)
202	if (PEAR::isError($opts)) {
203	return System::raiseError($opts);
204	}
205	foreach ($opts[0] as $opt) {
206	if ($opt[0] == 'r') {
207	$do_recursive = true;
208	}
209	}
210	$ret = true;
211	if (isset($do_recursive)) {
212	$struct = System::_multipleToStruct($opts[1]);
213	foreach ($struct['files'] as $file) {
214	if (!@unlink($file)) {
215	$ret = false;
216	}
217	}
218
219	rsort($struct['dirs']);
220	foreach ($struct['dirs'] as $dir) {
221	if (!@rmdir($dir)) {
222	$ret = false;
223	}
224	}
225	} else {
226	foreach ($opts[1] as $file) {
227	$delete = (is_dir($file)) ? 'rmdir' : 'unlink';
228	if (!@$delete($file)) {
229	$ret = false;
230	}
231	}
232	}
233	return $ret;
234	}
235
236	/**
237	* Make directories.
238	*
239	* The -p option will create parent directories
240	* @param string $args the name of the director(y\|ies) to create
241	* @return bool True for success
242	* @static
243	* @access public
244	*/
245	function mkDir($args)
246	{
247	$opts = System::_parseArgs($args, 'pm:');
248	if (PEAR::isError($opts)) {
249	return System::raiseError($opts);
250	}
251
252	$mode = 0777; // default mode
253	foreach ($opts[0] as $opt) {
254	if ($opt[0] == 'p') {
255	$create_parents = true;
256	} elseif ($opt[0] == 'm') {
257	// if the mode is clearly an octal number (starts with 0)
258	// convert it to decimal
259	if (strlen($opt[1]) && $opt[1]{0} == '0') {
260	$opt[1] = octdec($opt[1]);
261	} else {
262	// convert to int
263	$opt[1] += 0;
264	}
265	$mode = $opt[1];
266	}
267	}
268
269	$ret = true;
270	if (isset($create_parents)) {
271	foreach ($opts[1] as $dir) {
272	$dirstack = array();
273	while ((!file_exists($dir) \|\| !is_dir($dir)) &&
274	$dir != DIRECTORY_SEPARATOR) {
275	array_unshift($dirstack, $dir);
276	$dir = dirname($dir);
277	}
278
279	while ($newdir = array_shift($dirstack)) {
280	if (!is_writeable(dirname($newdir))) {
281	$ret = false;
282	break;
283	}
284
285	if (!mkdir($newdir, $mode)) {
286	$ret = false;
287	}
288	}
289	}
290	} else {
291	foreach($opts[1] as $dir) {
292	if ((@file_exists($dir) \|\| !is_dir($dir)) && !mkdir($dir, $mode)) {
293	$ret = false;
294	}
295	}
296	}
297
298	return $ret;
299	}
300
301	/**
302	* Concatenate files
303	*
304	* Usage:
305	* 1) $var = System::cat('sample.txt test.txt');
306	* 2) System::cat('sample.txt test.txt > final.txt');
307	* 3) System::cat('sample.txt test.txt >> final.txt');
308	*
309	* Note: as the class use fopen, urls should work also (test that)
310	*
311	* @param string $args the arguments
312	* @return boolean true on success
313	* @static
314	* @access public
315	*/
316	function &cat($args)
317	{
318	$ret = null;
319	$files = array();
320	if (!is_array($args)) {
321	$args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
322	}
323
324	$count_args = count($args);
325	for ($i = 0; $i < $count_args; $i++) {
326	if ($args[$i] == '>') {
327	$mode = 'wb';
328	$outputfile = $args[$i+1];
329	break;
330	} elseif ($args[$i] == '>>') {
331	$mode = 'ab+';
332	$outputfile = $args[$i+1];
333	break;
334	} else {
335	$files[] = $args[$i];
336	}
337	}
338	$outputfd = false;
339	if (isset($mode)) {
340	if (!$outputfd = fopen($outputfile, $mode)) {
341	$err = System::raiseError("Could not open $outputfile");
342	return $err;
343	}
344	$ret = true;
345	}
346	foreach ($files as $file) {
347	if (!$fd = fopen($file, 'r')) {
348	System::raiseError("Could not open $file");
349	continue;
350	}
351	while ($cont = fread($fd, 2048)) {
352	if (is_resource($outputfd)) {
353	fwrite($outputfd, $cont);
354	} else {
355	$ret .= $cont;
356	}
357	}
358	fclose($fd);
359	}
360	if (is_resource($outputfd)) {
361	fclose($outputfd);
362	}
363	return $ret;
364	}
365
366	/**
367	* Creates temporary files or directories. This function will remove
368	* the created files when the scripts finish its execution.
369	*
370	* Usage:
371	* 1) $tempfile = System::mktemp("prefix");
372	* 2) $tempdir = System::mktemp("-d prefix");
373	* 3) $tempfile = System::mktemp();
374	* 4) $tempfile = System::mktemp("-t /var/tmp prefix");
375	*
376	* prefix -> The string that will be prepended to the temp name
377	* (defaults to "tmp").
378	* -d -> A temporary dir will be created instead of a file.
379	* -t -> The target dir where the temporary (file\|dir) will be created. If
380	* this param is missing by default the env vars TMP on Windows or
381	* TMPDIR in Unix will be used. If these vars are also missing
382	* c:\windows\temp or /tmp will be used.
383	*
384	* @param string $args The arguments
385	* @return mixed the full path of the created (file\|dir) or false
386	* @see System::tmpdir()
387	* @static
388	* @access public
389	*/
390	function mktemp($args = null)
391	{
392	static $first_time = true;
393	$opts = System::_parseArgs($args, 't:d');
394	if (PEAR::isError($opts)) {
395	return System::raiseError($opts);
396	}
397
398	foreach ($opts[0] as $opt) {
399	if ($opt[0] == 'd') {
400	$tmp_is_dir = true;
401	} elseif ($opt[0] == 't') {
402	$tmpdir = $opt[1];
403	}
404	}
405
406	$prefix = (isset($opts[1][0])) ? $opts[1][0] : 'tmp';
407	if (!isset($tmpdir)) {
408	$tmpdir = System::tmpdir();
409	}
410
411	if (!System::mkDir(array('-p', $tmpdir))) {
412	return false;
413	}
414
415	$tmp = tempnam($tmpdir, $prefix);
416	if (isset($tmp_is_dir)) {
417	unlink($tmp); // be careful possible race condition here
418	if (!mkdir($tmp, 0700)) {
419	return System::raiseError("Unable to create temporary directory $tmpdir");
420	}
421	}
422
423	$GLOBALS['_System_temp_files'][] = $tmp;
424	if (isset($tmp_is_dir)) {
425	//$GLOBALS['_System_temp_files'][] = dirname($tmp);
426	}
427
428	if ($first_time) {
429	PEAR::registerShutdownFunc(array('System', '_removeTmpFiles'));
430	$first_time = false;
431	}
432
433	return $tmp;
434	}
435
436	/**
437	* Remove temporary files created my mkTemp. This function is executed
438	* at script shutdown time
439	*
440	* @static
441	* @access private
442	*/
443	function _removeTmpFiles()
444	{
445	if (count($GLOBALS['_System_temp_files'])) {
446	$delete = $GLOBALS['_System_temp_files'];
447	array_unshift($delete, '-r');
448	System::rm($delete);
449	$GLOBALS['_System_temp_files'] = array();
450	}
451	}
452
453	/**
454	* Get the path of the temporal directory set in the system
455	* by looking in its environments variables.
456	* Note: php.ini-recommended removes the "E" from the variables_order setting,
457	* making unavaible the $_ENV array, that s why we do tests with _ENV
458	*
459	* @static
460	* @return string The temporary directory on the system
461	*/
462	function tmpdir()
463	{
464	if (OS_WINDOWS) {
465	if ($var = isset($_ENV['TMP']) ? $_ENV['TMP'] : getenv('TMP')) {
466	return $var;
467	}
468	if ($var = isset($_ENV['TEMP']) ? $_ENV['TEMP'] : getenv('TEMP')) {
469	return $var;
470	}
471	if ($var = isset($_ENV['USERPROFILE']) ? $_ENV['USERPROFILE'] : getenv('USERPROFILE')) {
472	return $var;
473	}
474	if ($var = isset($_ENV['windir']) ? $_ENV['windir'] : getenv('windir')) {
475	return $var;
476	}
477	return getenv('SystemRoot') . '\temp';
478	}
479	if ($var = isset($_ENV['TMPDIR']) ? $_ENV['TMPDIR'] : getenv('TMPDIR')) {
480	return $var;
481	}
482	return realpath('/tmp');
483	}
484
485	/**
486	* The "which" command (show the full path of a command)
487	*
488	* @param string $program The command to search for
489	* @param mixed $fallback Value to return if $program is not found
490	*
491	* @return mixed A string with the full path or false if not found
492	* @static
493	* @author Stig Bakken <ssb@php.net>
494	*/
495	function which($program, $fallback = false)
496	{
497	// enforce API
498	if (!is_string($program) \|\| '' == $program) {
499	return $fallback;
500	}
501
502	// full path given
503	if (basename($program) != $program) {
504	$path_elements[] = dirname($program);
505	$program = basename($program);
506	} else {
507	// Honor safe mode
508	if (!ini_get('safe_mode') \|\| !$path = ini_get('safe_mode_exec_dir')) {
509	$path = getenv('PATH');
510	if (!$path) {
511	$path = getenv('Path'); // some OSes are just stupid enough to do this
512	}
513	}
514	$path_elements = explode(PATH_SEPARATOR, $path);
515	}
516
517	if (OS_WINDOWS) {
518	$exe_suffixes = getenv('PATHEXT')
519	? explode(PATH_SEPARATOR, getenv('PATHEXT'))
520	: array('.exe','.bat','.cmd','.com');
521	// allow passing a command.exe param
522	if (strpos($program, '.') !== false) {
523	array_unshift($exe_suffixes, '');
524	}
525	// is_executable() is not available on windows for PHP4
526	$pear_is_executable = (function_exists('is_executable')) ? 'is_executable' : 'is_file';
527	} else {
528	$exe_suffixes = array('');
529	$pear_is_executable = 'is_executable';
530	}
531
532	foreach ($exe_suffixes as $suff) {
533	foreach ($path_elements as $dir) {
534	$file = $dir . DIRECTORY_SEPARATOR . $program . $suff;
535	if (@$pear_is_executable($file)) {
536	return $file;
537	}
538	}
539	}
540	return $fallback;
541	}
542
543	/**
544	* The "find" command
545	*
546	* Usage:
547	*
548	* System::find($dir);
549	* System::find("$dir -type d");
550	* System::find("$dir -type f");
551	* System::find("$dir -name *.php");
552	* System::find("$dir -name .php -name .htm*");
553	* System::find("$dir -maxdepth 1");
554	*
555	* Params implmented:
556	* $dir -> Start the search at this directory
557	* -type d -> return only directories
558	* -type f -> return only files
559	* -maxdepth <n> -> max depth of recursion
560	* -name <pattern> -> search pattern (bash style). Multiple -name param allowed
561	*
562	* @param mixed Either array or string with the command line
563	* @return array Array of found files
564	* @static
565	*
566	*/
567	function find($args)
568	{
569	if (!is_array($args)) {
570	$args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
571	}
572	$dir = realpath(array_shift($args));
573	if (!$dir) {
574	return array();
575	}
576	$patterns = array();
577	$depth = 0;
578	$do_files = $do_dirs = true;
579	$args_count = count($args);
580	for ($i = 0; $i < $args_count; $i++) {
581	switch ($args[$i]) {
582	case '-type':
583	if (in_array($args[$i+1], array('d', 'f'))) {
584	if ($args[$i+1] == 'd') {
585	$do_files = false;
586	} else {
587	$do_dirs = false;
588	}
589	}
590	$i++;
591	break;
592	case '-name':
593	$name = preg_quote($args[$i+1], '#');
594	// our magic characters ? and * have just been escaped,
595	// so now we change the escaped versions to PCRE operators
596	$name = strtr($name, array('\?' => '.', '\' => '.'));
597	$patterns[] = '('.$name.')';
598	$i++;
599	break;
600	case '-maxdepth':
601	$depth = $args[$i+1];
602	break;
603	}
604	}
605	$path = System::_dirToStruct($dir, $depth, 0, true);
606	if ($do_files && $do_dirs) {
607	$files = array_merge($path['files'], $path['dirs']);
608	} elseif ($do_dirs) {
609	$files = $path['dirs'];
610	} else {
611	$files = $path['files'];
612	}
613	if (count($patterns)) {
614	$dsq = preg_quote(DIRECTORY_SEPARATOR, '#');
615	$pattern = '#(^\|'.$dsq.')'.implode('\|', $patterns).'($\|'.$dsq.')#';
616	$ret = array();
617	$files_count = count($files);
618	for ($i = 0; $i < $files_count; $i++) {
619	// only search in the part of the file below the current directory
620	$filepart = basename($files[$i]);
621	if (preg_match($pattern, $filepart)) {
622	$ret[] = $files[$i];
623	}
624	}
625	return $ret;
626	}
627	return $files;
628	}
629	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: